Professional C# 6 and .NET Core 1.0. Christian Nagel

the following source code into a text editor, and save it with a .cs extension (for example, HelloWorld.cs). The Main method is the entry point for a .NET application. The CLR invokes a static Main method on startup. The Main method needs to be put into a class. Here, the class is named Program, but you could call it by any name. WriteLine is a static method of the Console class. All the static members of the Console class are opened with the using declaration in the first line. using static System.Console opens the static members of the Console class with the result that you don’t need to type the class name calling the method WriteLine (code file Dotnet/HelloWorld.cs):

      As previously mentioned, the syntax of Hello, World changed slightly with C# 6. Previous to C# 6, using static was not available, and only a namespace could be opened with the using declaration. Of course, the following code still works with C# 6 (code file Dotnet/HelloWorld2.cs):

      The using declaration is there to reduce the code with opening a namespace. Another way to write the Hello, World program is to remove the using declaration and add the System namespace to the Console class with the invocation of the WriteLine method (code file Dotnet/HelloWorld3.cs):

      After writing the source code, you need to compile the code to run it.

Compiling with .NET 4.6

      You can compile this program by simply running the C# command-line compiler (csc.exe) against the source file, like this:

      If you want to compile code from the command line using the csc command, you should be aware that the .NET command-line tools, including csc, are available only if certain environment variables have been set up. Depending on how you installed .NET (and Visual Studio), this may or may not be the case on your machine.

      NOTE If you do not have the environment variables set up, you have three options: The first is to add the path to the call of the csc executable. It is located at %Program Files%\MsBuild\14.0\Bin\csc.exe With the dotnet tools installed, you can also find the csc at %ProgramFiles%\dot.net\bin\csc.exe. The second option is to run the batch file %Microsoft Visual Studio 2015 %\Common7\Tools\vsvars32.bat from the command prompt before running csc, where %Microsoft Visual Studio 2015 % is the folder to which Visual Studio 2015 has been installed. The third, and easiest, way is to use the Visual Studio 2015 command prompt instead of the Windows command prompt. To find the Visual Studio 2015 command prompt from the Start menu, select Programs ➪ Microsoft Visual Studio 2015 ➪ Visual Studio Tools. The Visual Studio 2015 command prompt is simply a command prompt window that automatically runs vsvars32.bat when it opens.

      Compiling the code produces an executable file named HelloWorld.exe, which you can run from the command line. You can also run it from Windows Explorer as you would run any other executable. Give it a try:

Compiling an executable this way produces an assembly that contains Intermediate Language (IL) code. The assembly can be read using the Intermediate Language Disassembler (IL DASM) tool. If you run ildasm.exe and open HelloWorld.exe, you see that the assembly contains a Program type and a Main method as shown in Figure 1.3.

Figure 1.3

Double-click the MANIFEST node in the tree view to reveal metadata information about the assembly (see Figure 1.4). This assembly makes use of the mscorlib assembly (because the Console class is located there), and some configuration and version of the HelloWorld assembly.

Figure 1.4

Double-click the Main method to reveal the IL code of this method (see Figure 1.5). No matter what version of the Hello, World code you compiled, the result is the same. The string Hello, World! is loaded before calling the method System.Console.WriteLine that is defined within the mscorlib assembly passing the string. One feature of the CLR is the JIT compiler. The JIT compiler compiles IL code to native code when running the application.

Figure 1.5

Compiling with .NET Core CLI

      Using the new .NET Core Command line (CLI), some preparations need to be done to compile the application without the help of Visual Studio. Let’s have a look at the new tools next to compile the Hello, World sample application.

      Setting Up the Environment

      In case you have Visual Studio 2015 with the latest updates installed, you can immediately start with the CLI tools. Otherwise, you need to install .NET Core and the CLI tools. You can find instructions for the download at http://dotnet.github.io for Windows, Linux, and OS X.

      With Windows, different versions of .NET Core runtimes as well as NuGet packages are installed in the user profile. As you work with .NET, this folder increases in size. Over time as you create multiple projects, NuGet packages are no longer stored in the project itself; they’re stored in this user-specific folder. This has the advantage that you do not need to download NuGet packages for every different project. After you have this NuGet package downloaded, it’s on your system. Just as different versions of the NuGet packages as well as the runtime are available, all the different versions are stored in this folder. From time to time it might be interesting to check this folder and delete old versions you no longer need.

      Installing .NET Core CLI tools, you have the dotnet tools as an entry point to start all these tools. Just start

      to see all the different options of the dotnet tools available.

      The repl (read, eval, print, loop') command is good to learn and test simple features of C# without the need to create a program. Start repl with the dotnet tool:

      This starts an interactive repl session. You can enter the following statements for a Hello, World using a variable:

      The output you’ll see as you enter the last statement is the Hello, World! string.

      The dotnet repl command is not available with Preview 2 of the tools, but it will be available at a later time as an extension.

      Building the Application

      The dotnet tools offer an easy way to create a Hello, World application. You create a new directory HelloWorldApp, and change to this directory with the command prompt. Then enter this command:

      This command creates a Program.cs file that includes the code for the Hello, World program, a NuGet.config file that defines the NuGet server where NuGet packages should be loaded, and project.json, the new project configuration file.

      NOTE With dotnet new you can also create the initial files needed for libraries and ASP.NET web applications (the option – template will be available with RTM). You can also select other programming languages, such as F# and Visual Basic (with the option – lang).

      The created project configuration