Programming languages have many similarities to human languages, except that in programming languages, you can make up your own words, just like Dr. Seuss!

In a book written by Dr. Seuss in 1950, If I Ran the Zoo, he states this:

"And then, just to show them, I'll sail to Ka-Troo And Bring Back an It-Kutch, a Preep, and a Proo, A Nerkle, a Nerd, and a Seersucker, too!"

Understanding language versions and features

This book covers features of the C# language from version 1.0 up to the latest version 10.0.

If you already have some familiarity with older versions of C# and are excited to find out about the new features in the most recent versions of C#, I have made it easier for you to jump around by listing language versions and their important new features below, along with the chapter number and topic title where you can learn about them.

C# 1.0

C# 2.0

C# 3.0

C# 4.0

C# 5.0

C# 6.0

C# 7.0

C# 7.1

C# 7.2

C# 7.3

C# 8

C# 9

C# 10

Understanding C# standards

The standard for C# 6 is still a draft and work on adding C# 7 features is progressing. Microsoft made C# open source in 2014.

There are currently three public GitHub repositories for making the work on C# and related technologies as open as possible, as shown in the following table:

Discovering your C# compiler versions

How to output the SDK version

1. On macOS, start Terminal. On Windows, start Command Prompt.
2. To determine which version of the .NET SDK you have available, enter the following command:

   dotnet --version
   

3. Note the version at the time of writing is 6.0.100, indicating that it is the initial version of the SDK without any bug fixes or new features yet, as shown in the following output:

   6.0.100
   

Enabling a specific language version compiler

<LangVersion>7.3</LangVersion>

After the release of C# 10.0 with .NET 6.0, if Microsoft releases a C# 10.1 compiler and you want to use its new language features then you will have to add a configuration element to your project file, as shown in the following markup:

<LangVersion>10.1</LangVersion>

Potential values for the <LangVersion> are shown in the following table:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>
</Project>

Your projects must target net6.0 to use the full features of C# 10.

Understanding C# grammar and vocabulary

To learn some other C# language features, you will need to create an application. The simplest type of application is a console application.

Let's start by looking at the basics of the grammar and vocabulary of C#. Throughout this chapter, you will create multiple console applications, with each one showing related features of the C# language.

Showing the compiler version

1. If you've completed Chapter 1, Hello, C#! Welcome, .NET!, then you will already have a Code folder. If not, then you'll need to create it.
2. Use your preferred code editor to create a new console app, as defined in the following list:
   1. Project template: Console Application [C#] / console
   2. Workspace/solution file and folder: Chapter02
   3. Project file and folder: Vocabulary

      Good Practice: If you have forgotten how, or did not complete the previous chapter, then step-by-step instructions for creating a workspace/solution with multiple projects are given in Chapter 1, Hello, C#! Welcome, .NET!.

Understanding C# grammar

Statements

The adjective, black, comes before the noun, cat. Whereas French grammar has a different order; the adjective comes after the noun: "le chat noir." What's important to take away from this is that the order matters.

var totalPrice = subtotal + salesTax;

The expression is made up of an operand named subtotal, an operator +, and another operand named salesTax. The order of operands and operators matters.

Comments

// sales tax must be added to the subtotal
var totalPrice = subtotal + salesTax;

To write a multiline comment, use /* at the beginning and */ at the end of the comment, as shown in the following code:

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

Your code editor has commands to make it easier to add and remove comment characters, as shown in the following list:

• Visual Studio 2022 for Windows: Navigate to Edit | Advanced | Comment Selection or Uncomment Selection
• Visual Studio Code: Navigate to Edit | Toggle Line Comment or Toggle Block Comment

  Good Practice: You comment code by adding descriptive text above or after code statements. You comment out code by adding comment characters before or around statements to make them inactive. Uncommenting means removing the comment characters.

Blocks

In English, we indicate a new paragraph by starting a new line. C# indicates a block of code with the use of curly brackets, { }.

You will learn more about namespaces, classes, and methods later in this chapter and subsequent chapters but to briefly introduce some of those concepts now:

• A namespace contains types like classes to group them together.
• A class contains the members of an object including methods.
• A method contains statements that implement an action that an object can take.

Examples of statements and blocks

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

Understanding C# vocabulary

The C# vocabulary is made up of keywords, symbol characters, and types.

Some of the symbol characters that you will see include ", ', +, -, *, /, %, @, and $.

There are other contextual keywords that only have a special meaning in a specific context.

However, that still means that there are only about 100 actual C# keywords in the language.

Comparing programming languages to human languages

1. In Visual Studio Code, navigate to Code | Preferences | Color Theme (it is on the File menu on Windows).
2. Select a color theme. For reference, I'll use the Light+ (default light) color theme so that the screenshots look good in a printed book.
3. In Visual Studio, navigate to Tools | Options.
4. In the Options dialog box, select Fonts and Colors, and then select the display items that you would like to customize.

Help for writing correct code

Plain text editors such as Notepad don't help you write correct English. Likewise, Notepad won't help you write correct C# either.

Similarly, Visual Studio Code's C# extension and Visual Studio help you write C# code by highlighting spelling mistakes, such as the method name should be WriteLine with an uppercase L, and grammatical errors, such as statements that must end with a semicolon.

The C# extension constantly watches what you type and gives you feedback by highlighting problems with colored squiggly lines, similar to that of Microsoft Word.

Let's see it in action:

Importing namespaces

System.Console.WriteLine tells the compiler to look for a method named WriteLine in a type named Console in a namespace named System. To simplify our code, the Console Application project template for every version of .NET before 6.0 added a statement at the top of the code file to tell the compiler to always look in the System namespace for types that haven't been prefixed with their namespace, as shown in the following code:

using System; // import the System namespace

We call this importing the namespace. The effect of importing a namespace is that all available types in that namespace will be available to your program without needing to enter the namespace prefix and will be seen in IntelliSense while you write code.

Implicitly and globally importing namespaces

using System;
using System.Linq;
using System.Collections.Generic;

When creating websites and services using ASP.NET Core, there are often dozens of namespaces that each file would have to import.

C# 10 introduces some new features that simplify importing namespaces.

First, the global using statement means you only need to import a namespace in one .cs file and it will be available throughout all .cs files. You could put global using statements in the Program.cs file but I recommend creating a separate file for those statements named something like GlobalUsings.cs or GlobalNamespaces.cs, as shown in the following code:

global using System;
global using System.Linq;
global using System.Collections.Generic;

Second, any projects that target .NET 6.0 and therefore use the C# 10 compiler generate a.cs file in the obj folder to implicitly globally import some common namespaces like System. The specific list of implicitly imported namespaces depends on which SDK you target, as shown in the following table:

Let's see the current auto-generated implicit imports file:

You can disable the implicitly imported namespaces feature for all SDKs by removing an entry in the project file, as shown in the following markup:

<ImplicitUsings>enable</ImplicitUsings>

Verbs are methods

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'll cover in more detail in Chapter 5, Building Your Own Types with Object-Oriented Programming. But for now, consider the following example:

// outputs the current line terminator string
// by default, this is a carriage-return and line feed
Console.WriteLine();
// outputs the greeting and the current line terminator string
Console.WriteLine("Hello Ahmed");
// outputs a formatted number and date and the current line terminator string
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.

Nouns are types, variables, fields, and properties

• Animal and Car are types; they are nouns for categorizing things.
• Head and Engine might be fields or properties; nouns that belong to Animal and Car.
• Fido and Bob are variables; nouns for referring to a specific object.

There are tens of thousands of types available to C#, though have you noticed how I didn't say, "There are tens of thousands of types in C#?" The difference is subtle but important. The language of C# only has a few keywords for types, such as string and int, and strictly speaking, C# doesn't define any types. Keywords such as string that look like types are aliases, which represent types provided by the platform on which C# runs.

It's important to know that C# cannot exist alone; after all, it's 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 .NET, which provides tens of thousands of types to C#, including System.Int32, which is the C# keyword alias int maps to, as well as many more complex types, such as System.Xml.Linq.XDocument.

Revealing the extent of the C# vocabulary

Now, you have a better sense of why learning C# is a challenge, because there are so many types and methods to learn. Methods are only one category of a member that a type can have, and you and other programmers are constantly defining new types and members!

Working with variables

All applications process data. Data comes in, data is processed, and then data goes out.

We control this by picking an appropriate type. You can think of simple common types such as int and double as being different-sized storage boxes, where a smaller box would take less memory but may not be as fast at being processed; for example, adding 16-bit numbers might not be processed as fast as adding 64-bit numbers on a 64-bit operating system. Some of these boxes may be stacked close by, and some may be thrown into a big heap further away.

Naming things and assigning values

The following code block shows an example of declaring a named local variable and assigning a value to it with the = symbol. You should note that you can output the name of a variable using a keyword introduced in C# 6.0, nameof:

// let the heightInMetres variable become equal to the value 1.88
double heightInMetres = 1.88;
Console.WriteLine($"The variable {nameof(heightInMetres)} has the value
{heightInMetres}.");

Literal values

Storing text

A char is assigned using single quotes around the literal value, or assigning the return value of a fictitious function call, as shown in the following code:

char letter = 'A'; // assigning literal characters
char digit = '1'; 
char symbol = '$';
char userChoice = GetSomeKeystroke(); // assigning from a fictitious function

For text, multiple letters, such as Bob, are stored as a string type and are assigned using double quotes around the literal value, or assigning the return value of a function call, as shown in the following code:

string firstName = "Bob"; // assigning literal strings
string lastName = "Smith";
string phoneNumber = "(215) 555-4256";
// assigning a string returned from a fictitious function
string address = GetAddressFromDatabase(id: 563);

Understanding verbatim strings

string fullNameWithTabSeparator = "Bob\tSmith";

But what if you are storing the path to a file on Windows, and one of the folder names starts with a T, as shown in the following code?

string filePath = "C:\televisions\sony\bravia.txt";

The compiler will convert the \t into a tab character and you will get errors!

You must prefix with the @ symbol to use a verbatim literal string, as shown in the following code:

string filePath = @"C:\televisions\sony\bravia.txt";

To summarize:

Storing numbers

Numbers can be natural numbers, such as 42, used for counting (also called whole numbers); they can also be negative numbers, such as -42 (called integers); or, they can be real numbers, such as 3.9 (with a fractional part), which are called single- or double-precision floating-point numbers in computing.

1. Use your preferred code editor to add a new Console Application to the Chapter02 workspace/solution named Numbers:
   1. In Visual Studio Code, select Numbers as the active OmniSharp project. When you see the pop-up warning message saying that required assets are missing, click Yes to add them.
   2. In Visual Studio, set the startup project to the current selection.
2. In Program.cs, delete the existing code and then type statements to declare some number variables using various data types, as shown in the following code:

   // unsigned integer means positive whole number or 0
   uint naturalNumber = 23;
   // integer means negative or positive whole number or 0
   int integerNumber = -23;
   // float means single-precision floating point
   // F suffix makes it a float literal
   float realNumber = 2.3F;
   // double means double-precision floating point
   double anotherRealNumber = 2.3; // double literal
   

Storing whole numbers

The decimal number system, also known as Base 10, has 10 as its base, meaning there are ten digits, from 0 to 9. Although it is the number base most commonly used by human civilizations, other number base systems are popular in science, engineering, and computing. The binary number system, also known as Base 2, has two as its base, meaning there are two digits, 0 and 1.

So, 10 in decimal is 00001010 in binary.

Improving legibility by using digit separators

Two of the improvements seen in C# 7.0 and later are the use of the underscore character _ as a digit separator, and support for binary literals.

For example, you could write the value for 1 million in decimal notation, that is, Base 10, as 1_000_000.

You can even use the 2/3 grouping common in India: 10_00_000.

Using binary notation

Exploring whole numbers

Computers can always exactly represent integers using the int type or one of its sibling types, such as long and short.

Storing real numbers

Computers cannot always represent real, aka decimal or non-integer, numbers precisely. The float and double types store real numbers using single- and double-precision floating points.

8 + 4 + ½ + ¼ = 12¾ = 12.75.

So, 12.75 in decimal is 00001100.1100 in binary. As you can see, the number 12.75 can be exactly represented using bits. However, some numbers can't, something that we'll be exploring shortly.

Writing code to explore number sizes

An int variable uses four bytes of memory and can store positive or negative numbers up to about 2 billion. A double variable uses eight bytes of memory and can store much bigger values! A decimal variable uses 16 bytes of memory and can store big numbers, but not as big as a double type.

Comparing double and decimal types

1. Type statements to declare two double variables, add them together and compare them to the expected result, and write the result to the console, as shown in the following code:

   Console.WriteLine("Using doubles:"); 
   double a = 0.1;
   double b = 0.2;
   if (a + b == 0.3)
   {
     Console.WriteLine($"{a} + {b} equals {0.3}");
   }
   else
   {
     Console.WriteLine($"{a} + {b} does NOT equal {0.3}");
   }
   

2. Run the code and view the result, as shown in the following output:

   Using doubles:
   0.1 + 0.2 does NOT equal 0.3
   

In locales that use a comma for the decimal separator the result will look slightly different, as shown in the following output:

0,1 + 0,2 does NOT equal 0,3

The double type is not guaranteed to be accurate because some numbers like 0.1 literally cannot be represented as floating-point values.

As a rule of thumb, you should only use double when accuracy, especially when comparing the equality of two numbers, is not important. An example of this may be when you're measuring a person's height and you will only compare values using greater than or less than, but never equals.

The problem with the preceding code is illustrated by how the computer stores the number 0.1, or multiples of it. To represent 0.1 in binary, the computer stores 1 in the 1/16 column, 1 in the 1/32 column, 1 in the 1/256 column, 1 in the 1/512 column, and so on.

The number 0.1 in decimal is 0.00011001100110011… in binary, repeating forever:

The double type has some useful special values: double.NaN represents not-a-number (for example, the result of dividing by zero), double.Epsilon represents the smallest positive number that can be stored in a double, and double.PositiveInfinity and double.NegativeInfinity represent infinitely large positive and negative values.

Storing Booleans

bool happy = true; 
bool sad = false;

They are most commonly used to branch and loop. You don't need to fully understand them yet, as they are covered more in Chapter 3, Controlling Flow, Converting Types, and Handling Exceptions.

Storing any type of object

Storing dynamic types

1. Add statements to declare a dynamic variable and then assign a string literal value, and then an integer value, and then an array of integer values, as shown in the following code:

   // storing a string in a dynamic object
   // string has a Length property
   dynamic something = "Ahmed";
   // int does not have a Length property
   // something = 12;
   // an array of any type has a Length property
   // something = new[] { 3, 5, 7 };
   

2. Add a statement to output the length of the dynamic variable, as shown in the following code:

   // this compiles but would throw an exception at run-time
   // if you later store a data type that does not have a
   // property named Length
   Console.WriteLine($"Length is {something.Length}");
   

3. Run the code and note it works because a string value does have a Length property, as shown in the following output:

   Length is 5
   

4. Uncomment the statement that assigns an int value.
5. Run the code and note the runtime error because int does not have a Length property, as shown in the following output:

   Unhandled exception. Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: 'int' does not contain a definition for 'Length'
   

6. Uncomment the statement that assigns the array.
7. Run the code and note the output because an array of three int values does have a Length property, as shown in the following output:

   Length is 3
   

Exceptions are a way to indicate that something has gone wrong at runtime. You will learn more about them and how to handle them in Chapter 3, Controlling Flow, Converting Types, and Handling Exceptions.

Declaring local variables

Strictly speaking, value types are released while reference types must wait for a garbage collection. You will learn about the difference between value types and reference types in Chapter 6, Implementing Interfaces and Inheriting Classes.

Specifying the type of a local variable

1. Type statements to declare and assign values to some local variables using specific types, as shown in the following code:

   int population = 66_000_000; // 66 million in UK
   double weight = 1.88; // in kilograms
   decimal price = 4.99M; // in pounds sterling
   string fruit = "Apples"; // strings use double-quotes
   char letter = 'Z'; // chars use single-quotes
   bool happy = true; // Booleans have value of true or false
   

Inferring the type of a local variable

A literal number without a decimal point is inferred as an int variable, that is, unless you add a suffix, as described in the following list:

• L: infers long
• UL: infers ulong
• M: infers decimal
• D: infers double
• F: infers float

A literal number with a decimal point is inferred as double unless you add the M suffix, in which case, it infers a decimal variable, or the F suffix, in which case, it infers a float variable.

Double quotes indicate a string variable, single quotes indicate a char variable, and the true and false values infer a bool type:

Using target-typed new to instantiate objects

XmlDocument xml3 = new(); // target-typed new in C# 9 or later

If you have a type with a field or property that needs to be set, then the type can be inferred, as shown in the following code:

class Person
{
  public DateTime BirthDate;
}
Person kim = new();
kim.BirthDate = new(1967, 12, 26); // instead of: new DateTime(1967, 12, 26)

Getting and setting the default values for types

You'll learn more about value types and reference types in Chapter 6, Implementing Interfaces and Inheriting Classes.

Let's explore default values:

Storing multiple values in an array

The code that you will write next will allocate memory for an array for storing four string values. It will then store string values at index positions 0 to 3 (arrays usually have a lower bound of zero, so the index of the last item is one less than the length of the array).

Finally, it will loop through each item in the array using a for statement, something that we will cover in more detail in Chapter 3, Controlling Flow, Converting Types, and Handling Exceptions.

Let's look at how to use an array:

Arrays are always of a fixed size at the time of memory allocation, so you need to decide how many items you want to store before instantiating them.

An alternative to defining the array in three steps as above is to use array initializer syntax, as shown in the following code:

string[] names2 = new[] { "Kate", "Jack", "Rebecca", "Tom" };

When you use the new[] syntax to allocate memory for the array, you must have at least one item in the curly braces so that the compiler can infer the data type.

Exploring more about console applications

We have already created and used basic console applications, but we're now at a stage where we should delve into them more deeply.

Equally, they can also have arguments passed to them to control their behavior.

An example of this would be to create a new console app using the F# language with a specified name instead of using the name of the current folder, as shown in the following command line:

dotnet new console -lang "F#" --name "ExploringConsole"

Displaying output to the user

Formatting using numbered positional arguments

One way of generating formatted strings is to use numbered positional arguments.

Let's begin formatting:

The WriteToFile method is a nonexistent method used to illustrate the idea.

Formatting using interpolated strings

1. Enter a statement at the bottom of the Program.cs file, as shown in the following code:

   Console.WriteLine($"{numberOfApples} apples costs {pricePerApple * numberOfApples:C}");
   

2. Run the code and view the result, as shown in the following partial output:

    12 apples costs £4.20
   

For short, formatted string values, an interpolated string can be easier for people to read. But for code examples in a book, where lines need to wrap over multiple lines, this can be tricky. For many of the code examples in this book, I will use numbered positional arguments.

Before C# 10, string constants could only be combined by using concatenation, as shown in the following code:

private const string firstname = "Omar";
private const string lastname = "Rudberg";
private const string fullname = firstname + " " + lastname;

With C# 10, interpolated strings can now be used, as shown in the following code:

private const string fullname = "{firstname} {lastname}";

This only works for combining string constant values. It cannot work with other types like numbers that would require runtime data type conversions.

Understanding format strings

A variable or expression can be formatted using a format string after a comma or colon.

For instance, if you run this code on a PC in the UK, you'll get pounds sterling with commas as the thousand separators, but if you run this code on a PC in Germany, you will get euros with dots as the thousand separators.

The full syntax of a format item is:

{ index [, alignment ] [ : formatString ] }

Each format item can have an alignment, which is useful when outputting tables of values, some of which might need to be left- or right-aligned within a width of characters. Alignment values are integers. Positive integers mean right-aligned and negative integers mean left-aligned.

1. At the bottom of Program.cs, enter the following statements:

   string applesText = "Apples"; 
   int applesCount = 1234;
   string bananasText = "Bananas"; 
   int bananasCount = 56789;
   Console.WriteLine(
     format: "{0,-10} {1,6:N0}",
     arg0: "Name",
     arg1: "Count");
   Console.WriteLine(
     format: "{0,-10} {1,6:N0}",
     arg0: applesText,
     arg1: applesCount);
   Console.WriteLine(
     format: "{0,-10} {1,6:N0}",
     arg0: bananasText,
     arg1: bananasCount);
   

2. Run the code and note the effect of the alignment and number format, as shown in the following output:

   Name          Count
   Apples        1,234
   Bananas      56,789
   

Getting text input from the user

Let's get input from the user:

1. Type statements to ask the user for their name and age and then output what they entered, as shown in the following code:

   Console.Write("Type your first name and press ENTER: "); 
   string? firstName = Console.ReadLine();
   Console.Write("Type your age and press ENTER: "); 
   string? age = Console.ReadLine();
   Console.WriteLine(
     $"Hello {firstName}, you look good for {age}.");
   

2. Run the code, and then enter a name and age, as shown in the following output:

   Type your name and press ENTER: Gary 
   Type your age and press ENTER: 34 
   Hello Gary, you look good for 34.
   

Simplifying the usage of the console

1. At the top of the Program.cs file, add a statement to statically import the System.Console class, as shown in the following code:

   using static System.Console;
   

2. Select the first Console. in your code, ensuring that you select the dot after the word Console too.
3. In Visual Studio, navigate to Edit | Find and Replace | Quick Replace, or in Visual Studio Code, navigate to Edit | Replace, and note that an overlay dialog appears ready for you to enter what you would like to replace Console. with, as shown in Figure 2.5:

   

   Figure 2.5: Using the Replace feature in Visual Studio to simplify your code

4. Leave the replace box empty, click on the Replace all button (the second of the two buttons to the right of the replace box), and then close the replace box by clicking on the cross in its top-right corner.

Getting key input from the user

You will not be able to execute the call to the ReadKey method using a .NET Interactive notebook, but if you have created a console application, then let's explore reading key presses:

1. Type statements to ask the user to press any key combination and then output information about it, as shown in the following code:

   Write("Press any key combination: "); 
   ConsoleKeyInfo key = ReadKey(); 
   WriteLine();
   WriteLine("Key: {0}, Char: {1}, Modifiers: {2}",
     arg0: key.Key, 
     arg1: key.KeyChar,
     arg2: key.Modifiers);
   

2. Run the code, press the K key, and note the result, as shown in the following output:

   Press any key combination: k 
   Key: K, Char: k, Modifiers: 0
   

3. Run the code, hold down Shift and press the K key, and note the result, as shown in the following output:

   Press any key combination: K  
   Key: K, Char: K, Modifiers: Shift
   

4. Run the code, press the F12 key, and note the result, as shown in the following output:

   Press any key combination: 
   Key: F12, Char: , Modifiers: 0
   

Passing arguments to a console app

You might have been wondering how to get any arguments that might be passed to a console application.

using System;
namespace Arguments
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Hello World!");
    }
  }
}

The string[] args arguments are declared and passed in the Main method of the Program class. They're an array used to pass arguments into a console application. But in top-level programs, as used by the console application project template in .NET 6.0 and later, the Program class and its Main method are hidden, along with the declaration of the args string array. The trick is that you must know it still exists.

Command-line arguments are separated by spaces. Other characters like hyphens and colons are treated as part of an argument value.

To include spaces in an argument value, enclose the argument value in single or double quotes.

Imagine that we want to be able to enter the names of some colors for the foreground and background, and the dimensions of the terminal window at the command line. We would be able to read the colors and numbers by reading them from the args array, which is always passed into the Main method aka the entry point of a console application:

Setting options with arguments

The System namespace is already imported so that the compiler knows about the ConsoleColor and Enum types:

Figure 2.8: An unhandled exception on unsupported macOS

Handling platforms that do not support an API

1. Modify the code to wrap the lines that change the cursor size in a try statement, as shown in the following code:

   try
   {
     CursorSize = int.Parse(args[2]);
   }
   catch (PlatformNotSupportedException)
   {
     WriteLine("The current platform does not support changing the size of the cursor.");
   }
   

2. If you were to run the code on macOS then you would see the exception is caught, and a friendlier message is shown to the user.

if (OperatingSystem.IsWindows())
{
  // execute code that only works on Windows
}
else if (OperatingSystem.IsWindowsVersionAtLeast(major: 10))
{
  // execute code that only works on Windows 10 or later
}
else if (OperatingSystem.IsIOSVersionAtLeast(major: 14, minor: 5))
{
  // execute code that only works on iOS 14.5 or later
}
else if (OperatingSystem.IsBrowser())
{
  // execute code that only works in the browser with Blazor
}

The OperatingSystem class has equivalent methods for other common operating systems like Android, iOS, Linux, macOS, and even the browser, which is useful for Blazor web components.

A third way to handle different platforms is to use conditional compilation statements.

There are four preprocessor directives that control conditional compilation: #if, #elif, #else, and #endif.

You define symbols using #define, as shown in the following code:

#define MYSYMBOL

Many symbols are automatically defined for you, as shown in the following table:

#if NET6_0_ANDROID
// compile statements that only works on Android
#elif NET6_0_IOS
// compile statements that only works on iOS
#else
// compile statements that work everywhere else
#endif

Practicing and exploring

Test your knowledge and understanding by answering some questions, get some hands-on practice, and explore the topics covered in this chapter with deeper research.

Exercise 2.1 – Test your knowledge

To get the best answer to some of these questions, you will need to do your own research. I want you to "think outside the book" so I have deliberately not provided all the answers in the book.

I want to encourage you to get in to the good habit of looking for help elsewhere, following the principle of "teach a person to fish."