Use a C # 2.0 command line compiler

/// Display a user support.

///

Public Static Void PrintMessage (String MSG)

{

Console.WriteLine ("You Said: {0}", MSG);

}

Compile these files to create a new assembly called MyCodelibrary2.dll, as shown below:

CSC / T: library /out:mycodelibrary2.dll * .cs Finally, place the copy of this new code library into the MyClient folder (Figure 8).

Figure 8. New code in myclient folder

Now, if our current client program wants to reference mycodelibrary.dll and mycodelibrary2.dll, we do the following:

CSC / T: EXE /R: MYCODELIBRARY.DLL (Mycodelibrary2.dll * .cs

The compiler tells us that we have introduced a name conflict, because these two assemblies define a class named SimpleType:

SimpleTypeClient.cs (13,7): Error CS0433: The Type 'MyCodelibrary.sIMpleType'

EXISTS in Both 'C: /mycsharpcode/myclient/mycodelibrary.dll' and

'c: /mycsharpcode/myclient/mycodelibrary2.dll'

At first glance, you may think that it can be repaired by using a fully qualified name in the client code. However, this cannot be corrected, because the two assemblies define the same fully qualified name (MyCodelibrary.SIMpleType).

With the new alias option for using the / reference flag, we can generate a unique name for each code library referenced. After we do this, we can update the client code to associate a type with a specific assembly.

The first step is to modify the SimpleTypeClient.cs file to use the alias that we will specify by the new Extern Alias ​​syntax:

// Extern Alias ​​Statements Must Be

// listed Before All Other Code!

Extern alias ST1;

Extern Alias ​​ST2;

Using system;

Namespace MyClientApp

{

Public class myapp

{

Public static void main ()

{

// bind assembly to type using the '::' Operator.

St1 :: mycodelibrary.simpletype.displayenvironment ();

St2 :: mycodelibrary.simpletype.printMessage ("Hello!");

Console.readline ();

}

}

}

Please note that we have already used the C # 2.0 Extern Alias ​​statement to capture alias defined in the command line. Here, ST1 (Simple Type 1) is an alias defined for MyCodelibrary.dll, and ST2 is mycodelibrary2.dll alias:

CSC /R :st1=mycodelibrary.dll /r :st2=mycodelibrary2.dll * .cs

Given these alias, please pay attention to the main () method how to use the C # 2.0 range resolution operator (: :) to bind the program set name to the type itself:

// this Says "I want the mycodelibrary.simpletype class

// That is defined in mycodelibrary.dll ".

St1 :: mycodelibrary.simpletype.displayenvironment ();

Furthermore, this variant of the / reference option provides a way to avoid name collisions (when two assemblies with unique names contain the names of the same name). Back to top

Generate multi-file assemblies using / addModule

As you may already know, the multi-file assembly provides a way to decompose a single .NET binary into multiple smaller small files, which proves to be helpful when downloading the .NET module. The ultimate effect of multi-file assembly is to make a set of files work like a separate reference and version control.

The multi-file assembly contains a master * .dll, which contains an assembly list. Other modules of the multi-file assembly (according to the agreement, they use the * .NetModule file extension) to be recorded in the list of main modules, and is loaded by the CLR on demand. To date, the only way to generate multi-file assemblies is to use the command line compiler.

To illustrate the process, create a new subdirectory called multifileASM in the C: / MyCsharpcode directory. Our goal is to create a multi-file assembly called AirVehicles. The main module (airvehicles.dll) will contain a single type of Helicopter (later definition). The assembly list catches an additional module (UFOS.NETMODULE), which defines a class type named UFO:

// ufo.cs

Using system;

Using system.windows.forms;

Namespace Airvehicles

{

Public Class UFO

{

Public void abductionhuman ()

{

MessageBox.show ("Resistance Is Futile);

}

}

}

To compile ufo.cs as a .NET module, specify / t: module as the target type, which will automatically follow the * .NetModule naming agreement (please recall, the default response file automatically references System.Windows.Forms.dll, so We don't need to explicitly reference the library):

CSC / T: module ufo.cs

If you want to load Ufo.netModule into ildasm.exe, you will find a module level list that describes the name and external reference set of the module (note, *. NetModules no specified version number, because that is the main module work):

.assembly extern mscorlib {...}

.assembly extern system.windows.forms {...}

.Module ufo.netModule

Now, create a new file called Helicopter.cs, which will be used to compile the main module airvehicles.dll:

// Helicopter.cs

Using system;

Using system.windows.forms;

Namespace Airvehicles

{

Public Class Helicopter

{

Public void takeoff ()

{

Messagebox.show ("Helicopter Taking Off!");

}

}

}

Assuming AirVehicles.dll is the main module of the multi-file assembly, you will need to specify / T: library flag. However, because you also want to encode the ufo.neetmodule binary to the assembly list, you must also specify / addModule options:

CSC / T: library /addmodule:ufo.neetmodule /out:airvehicles.dll helicopter.cs If you want to analyze the assembly level list included in the airvehicles.dll binary (using ildasm.exe), you will find that ufo.netmodule is indeed Is the .file CIL instruction record:

.assembly airvehicles {...}

.file ufo.neetmodule

Multi-file assembly users can share this fact that they want to collect by a large number of binary files. In fact, it will appear to be identical to the behavior of the single file assembly. In order to make this article more interesting, let's create a client application based on a Windows Form.

Back to top

Create a Windows Form Application

Our next example project will be a Windows Form Application using the AirVehicles.dll multi-file assembly. Create a new subdirectory called WinformClient in the C: / Mycsharpcode directory. Create a class derived from the form that defines a single Button type. When it is clicked, you will create a Helicopter and a UFO type and call them:

Using system;

Using system.windows.forms;

Using airvehicles;

Public Class MyForm: Form

{

Private button BTNUSEVEHICLES = New Button ();

Public myform ()

{

THIS.TEXT = "My Multifile ASM Client";

btnusevehicles.text = "Click Me";

Btnusevehicles.width = 100;

Btnusevehicles.height = 100;

Btnusevehicles.top = 10;

Btnusevehicles.Left = 10;

Btnusevehicles.click = new eventhandler (btnusevehicles_click);

This.Controls.Add (btnusevehicles);

}

Private Void Btnusevehicles_Click (Object O, Eventargs E)

{

Helicopter h = new helicopter ();

H.Takeoff ();

UFO U = New ufo ();

u.abducthuman ();

}

Private static void main ()

{

Application.run (new myform ());

}

}

Note Before proceeding, make sure that the airvehicals.dll and ufo.netModule binarys are copied to the WinformClient directory.

To compile the application as a Windows Form, make sure that Winexe is specified as the modification of the / target flag. Note that when you reference the multi-file assembly, you only have to specify the name of the main module:

CSC / T: Winexe /R :airvehicles.dll * .cs

After running your program and click the button, you should see each message box as expected. Figure 9 shows a message box I created.

Figure 9. Sample Message Box

Back to top

Use resources via CSC.exe

The next agenda is to analyze how to use CSC.exe to embed resources (eg, string tables or image files) into the .NET program. First, you can specify the path to the Win32 * .ico file using the / Win32In option. Suppose you have placed a icon file called HappyDude.ico in the application directory of the current Windows Form application. To set the happydude.ico to an icon for the executable, issue the following commands: CSC / T: Winexe /Win32icon:happyDude.ico /R :airvehicles.dll * .cs

At this point, the executable assembly should be updated, as shown in Figure 10.

Figure 10. Updated executable assembly

In addition to using the / Win32icon allocated application icon, CSC.exe also provides three additional resource-centered options (Table 5).

Table 5. CSC.exe's resource-centered options

Csc.exe's resource-centered option definition / resource is embedded in the current program set in the * .resources file inside the * .resources file. Note that you can "embed resources" in public way "by this option for all users, or" in private way "to embed resources for only the assembly usage. / LinkResource records links to external resource files in the assembly list, but actually not embedded in the resource itself. / Win32RES allows you to embed resources existing in old-style * .res files.

Before we understand how to embed resources into our program, let me introduce the nature of the resources in the .NET platform. As you may already know, the .NET resource is usually present as a group / value pair recorded as an XML (*. RESX file) or simple text (* .txt). This XML / text file is then converted to an equivalent binary, which uses a * .resources file extension. These binaries are then embedded in the program set and recorded in the list. When you need to read resources from the program, System.Resources namespace will provide a lot of types to complete this work, which is the most worthless of the ResourceManager class.

Although you must manually create a * .resx file, you'd better use the ResGen.exe command line tool (or you can of course use the Visual Studio .Net itself). Although this article does not intend to describe all of the details of ResGen.exe, let us exercise a simple example.

Embed resources using / resource

Create a new directory called MyResourceApp under Mycsharpcode. In this directory, create a new file called MyStrings.txt using NotePad.exe, and make it contain some interesting name / value pairs you selected. E.g:

# A List of Personal Data

#

Company = intertech training

LastClasstaught = .NET Security

LastPresentation = SD EAST BEST PRACTICES

Favoritegameconsole = Xbox

FavoriteComic = CEREBUS

Now, use the command prompt, convert the * .txt file to a XML-based * .resx file by the following command:

Resgen mystrings.txt mystrings.resx

If you open this file with NotePad.exe, you will find a number of XML elements that describe name / value, for example:

intertech training

. Net security

To convert the * .resx file into a binary * .resources file, you only need to update the file extension as the parameter of ResGen.exe:

Resgen mystrings.resx mystrings.resources

At this point, we have a binary resource file called MyStrings.Resources. The use of CSC.exe can be used to embed this data into the .NET program set. Suppose we have created the following C # files located in your MyResourceApp directory (RESAPP.CS):

// this Simple App Reads Embedded

// resources and displays the the the the THE

// console.

Using system;

Using System.Resources;

Using system.reflection;

Public Class ResApp

{

Private static void main ()

{

ResourceManager RM = New ResourceManager ("MyStrings",

AskEMBLY.GETEXECUTINGASSEMBLY ());

Console.Writeline ("Last Taught A {0} Class.",

Rm.getstring ("LastClasstaught"))));

}

}

To compile this assembly with respect to your mystrings.resources file, enter the following command:

CSC /Resource: Mystrings.Resources * .cs

Because I have not specified the / out flag, in this example, the name of our executable will be based on the file resapp.exe that defines main (). If everything is normal, you should find that the output is similar to Figure 11 after execution.

Figure 11. Output

I hope that you can easily create single files and multi-files .NET assemblies (with resources!) Using CSC.exe and selected text editor. You have learned the most common command line options for CSC.exe, and the rest of this article will analyze some options that are not common but still help.

If you are willing to continue learning, create a new directory called Finalexample in the Mycsharpcode folder.

Back to top

Use / define to define a pre-processor symbol

Although the C # compiler does not really preprocess code, the language does allow us to define the compiler and interact with it using preprocessor symbols similar to C. With the C # DEFINE syntax, you can create tags that control the execution path inside the application.

Note You must list the defined symbols before using any statement or other C # type definition.

In order to take advantage of common examples, assume that you want to define a symbol named debug. To do this, create a new file called FINALEX.CS and save it in the Mycsharpcode / Finalexample directory:

// define a 'preprocessor' symbol named debug. # Define debug

Using system;

Public Class FinalExample

{

Public static void main ()

{

#if Debug

Console.writeline ("Debug Symbol Defined");

#ELSE

Console.WriteLine ("Debug Not De De Defined");

#ENDIF

}

}

Note that after we use #define to define the symbol, we can use the # if, # else, and #ndif keywords to check and respond to the symbol. If you compile the program now, you should see that when FINALEX.EXE is executed, the message "debug symbol defined" is displayed on the console:

CSC * .cs

However, if you comment out the symbol definition:

// #define debug

The output will be as expected ("Debug Not De De DEfined").

During the development and testing of the .NET assembly, the command line definition symbol may be helpful. This can quickly specify symbols quickly without having to update the code base. For instructions, assume that you want to defbug symbols on the command line, please use the / define option:

CSC / Define: Debug * .cs

When you run the application again, you should see "debug symbol defined" - even if the #define statement has been commented away.

Back to top

CSC.exe's debugging-centric option

Even the best programmers sometimes find the need to debug their code base. Although I assume that most readers prefer to use Visual Studio .NET to debug activities, but some of the CSC.exe's options (Table 6) will be worthwhile.

Table 6. CSC.exe's debugging option

Csc.exe's debug-centered option definition / debug indicates that CSC.exe issues a * .pdb file for debugging tools (for example, Cordbg.exe, DBGCLR.exe or Visual Studio). / Warnaserror treats all warnings as a serious error. / WARN allows you to specify the currently compiled warning level (0, 1, 2, 3 or 4). / NOWARN allows you to disable a specific C # compiler warning. / bugreport If the application fails at runtime, the option generates an error log. This option prompts you to enter corrective information to send to anywhere you want (for example, QA Group).

To explain the usage of the / debug option, we first need to insert some coding errors in our Finalex.cs code file. Add the following code to the current main () method:

// CREATE AN ARRAY.

String [] mYStrings = {"csc.exe is cool"};

// Go out of bounds.

Console.writeLine (MyStrings [1]);

As you can see, we tried to use the cross-ribs to access our array content. If you recompile and run the program, you get indexoutofrangeexception. Although we can clearly point out the mistake, if it is a more complicated error, what should I do?

To debug the assembly created using CSC.exe, the first step is to generate a * .pdb file that contains the information you need to use a variety of .NET debug utilities. To do this, enter the following commands (they are equivalent): CSC / Debug * .cs

CSC / Debug * .cs

At this point, you should see a new file called Finalex.pdb in the application directory, as shown in Figure 12.

Figure 12. New Finalex.pdb in the application directory

You can define the / debug flag according to the situation. When you specify / debug: Full (it is a default mark), the assembly will be modified in an appropriate manner to allow it to attach it to the debugger currently executing. Since this option can influence the size and speed of the generated .NET assembly, make sure that this option is specified only during the debugging process. Because Full is the default behavior of the / debug flag, all of the above options are functionally equivalent:

CSC / Debug * .cs

CSC / Debug * .cs

CSC / Debug: full * .cs

On the other hand, specify / debug: PDBONLY can generate a * .pdb file, as well as an assembly that can only be debugged when the program is started directly by the debugging tool:

CSC / Debug: PDBONLY * .CS

In any case, since you have the required * .pdb file, you can use many debugging tools (Cordbg.exe, DBGCLR.EXE or VISUAL Studio) to debug applications. In order not to deviate from the characteristics of the command line, we will use the Cordbg.exe utility to debug the program:

Cordbg finalex.exe

After the debugging session begins, you can use the SO (Single Step Execution) command to perform each code line. When you click the wrong code line, you can find the code dump shown in Figure 13.

Figure 13. Single step execution command code dump

To terminate the Cordbg.exe utility, type EXIT and press Return.

Note This paper is not to explain the usage of the .NET debugging tool. If you want to know more about the process of debugging in the command line, find "Cordbg.exe" in the Visual Studio help system.

Back to top

Miscellaneous

At this point, you have learned the details behind the core options of the C # command line compiler. In order to make this paper more complete, Table 7 briefly describes the rest of the remaining flags I have not discussed.

Table 7. The rest of CSC.exe

CSC.EXE Option Definition / BaseAddress This option allows you to specify the expected base address of load * .dll. By default, the base address is selected by the CLR. / Checked Specifies whether an integer operation of overflow data type limits will cause anomalus during runtime. / CodePage Specifies the code page for all source code files to be used to compile. / FileAlign This option controls the section size adjustment inside the output assembly (512, 1024, 2048, 4096 or 8192 bytes). If the target device is a handheld device (eg, a Pocket PC), you can use / fileAlign to specify the minorted section that may exist. / LangVersion This option indicates that the compiler only uses ISO-1 C # language function, which basically can be concatenated as C # 1.0 language function. / main If the current project defines a plurality of main () methods (this may be helpful during unit test), you can use this flag to specify which main () method is performed when the assembly load is loaded. / NostDLIB By default, the assembly list automatically references mscorlib.dll. Specify this option can prohibit this line. / Optimize When (/ Optimize ) is enabled, you can indicate that the compiler generates minimal and fastest assemblies. This option will issue metadata that also indicates the CLR to optimize the code at runtime. / Platform This logo tells the compiler to optimize the assembly for 32-bit or 64-bit processor. In general, this option is only useful when the C # code base uses the P / Invoke and / or unsafe code structure. The default is "Anycpu". / UNSAFE When enabled, this option makes a C # file to declare an unsafe scope, which is usually used to manipulate the C style pointer. / UTF8output This option tells the compiler to use the UTF-8 encoding output data. It is important to understand that for most .NET projects, the options listed in Table 7 can only provide very few benefits. In view of this, please refer to MSDN if you need further details.

Back to top

summary

This article introduces you to the process of generating an assembly using the C # command line compiler. As you have learned, most work can be done using two flags - / target and / reference. In addition to analyzing the core logo of CSC.exe, this paper also explains the benefits of the response file and the structure of the multi-file assembly.

Although this article does not provide all the details of each option for CSC.exe, I hope that you can easily use the Visual Studio 2005 document to understand the rest of the flag.

I wish you a happy company!

Andrew Troelsen is a Microsoft MVP, who served as consultants and trainers in Intertech Training. Andrew creates many books, including winning C # and the .NET Platform Second Edition. He writes a column article every month, and he studies how to use SSCLI, Portible.Net and Mono CLI distribution in UNIX-based systems in these articles.

Go to the original English page

Back to top