Start Microsoft Visual Studio 2017. In Visual Studio, press Ctrl + Shift + N or choose the File | New | Project... menu.

In the New Project dialog, in the Installed | Templates list, expand Other Project Types and select Visual Studio Solutions. In the list at the center, select Blank Solution, type the name Chapter02, change the location to C:Code, and then click on OK, as shown in the following screenshot:

If you were to run File Explorer, you would see that Visual Studio has created a folder named Chapter02 with a Visual Studio solution named Chapter02 inside it, as shown in the following screenshot:

In Visual Studio, navigate to File | Add | New Project..., as shown in the following screenshot. This will add a new project to the blank solution:

In the Add New Project dialog, in the Installed | Templates list, expand Visual C#, and select .NET Core. In the list at the center, select Console App (.NET Core), type the name Ch02_Basics, ensure that .NET Framework 4.6.2 (or later) is selected at the top, and then click on OK, as shown in the following screenshot:

If you were to run File Explorer, you would see that Visual Studio has created a new folder with some files and subfolders inside it. You don't need to know what all these do yet. The code you will write will be stored in the file named Program.cs, as shown in the following screenshot:

In Visual Studio, the Solution Explorer window shows the same files as the ones in the preceding screenshot of the file system.

Some folders and files, for example, the bin folder, are hidden by default in Solution Explorer. At the top of the window is a toolbar button named Show All Files. Toggle this button to show and hide folders and files, as shown in the following screenshot:

If you completed Chapter 1, Hello, C#! Welcome, .NET Core!, then you will already have a Code folder in your user folder. If not, create it, and then create a subfolder named Chapter02, and then a sub-subfolder named Ch02_Basics, as shown in the following screenshot:

Start Visual Studio Code and open the /Chapter02/Ch02_Basics/ folder.

In Visual Studio Code, navigate to View | Integrated Terminal, and enter the following command:

dotnet new console

In the Explorer, click the Program.cs file, and then click Yes and Restore to restore dependencies, as shown in the following screenshot:

The grammar of C# includes statements and blocks.

    var FullName = FirstName + LastName; 

    var TotalPrice = Cost + Tax; // Tax is 20% of the Cost 

    /* 
    This is a multi-line  
    comment. 
    */ 

    using System; // a semicolon indicates the end of a statement 
 
    class Program 
    { 
      static void Main(string[] args) 
      { // the start of a block 
        Console.WriteLine("Hello World!"); // a statement 
      } // the end of a block 
    } 

Some of the 79 predefined, reserved keywords that you will see in this chapter include using, namespace, class, static, int, string, double, bool, var, if, switch, break, while, do, for, and foreach.

Visual Studio 2017 shows C# keywords in blue to make them easier to spot. In the following screenshot, using, namespace, class, static, void, and string are part of the vocabulary of C#:

The equivalent for Visual Studio Code is shown in the following screenshot:

Plain text editors such as Notepad don't help you write correct English, as shown in the following screenshot:

Notepad won't help you write correct C# either:

Microsoft Word helps you write English by highlighting spelling mistakes with red squiggles (it should be ice-cream) and grammatical errors with blue squiggles (sentences should have an uppercase first letter).

Similarly, Visual Studio 2017 and Visual Studio Code help you write C# code by highlighting spelling mistakes (the method name should be WriteLine with an uppercase L) and grammatical errors (statements must end with a semicolon).

Visual Studio 2017 constantly watches what you type and gives you feedback by highlighting problems with colored squiggly lines under your code and showing the Error List window (known as the Problems window in Visual Studio Code), as you can see in the following screenshot:

Visual Studio Code has a similar Problems window, as shown in the following screenshot:

In English, verbs are doing or action words. In C#, doing or action words are called methods. There are literally hundreds of thousands of methods available to C#.

In English, verbs change how they are written based on when in time the action happens. For example, Amir was jumping in the past, Beth jumps in the present, they jumped in the past, and Charlie will jump in the future.

In C#, methods such as WriteLine change how they are called or executed based on the specifics of the action. This is called overloading, which we will cover in more detail in Chapter 6, Building Your Own Types with Object-Oriented Programming. Consider the following example:

    // outputs a carriage-return 
    Console.WriteLine();  
    // outputs the greeting and a carriage-return 
    Console.WriteLine("Hello Ahmed");  
    // outputs a formatted number and date 
    Console.WriteLine("Temperature on {0:D} is {1}°C.", 
      DateTime.Today, 23.4); 

A different analogy is that some words are spelled the same but have different meanings depending on the context.

In English, nouns are names that refer to things. For example, Fido is the name of a dog. The word "dog" tells us the type of thing that Fido is. To order Fido to fetch a ball, we would use his name.

In C#, their equivalents are types, fields, and variables. There are tens of thousands of types available to C#. Note that I don't say, "There are tens of thousands of types in C#."

The difference is subtle but important. C# (the language) only has a few keywords for types, such as string and int. Strictly speaking, C# doesn't define any types. Keywords such as string that look like types are aliases. Those aliases represent types provided by the platform on which C# runs.

C# cannot exist alone. It is a language that runs on variants of .NET. In theory, someone could write a compiler for C# that uses a different platform, with different underlying types. In practice, the platform for C# is one of the .NET platforms. It is .NET that provides the tens of thousands of types to C#. Those types include System.Int32, which the C# keyword alias int maps to, as well as much more complex types, such as System.Xml.Linq.XDocument.

Note that the term type is often confused with class. Have you ever played the parlor game, Twenty Questions, also known as Animal, Vegetable, or Mineral? In the game, every thing can be categorized as an animal, vegetable, or mineral. In C#, every type can be categorized as a class, struct, enum, interface, or delegate. The C# keyword string is a class, but int is a struct. So, it is best to use the term type to include both.

Let's write some code to find out how many types and methods are available to C# in our simple console application.

Don't worry about how this code works. It uses a technique called reflection, which is beyond the scope of this book.

Start by adding the following statements at the top of the Program.cs file:

    using System.Linq; 
    using System.Reflection; 

Inside the Main method, delete the statement that writes Hello World!, and replace it with the following code:

    // loop through the assemblies that this application references 
    foreach (var r in  Assembly.GetEntryAssembly() 
      .GetReferencedAssemblies()) 
    { 
      // load the assembly so we can read its details 
      var a = Assembly.Load(new AssemblyName(r.FullName)); 
      // declare a variable to count the total number of methods 
      int methodCount = 0; 
      // loop through all the types in the assembly 
      foreach (var t in a.DefinedTypes) 
      { 
        // add up the counts of methods 
        methodCount += t.GetMethods().Count(); 
      } 
      // output the count of types and their methods 
      Console.WriteLine($"{a.DefinedTypes.Count():N0} types " + 
        $"with {methodCount:N0} methods in {r.Name} assembly."); 
    } 

23 types with 258 methods in System.Runtime assembly.
0 types with 0 methods in System.Reflection assembly.
87 types with 917 methods in System.Linq assembly.
38 types with 545 methods in System.Console assembly.

dotnet run

23 types with 258 methods in System.Runtime assembly.
0 types with 0 methods in System.Reflection assembly.
87 types with 917 methods in System.Linq assembly.
59 types with 721 methods in System.Console assembly.

    static void Main(string[] args) 
    { 
      System.Xml.XmlReader reader;

      System.Xml.Linq.XElement element;

      System.Net.Http.HttpClient client;

23 types with 258 methods in System.Runtime assembly.
366 types with 3,966 methods in System.Xml.ReaderWriter assembly.
64 types with 1,121 methods in System.Xml.XDocument assembly.
223 types with 2,346 methods in System.Net.Http assembly.
0 types with 0 methods in System.Reflection assembly.
87 types with 917 methods in System.Linq assembly.
59 types with 721 methods in System.Console assembly.