Creating, Editing, Compiling, and Running C# Source Code

Once you have written your C# code, it is time to compile and run it. You have a choice of which .NET implementation(s) to use—sometimes referred to as the .NET framework(s). Generally, the implementation is packaged into a software development kit (SDK). The SDK includes the compiler, the runtime execution engine, the framework of pragmatically accessible functionality that the runtime can access (see “Application Programming Interface” later in the chapter), and any additional tooling (such as a build engine for automating build steps) that might be bundled with the SDK. Given that C# has been publicly available since 2000, there are several different .NET frameworks to choose from (see “Multiple .NET Frameworks” later in the chapter).

For each .NET framework, the installation instructions vary depending on which operating system you are developing on and which .NET framework you select. For this reason, I recommend you visit https://dotnet.microsoft.com/download for download and installation instructions, if necessary, selecting first the .NET framework and then the package to download based on which operating system you will be developing for. While I could provide further details here, the .NET download site has the most updated instructions for each combination supported.

If you are unsure about which .NET framework to work with, choose .NET Core by default. It works on Linux, macOS, and Microsoft Windows and is the implementation where the .NET development teams are applying the majority of their investments. Furthermore, because of the cross-platform capabilities, I will favor .NET Core instructions inline within the chapters.

There are also numerous ways to edit your source code, including the most rudimentary of tools, such as Notepad on Windows, TextEdit on Mac/macOS, or vi on Linux. However, you’re likely to want something more advanced so that at least your code is colorized. Any programming editor that supports C# will suffice. If you don’t already have a preference, I recommend you consider the open source editor Visual Studio Code (https://code.visualstudio.com). To optimize working with C# in Visual Studio Code, you will want to install the C# extension as shown in Figure 1.1. Or, if you are working on Windows or Mac, consider Microsoft Visual Studio 2019 (or later)—see https://visualstudio.microsoft.com/vs/. Both are available free of charge.

In the next two sections, I provide instructions for both editors. For Visual Studio Code, we rely on the command-line interface (CLI) tool dotnet CLI for creating the initial C# program scaffolding in addition to compiling and running the program. For Windows and Mac, we focus on using Visual Studio 2019.

1>
2> mkdir ./HelloWorld
3> cd ./HelloWorld/
4> dotnet new console
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on C:DataEssentialCSharpYogaX11SCCsrc
Chapter01HelloWorldHelloWorld.csproj...
  Restore completed in 100.38 ms for C:DataEssentialCSharpYogaX11SCC
srcChapter01HelloWorldHelloWorld.csproj.
Restore succeeded.
5> dotnet run
Hello World!
6> echo '
class HelloWorld
{
 static void Main()
 {
   System.Console.WriteLine("Hello. My name is Inigo Montoya.");
 }
}
' > Program.cs
7> dotnet run
Hello. My name is Inigo Montoya.

> Hello. My name is Inigo Montoya.More output
Press any key to close this window . . .

Debugging

One significant feature of using an IDE is its support for debugging. To try it out, follow these additional steps in either Visual Studio or Visual Studio Code:

1. With Program.cs open, locate your cursor on the System.Console.WriteLine line and click the Debug->Toggle Breakpoint (F9) menu item to activate a breakpoint on that line.

2. Click the Debug->Start Debugging (F5) menu to relaunch the application but this time with debugging activated.

   With Visual Studio Code you will be prompted to select an environment—choose .NET Core—following which a launch.json file and a tasks.json file will be generated. You will then have to restart the debugging by clicking the Debug->Start Debugging (F5) menu.

   Once debugging starts, execution will stop on the line where you set the breakpoint. You can then hover over a variable (e.g., args) to see its value. You can also move the current execution of the program from the current line to another line within the method by dragging the yellow arrow in the left margin of the file window.

3. To continue the program execution, use the Debug->Continue (F5) menu (or the Continue button).

For more information about debugging with Visual Studio 2019. see http://itl.tc/vsdebugging.

With Visual Studio Code, the output will appear in the Debug Console tab (click View->Debug Console or Ctrl+Shift+V to see the “Hello. My name is Inigo Montoya.” output). For more information about debugging with Visual Studio Code, see https://code.visualstudio.com/docs/editor/debugging.

Creating a Project

Whether using dotnet CLI or Visual Studio, there are several files created. The first file is a C# file with the name Program.cs by convention. The name Program is commonly used as the starting point for a console program, even though any name could be used. The .cs extension is the standard convention for all C# files and what the compiler expects to compile into the final program by default. To use the code shown in Listing 1.1, open the Program.cs file and replace its content with Listing 1.1. Before saving the updated file, observe that the only functional difference between Listing 1.1 and what was generated by default is the text within quotations and a semantic difference of where System appears.

While not necessarily required, typically a configuration file called a project file is included as part of the generated source code of your C# project. The project file content will vary from one application type and .NET framework to the next. However, at a minimum, it generally identifies what files to include in the compilation, what application type to build (console, web, mobile, testing project, etc.), which .NET framework to support, and which potential settings are needed to debug or launch the application, along with other dependencies the code may rely on (called libraries). For example, the simple .NET Core console application project file created in the previous section appears in Listing 1.2.

Listing 1.2: Sample .NET Core Console Project File

Click here to view code image

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>
</Project>

In Listing 1.2, the application type is identified as a .NET Core version 3.1 (netcoreapp3.1) console application (Exe). All other settings (such as which C# files to compile) are identified by convention. For example, by default, all *.cs files in the same directory (or subdirectory) as the project file are included in the compile.

Compilation and Execution

The compiled output created by the dotnet build command is an assembly called HelloWorld.dll.⁷ The extension stands for dynamic link library (DLL), and with .NET Core, all assemblies have a .dll extension even if they are console programs, as this one is. By default, the compiled output for a .NET Core application is placed into a subdirectory (./bin/Debug/netcoreapp3.1/). The Debug directory is used because the default configuration is debug. This configuration causes the output to be optimized for debugging rather than for optimal performance. The compiled output will not execute on its own. Rather, it needs the CLI to host the code. For .NET Core applications, this requires using the dotnet.exe (dotnet on Linux and Mac) process as a host process for the application. Hence why the program is executed with the dotnet run command. That said, there is a way to generate a stand-alone executable that includes the necessary runtime files so that installing the dotnet runtime is not required—see the Advanced Topic: Publishing a Stand-Alone Executable.

7. Note that if you use the Microsoft .NET Framework to create a console program, the compiled code is placed into a HelloWorld.exe file that you can execute directly assuming the Microsoft .NET Framework is installed on the computer.

Essential C# Source Code

The source code⁸ associated with the book includes a solution file, EssentialCSharp.sln, which groups together the code from all the chapters. Building, running, and testing the source code is possible with either Visual Studio or the dotnet CLI.

8. The source code available for this book (along with some chapters related to earlier versions of C#) is available for download at https://IntelliTect.com/EssentialCSharp. You can also download the code from GitHub directly at https://github.com/IntelliTect/EssentialCSharp.

Perhaps the simplest approach is to paste the source code into the HelloWorld program created earlier in the chapter and then execute the source code. Alternatively, the source code contains project files for each chapter and a menu from which it is possible to select which listing to run when executing a program, as shown in the next two sections.

C# Keywords

Table 1.1 shows the C# keywords.

* Contextual keyword. Numbers in parentheses (n) identify in which version the contextual keyword was added.

After C# 1.0, no new reserved keywords were introduced to C#. However, some constructs in later versions use contextual keywords, which are significant only in specific locations. Outside these designated locations, contextual keywords have no special significance.⁹ By this method, most C# 1.0 code is compatible with the later standards.¹⁰

9. For example, early in the design of C# 2.0, the language designers designated yield as a keyword, and Microsoft released alpha versions of the C# 2.0 compiler, with yield as a designated keyword, to thousands of developers. However, the language designers eventually determined that by using yield return rather than yield, they could ultimately avoid adding yield as a keyword because it would have no special significance outside its proximity to return.

10. There are some rare and unfortunate incompatibilities, such as the following:

• C# 2.0 requires implementation of IDisposable with the using statement rather than simply using a Dispose() method.

• Some rare generic expressions are different between versions. For example, F(G<A,B>(7)) means F( (G<A), (B>7) ) in C# 1.0, but in C# 2.0, it means to call generic method G<A,B> with argument 7 and pass the result to F.

Identifiers

Like other languages, C# includes identifiers to identify constructs that the programmer codes. In Listing 1.1, HelloWorld and Main are examples of identifiers. The identifiers assigned to a construct are used to refer to the construct later, so it is important that the names the developer assigns are meaningful rather than arbitrary.

A keen ability to select succinct and indicative names is an important characteristic of a strong programmer because it means the resultant code will be easier to understand and reuse. Clarity coupled with consistency is important enough that the Framework Design Guidelines (http://bit.ly/dotnetguidelines) advise against the use of abbreviations or contractions in identifier names and even recommend avoiding acronyms that are not widely accepted. If an acronym is sufficiently well established (e.g., HTML), you should use it consistently. Avoid spelling out the accepted acronym in some cases but not in others. Generally, adding the constraint that all acronyms be included in a glossary of terms places enough overhead on the use of acronyms that they are not used flippantly. Ultimately, select clear, possibly even verbose names—especially when working on a team or when developing a library against which others will program.

There are two basic casing formats for an identifier. Pascal case (henceforth PascalCase), as the .NET framework creators refer to it because of its popularity in the Pascal programming language, capitalizes the first letter of each word in an identifier name; examples include ComponentModel, Configuration, and HttpFileCollection. As HttpFileCollection demonstrates with HTTP, when using acronyms that are more than two letters long, only the first letter is capitalized. The second format, camel case (henceforth camelCase), follows the same convention except that the first letter is lowercase; examples include quotient, firstName, httpFileCollection, ioStream, and theDreadPirateRoberts.

Notice that although underscores are legal, generally there are no underscores, hyphens, or other nonalphanumeric characters in identifier names. Furthermore, C# doesn’t follow its predecessors in that Hungarian notation (prefixing a name with a data type abbreviation) is not used. This convention avoids the variable rename that is necessary when data types change, or the inconsistency introduced due to failure to adjust the data type prefix when using Hungarian notation.

In rare cases, some identifiers, such as Main, can have a special meaning in the C# language.

Type Definition

All executable code in C# appears within a type definition, and the most common type definition begins with the keyword class. A class definition is the section of code that generally begins with class identifier { ... }, as shown in Listing 1.3.

Listing 1.3: Basic Class Declaration

Click here to view code image

class HelloWorld
{
  //...
}

The name used for the type (in this case, HelloWorld) can vary, but by convention, it must be PascalCased. For this example, therefore, other possible names are Greetings, HelloInigoMontoya, Hello, or simply Program. (Program is a good convention to follow when the class contains the Main() method, described next.)

Generally, programs contain multiple types, each containing multiple methods.

Main Method

The location where C# programs begin execution is the Main method, which begins with static void Main(). When you execute the program by typing dotnet run at the command console, the program starts up, resolves the location of Main, and begins executing the first statement as identified in Listing 1.4.

Listing 1.4: Breaking Apart HelloWorld

Although the Main method declaration can vary to some degree, static and the method name, Main, are always required for a program.

Listing 1.5: The Main Method with Parameters and a Return

Click here to view code image

static int Main(string[] args)
{
    //...
}

The designation of the Main method as static indicates that other methods may call it directly off the class definition. Without the static designation, the command console that started the program would need to perform additional work (known as instantiation) before calling the method. (Chapter 6 contains an entire section devoted to the topic of static members.)

Placing void prior to Main() indicates that this method does not return any data. (This is explained further in Chapter 2.)

One distinctive C/C++-style characteristic followed by C# is the use of curly braces for the body of a construct, such as the class or the method. For example, the Main method contains curly braces that surround its implementation; in this case, only one statement appears in the method.

Statements and Statement Delimiters

The Main method includes a single statement, System.Console.WriteLine(), which is used to write a line of text to the console. C# generally uses a semicolon to indicate the end of a statement, where a statement comprises one or more actions that the code will perform. Declaring a variable, controlling the program flow, and calling a method are typical uses of statements.

Since creation of a newline does not separate statements, you can place multiple statements on the same line and the C# compiler will interpret the line as having multiple instructions. For example, Listing 1.6 contains two statements on a single line that, in combination, display Up and Down on two separate lines.

Listing 1.6: Multiple Statements on One Line

Click here to view code image

System.Console.WriteLine("Up");System.Console.WriteLine("Down");

C# also allows the splitting of a statement across multiple lines. Again, the C# compiler looks for a semicolon to indicate the end of a statement. In Listing 1.7, for example, the original WriteLine() statement from the HelloWorld program is split across multiple lines.

Listing 1.7: Splitting a Single Statement across Multiple Lines

Click here to view code image

System.Console.WriteLine(
 Hello. My name is Inigo Montoya.");

Whitespace

The semicolon makes it possible for the C# compiler to ignore whitespace in code. Apart from a few exceptions, C# allows developers to insert whitespace throughout the code without altering its semantic meaning. In Listings 1.6 and 1.7, it didn’t matter whether a newline was inserted within a statement, between statements, or eliminated entirely, and doing so had no effect on the resultant executable created by the compiler.

Frequently, programmers use whitespace to indent code for greater readability. Consider the two variations on HelloWorld shown in Listings 1.8 and 1.9. Although these two examples look significantly different from the original program, the C# compiler sees them as semantically equivalent.

Listing 1.8: No Indentation Formatting

Click here to view code image

class HelloWorld
{
static void Main()
{
System.Console.WriteLine("Hello Inigo Montoya");
}
}

Listing 1.9: Removing Whitespace

Click here to view code image

class HelloWorld{static void Main()
{System.Console.WriteLine("Hello Inigo Montoya");}}

Data Types

Listing 1.10 declares a variable with the data type string. Other common data types used in this chapter are int and char.

• int is the C# designation of an integer type that is 32 bits in size.

• char is used for a character type. It is 16 bits, large enough for (nonsurrogate) Unicode characters.

The next chapter looks at these and other common data types in more detail.

Declaring a Variable

In Listing 1.10, string max is a variable declaration of a string type whose name is max. It is possible to declare multiple variables within the same statement by specifying the data type once and separating each identifier with a comma. Listing 1.11 demonstrates such a declaration.

Listing 1.11: Declaring Two Variables within One Statement

Click here to view code image

string message1, message2;

Because a multivariable declaration statement allows developers to provide the data type only once within a declaration, all variables will be of the same type.

In C#, the name of the variable may begin with any letter or an underscore (_), followed by any number of letters, numbers, and/or underscores. By convention, however, local variable names are camelCased (the first letter in each word is capitalized, except for the first word) and do not include underscores.

Assigning a Variable

After declaring a local variable, you must assign it a value before reading from it. One way to do this is to use the = operator, also known as the simple assignment operator. Operators are symbols used to identify the function the code is to perform. Listing 1.12 demonstrates how to use the assignment operator to designate the string values to which the variables miracleMax and valerie will point.

Listing 1.12: Changing the Value of a Variable

Click here to view code image

class StormingTheCastle
{
  static void Main()
  {
      string valerie;
      string miracleMax = "Have fun storming the castle!";                        
                                                                                  
      valerie = "Think it will work?";                                            

      System.Console.WriteLine(miracleMax);
      System.Console.WriteLine(valerie);

      miracleMax = "It would take a miracle.";                                    
      System.Console.WriteLine(miracleMax);
  }
}

From this listing, observe that it is possible to assign a variable as part of the variable declaration (as it was for miracleMax) or afterward in a separate statement (as with the variable valerie). The value assigned must always be on the right side of the declaration.

Running the compiled program produces the code shown in Output 1.3.

Output 1.3

Click here to view code image

>dotnet run
Have fun storming the castle!
Think it will work?
It would take a miracle.

In this example, we show the command dotnet run explicitly. In future output listings, we will omit this line unless there is something special about the command used to execute the program.

C# requires that local variables be (as determined by the compiler) “definitely assigned” before they are read. Additionally, an assignment results in a value. Therefore, C# allows two assignments within the same statement, as demonstrated in Listing 1.13.

Listing 1.13: Assignment Returning a Value That Can Be Assigned Again

Click here to view code image

class StormingTheCastle
{
  static void Main()
  {
    // ...
    string requirements, miracleMax;
    requirements = miracleMax = "It would take a miracle.";
    // ...
  }
}

Using a Variable

The result of the assignment, of course, is that you can then refer to the value using the variable identifier. Therefore, when you use the variable miracleMax within the System.Console.WriteLine(miracleMax) statement, the program displays “Have fun storming the castle!”, the value of miracleMax, on the console. Changing the value of miracleMax and executing the same System.Console.WriteLine(miracleMax) statement causes the new miracleMax value, “It would take a miracle.”, to be displayed.

Getting Input from the Console

One way to retrieve text that is entered at the console is to use System.Console.ReadLine(). This method stops the program execution so that the user can enter characters. When the user presses the Enter key, creating a newline, the program continues. The output, also known as the return, from the System.Console.ReadLine() method is the string of text that was entered. Consider Listing 1.14 and the corresponding output shown in Output 1.4.

Listing 1.14: Using System.Console.ReadLine()

Click here to view code image

class HeyYou
{
  static void Main()
  {
      string firstName;
      string lastName;

      System.Console.WriteLine("Hey you!");

      System.Console.Write("Enter your first name: ");
      firstName = System.Console.ReadLine();

      System.Console.Write("Enter your last name: ");
      lastName = System.Console.ReadLine();
  }
}

Output 1.4

Hey you!
Enter your first name: Inigo
Enter your last name: Montoya

After each prompt, this program uses the System.Console.ReadLine() method to retrieve the text the user entered and assign it to an appropriate variable. By the time the second System.Console.ReadLine() assignment completes, firstName refers to the value Inigo and lastName refers to the value Montoya.

Listing 1.15: Using System.Console.Read()

Click here to view code image

int readValue;
char character;
readValue = System.Console.Read();
character = (char) readValue;
System.Console.Write(character);

The System.Console.Read() method does not return the input until the user presses the Enter key; no processing of characters will begin, even if the user types multiple characters before pressing the Enter key.

In C# 2.0 and above, you can use System.Console.ReadKey(), which, in contrast to System.Console.Read(), returns the input after a single keystroke. It allows the developer to intercept the keystroke and perform actions such as key validation, restricting the characters to numerics.

Writing Output to the Console

In Listing 1.14, you prompt the user for his or her first and last names using the method System.Console.Write() rather than System.Console.WriteLine(). Instead of placing a newline character after displaying the text, the System.Console.Write() method leaves the current position on the same line. In this way, any text the user enters will be on the same line as the prompt for input. The output from Listing 1.14 demonstrates the effect of System.Console.Write().

The next step is to write the values retrieved using System.Console.ReadLine() back to the console. In the case of Listing 1.16, the program writes out the user’s full name. However, instead of using System.Console.WriteLine() as before, this code uses a slight variation that leverages a C# 6.0 feature known as string interpolation. Notice the dollar sign preceding the string literal in the call to Console.WriteLine; it indicates that string interpolation will be used. Output 1.5 shows the corresponding output.

Listing 1.16: Formatting Using String Interpolation

Click here to view code image

class HeyYou
{
  static void Main()
  {
      string firstName;
      string lastName;

      System.Console.WriteLine("Hey you!");

      System.Console.Write("Enter your first name: ");
      firstName = System.Console.ReadLine();

      System.Console.Write("Enter your last name: ");
      lastName = System.Console.ReadLine();

      System.Console.WriteLine(
        $"Your full name is { firstName } { lastName }.");
  }
}

Output 1.5

Click here to view code image

Hey you!
Enter your first name: Inigo
Enter your last name: Montoya

Your full name is Inigo Montoya.

Instead of writing out “Your full name is” followed by another Write statement for firstName, a third Write statement for the space, and finally a WriteLine statement for lastName, Listing 1.16 writes out the entire output using C# 6.0’s string interpolation. With string interpolation, the compiler interprets the interior of the curly brackets within the string as regions in which you can embed code (expressions) that the compiler will evaluate and convert to strings. Rather than executing lots of code snippets individually and combining the results as a string at the end, string interpolation allows you to do this in a single step. This makes the code easier to understand.

Prior to C# 6.0, C# used a different approach, that of composite formatting. With composite formatting, the code first supplies a format string to define the output format—see Listing 1.17.

Listing 1.17: Formatting Using System.Console.WriteLine()’s Composite Formatting

Click here to view code image

class HeyYou
{
  static void Main()
  {
      string firstName;
      string lastName;

      System.Console.WriteLine("Hey you!");

      System.Console.Write("Enter your first name: ");
      firstName = System.Console.ReadLine();

      System.Console.Write("Enter your last name: ");     
      lastName = System.Console.ReadLine();               

      System.Console.WriteLine(
        "Your full name is {0} {1}.", firstName, lastName);
  }
}

In this example, the format string is Your full name is {0} {1}. It identifies two indexed placeholders for data insertion in the string. Each placeholder corresponds to the order of the arguments that appear after the format string.

Note that the index value begins at zero. Each inserted argument (known as a format item) appears after the format string in the order corresponding to the index value. In this example, since firstName is the first argument to follow immediately after the format string, it corresponds to index value 0. Similarly, lastName corresponds to index value 1.

Note that the placeholders within the format string need not appear in order. For example, Listing 1.18 switches the order of the indexed placeholders and adds a comma, which changes the way the name is displayed (see Output 1.6).

Listing 1.18: Swapping the Indexed Placeholders and Corresponding Variables

Click here to view code image

System.Console.WriteLine("Your full name is {1}, {0}",
  firstName, lastName);

Output 1.6

Click here to view code image

Hey you!
Enter your first name: Inigo
Enter your last name: Montoya

Your full name is Montoya, Inigo

In addition to not having the placeholders appear consecutively within the format string, it is possible to use the same placeholder multiple times within a format string. Furthermore, it is possible to omit a placeholder. It is not possible, however, to have placeholders that do not have a corresponding argument.

Comments

In this section, we modify the program in Listing 1.17 by adding comments. In no way does this modification change the execution of the program; rather, providing comments within the code can simply make the code more understandable in areas where it isn’t inherently clear. Listing 1.19 shows the new code, and Output 1.7 shows the corresponding output.

Listing 1.19: Commenting Your Code

Output 1.7

Click here to view code image

Hey you!
Enter your first name: Inigo
Enter your last name: Montoya

Your full name is Inigo Montoya.

Despite the inserted comments, compiling and executing the new program produces the same output as before.

Programmers use comments to describe and explain the code they are writing, especially where the syntax itself is difficult to understand, or perhaps a particular algorithm implementation is surprising. Since comments are pertinent only to the programmer reviewing the code, the compiler ignores comments and generates an assembly that is devoid of any trace that comments were part of the original source code.

Table 1.2 shows four different C# comment types. The program in Listing 1.18 includes two of these.

* XML delimited comments were explicitly added only in C# 2.0, but the syntax is compatible with C# 1.0.

A more comprehensive discussion of the XML comments and how they are leveraged to generate API documentation appears in Chapter 10, where we further discuss the various XML tags.

There was a period in programming history when a prolific set of comments implied a disciplined and experienced programmer. This is no longer the case. Instead, code that is readable without comments is more valuable than that which requires comments to clarify what it does. If developers find it necessary to enter comments to clarify what a code block is doing, they should favor rewriting the code more clearly over commenting it. Writing comments that simply repeat what the code clearly shows serves only to clutter the code, decrease its readability, and increase the likelihood of the comments going out of date because the code changes without the comments getting updated.

Common Intermediate Language and ILDASM

As mentioned in the introduction of this section, the C# compiler converts C# code to CIL code and not to machine code. The processor can directly understand machine code; therefore, CIL code needs to be converted before the processor can execute it. Given an assembly, it is possible to view the CIL code using a CIL disassembler utility to deconstruct the assembly into its CIL representation. (The CIL disassembler is affectionately referred to by its Microsoft .NET Framework specific filename, ILDASM, which stands for IL Disassembler.) ILDASM will disassemble an assembly and extract the CIL generated by the C# compiler into text.

The output that results from disassembling a .NET assembly is significantly easier to understand than machine code. For many developers, this may raise a concern because it is easier for programs to be decompiled and algorithms understood without explicitly redistributing the source code. As with any program, CLI based or not, the only foolproof way of preventing disassembly is to disallow access to the compiled program altogether (e.g., hosting a program only on a website instead of distributing it out to a user’s machine). However, if decreased accessibility to the source code is all that is required, there are several obfuscators available. Obfuscators read the IL code and transform it so that it does the same thing but in a way that is much more difficult to understand. This technique prevents the casual developer from accessing the code and creates assemblies that are much more difficult and tedious to decompile into comprehensible code. Unless a program requires a high degree of algorithm security, obfuscators are generally sufficient.

Perhaps the most interesting thing that you can glean from such a listing is how relatively easy it is to follow what the program is doing compared to trying to read and understand machine code (assembler). In the listing, an explicit reference to System.Console.WriteLine() appears. There is a lot of peripheral information to the CIL code listing, but if a developer wanted to understand the inner workings of a C# assembly (or any CLI-based program) without having access to the original source code, it would be relatively easy unless an obfuscator is used. In fact, several free tools are available (such as Red Gate’s Reflector, ILSpy, JustDecompile, dotPeek, and CodeReflect) that can decompile from CIL to C# automatically.

Application Programming Interface

All the methods (or more generically, the members) found on a data type such as System.Console are what define the System.Console’s application programming interface (API). The API defines how a software program interacts with a component. As such, it is found not just with a single data type, but more generically; the combination of all the APIs for a set of data types is said to create an API for the collective set of components. In .NET, for example, all the types (and the members within those types) in an assembly are said to form the assembly’s API. Likewise, given a combination of assemblies, such as those found in .NET Core or the Microsoft .NET Framework, the collective group of assemblies forms a larger API. Often, this larger group of APIs is referred to as the framework—hence the term .NET framework in reference to the APIs exposed by all the assemblies included with .NET Core or the Microsoft .NET Framework. Generically, the API comprises the set of interfaces and protocols (or instructions) for programming against a set of components. In fact, with .NET, the protocols themselves are the rules for how .NET assemblies execute.

C# and .NET Versioning

Since the development life cycle of .NET frameworks is different from that of the C# language, the version of the underlying .NET framework and the corresponding version of the C# language end up with different numbers. This means that if you compile with the C# 5.0 compiler, it will, by default, compile against the Microsoft .NET Framework version 4.6, for example. Table 1.4 is a brief overview of the C# and .NET releases for the Microsoft .NET Framework and .NET Core.

Perhaps the most important framework feature added occurred alongside C# 6.0—that is, cross-platform compilation. In other words, not only would the Microsoft .NET Framework run on Windows, but Microsoft also provided the .NET Core implementation that would run on Linux and macOS. Although the .NET Core is not an equivalent feature set to the full Microsoft .NET Framework, it includes enough functionality that entire (ASP.NET) websites can be hosted on operating systems other than Windows and its Internet Information Server (IIS). This means that with the same code base it is possible to compile and execute applications that run across multiple platforms. .NET Core is an entire SDK with everything from the .NET Compiler Platform (“Roslyn”), which itself executes on Linux and macOS, to the .NET Core runtime, along with tools such as the dotnet command-line utility, dotnet CLI (which was introduced around the time of C# 7.0). Both .NET Core and dotnet CLI have continued to mature to the point of becoming mainstream with C# 8.0 and .NET Core 3.0.

.NET Standard

With so many different implementations of .NET, including multiple versions of each individual .NET framework, the frameworks became furcated as each implementation supported a different set of only somewhat overlapping APIs. As a result, writing code that was reusable across multiple .NET frameworks became difficult because it was necessary to litter the code with conditional checks as to whether a particular API was available. To reduce this complexity, the .NET Standard emerged as a means of defining what APIs were supported by which version of the standard. The .NET Standard defines what a .NET framework needs to support so as to be compliant with each .NET Standard version number. However, since many of the implementations were already released, the decision tree of identifying which API went into which standard was to some extent based on the existing implementations and the association of those existing implementations with a .NET Standard version number.

The latest .NET Standard version at the time of this writing is 2.1. Unfortunately, the latest Microsoft .NET Framework version—4.8—will remain on .NET Standard 2.0, resulting in a lack of support for C# 8.0’s ranges/indices and async streams features. Putting this aside, all the base frameworks have implemented .NET Standard 2.0; thus, it represents a reunification of the furcated APIs found in older versions of each framework and allows cross-compilation against the latest versions of each of the .NET framework implementations.

Microsoft’s vision is that in the future the divergent .NET framework source code will all be merged into a single code base to form .NET 5.0—a reunification of .NET Framework, .NET Core, and Xamarin/Mono. And, with the advent of such a merge, the .NET Standard will become irrelevant—that is, if all the .NET frameworks are created from the same code base, their APIs will automatically be a unified API, so there is no need for a standard to which they must conform. For more information, see http://itl.tc/net5unification.