There are programming books that are thousands of pages long that aim to be comprehensive references for the C# language, .NET libraries, app models like websites, services, and desktop, and mobile apps.

This book is different. It is concise and aims to be a brisk, fun read packed with practical hands-on walkthroughs of each subject. The breadth of the overarching narrative comes at the cost of some depth, but you will find many signposts to explore further if you wish.

This book is simultaneously a step-by-step guide to learning modern C# proven practices using cross-platform .NET and a brief introduction to the main types of practical applications that can be built with them. This book is best for beginners to C# and .NET, or programmers who have worked with C# in the past but feel left behind by the changes in the past few years.

If you already have experience with older versions of the C# language, then in the first section of Chapter 2, Speaking C#, you can review tables of the new language features and jump straight to them.

If you already have experience with older versions of the .NET libraries, then in the first section of Chapter 7, Packaging and Distributing .NET Types, you can review tables of the new library features and jump straight to them.

I will point out the cool corners and gotchas of C# and .NET, so you can impress colleagues and get productive fast. Rather than slowing down and boring some readers by explaining every little thing, I will assume that you are smart enough to Google an explanation for topics that are related but not necessary to include in a beginner-to-intermediate guide that has limited space in the printed book.

You can download solutions for the step-by-step guided tasks and exercises from the GitHub repository at the following link: https://github.com/markjprice/cs10dotnet6.

If you don't know how, then I provide instructions on how to do this at the end of Chapter 1, Hello, C#! Welcome, .NET!.

Chapter 1, Hello, C#! Welcome, .NET!, is about setting up your development environment and using either Visual Studio or Visual Studio Code to create the simplest application possible with C# and .NET. For simplified console apps, you will see the use of the top-level program feature introduced in C# 9. For learning how to write simple language constructs and library features, you will see the use of .NET Interactive Notebooks. You will also learn about some good places to look for help and ways to contact me to get help with an issue or give me feedback to improve the book and future editions through its GitHub repository.

Chapter 2, Speaking C#, introduces the versions of C# and has tables showing which versions introduced new features. I explain the grammar and vocabulary that you will use every day to write the source code for your applications. In particular, you will learn how to declare and work with variables of different types.

Chapter 3, Controlling Flow, Converting Types, and Handling Exceptions, covers using operators to perform simple actions on variables, including comparisons, writing code that makes decisions, pattern matching in C# 7 to C# 10, repeating a block of statements, and converting between types. It also covers writing code defensively to handle exceptions when they inevitably occur.

Chapter 4, Writing, Debugging, and Testing Functions, is about following the Don't Repeat Yourself (DRY) principle by writing reusable functions using both imperative and functional implementation styles. You will also learn how to use debugging tools to track down and remove bugs, monitoring your code while it executes to diagnose problems, and rigorously testing your code to remove bugs and ensure stability and reliability before it gets deployed into production.

Chapter 5, Building Your Own Types with Object-Oriented Programming, discusses all the different categories of members that a type can have, including fields to store data and methods to perform actions. You will use object-oriented programming (OOP) concepts, such as aggregation and encapsulation. You will learn about language features such as tuple syntax support and out variables, default literals, and inferred tuple names, as well as how to define and work with immutable types using the record keyword, init-only properties, and with expressions introduced in C# 9.

Chapter 6, Implementing Interfaces and Inheriting Classes, explains deriving new types from existing ones using OOP. You will learn how to define operators and local functions, delegates and events, how to implement interfaces about base and derived classes, how to override a member of a type, how to use polymorphism, how to create extension methods, how to cast between classes in an inheritance hierarchy, and about the big change in C# 8 with the introduction of nullable reference types.

Chapter 7, Packaging and Distributing .NET Types, introduces the versions of .NET and has tables showing which versions introduced new library features, and then presents .NET types that are compliant with .NET Standard and how they relate to C#. You will learn how to write and compile code on any of the supported operating systems: Windows, macOS, and Linux variants. You will learn how to package, deploy, and distribute your own apps and libraries.

Chapter 8, Working with Common .NET Types, discusses the types that allow your code to perform common practical tasks, such as manipulating numbers and text, dates and times, storing items in collections, working with the network and manipulating images, and implementing internationalization.

Chapter 9, Working with Files, Streams, and Serialization, covers interacting with the filesystem, reading and writing to files and streams, text encoding, and serialization formats like JSON and XML, including the improved functionality and performance of the System.Text.Json classes.

Chapter 10, Working with Data Using Entity Framework Core, explains reading and writing to relational databases, such as Microsoft SQL Server and SQLite, using the object-relational mapping (ORM) technology named Entity Framework Core (EF Core). You will learn how to define entity models that map to existing tables in a database, as well as how to define Code First models that can create the tables and database at runtime.

Chapter 11, Querying and Manipulating Data Using LINQ, teaches you about Language INtegrated Queries (LINQs)—language extensions that add the ability to work with sequences of items and filter, sort, and project them into different outputs. You will learn about the special capabilities of Parallel LINQ (PLINQ) and LINQ to XML.

Chapter 12, Improving Performance and Scalability Using Multitasking, discusses allowing multiple actions to occur at the same time to improve performance, scalability, and user productivity. You will learn about the async Main feature and how to use types in the System.Diagnostics namespace to monitor your code to measure performance and efficiency.

Chapter 13, Introducing Practical Applications of C# and .NET, introduces you to the types of cross-platform applications that can be built using C# and .NET. You will also build an EF Core model to represent the Northwind database that will be used throughout the rest of the chapters in the book.

Chapter 14, Building Websites Using ASP.NET Core Razor Pages, is about learning the basics of building websites with a modern HTTP architecture on the server side using ASP.NET Core. You will learn how to implement the ASP.NET Core feature known as Razor Pages, which simplifies creating dynamic web pages for small websites, and about building the HTTP request and response pipeline.

Chapter 15, Building Websites Using the Model-View-Controller Pattern, is about learning how to build large, complex websites in a way that is easy to unit test and manage with teams of programmers using ASP.NET Core MVC. You will learn about startup configuration, authentication, routes, models, views, and controllers.

Chapter 16, Building and Consuming Web Services, explains building backend REST architecture web services using the ASP.NET Core Web API and how to properly consume them using factory-instantiated HTTP clients.

Chapter 17, Building User Interfaces Using Blazor, introduces how to build web user interface components using Blazor that can be executed either on the server side or inside the client-side web browser. You will see the differences between Blazor Server and Blazor WebAssembly and how to build components that are easier to switch between the two hosting models.

Three bonus online chapters complete this bumper edition. You can read the following chapters and the appendix at https://static.packt-cdn.com/downloads/9781801077361_Bonus_Content.pdf:

Chapter 18, Building and Consuming Specialized Services, introduces you to building services using gRPC, implementing real-time communications between server and client using SignalR, exposing an EF Core model using OData, and hosting functions in the cloud that respond to triggers using Azure Functions.

Chapter 19, Building Mobile and Desktop Apps Using .NET MAUI, introduces you to building cross-platform mobile and desktop apps for Android, iOS, macOS, and Windows. You will learn the basics of XAML, which can be used to define the user interface for a graphical app.

Chapter 20, Protecting Your Data and Applications, is about protecting your data from being viewed by malicious users using encryption, and from being manipulated or corrupted using hashing and signing. You will also learn about authentication and authorization to protect applications from unauthorized users.

Appendix, Answers to the Test Your Knowledge Questions, has the answers to the test questions at the end of each chapter.

You can develop and deploy C# and .NET apps using Visual Studio Code on many platforms, including Windows, macOS, and many varieties of Linux.

An operating system that supports Visual Studio Code and an internet connection is all you need to complete all but one chapter.

If you prefer to use Visual Studio for Windows or macOS, or a third-party tool like JetBrains Rider, then you can.

You will need macOS to build the iOS app in Chapter 19, Building Mobile and Desktop Apps Using .NET MAUI, because you must have macOS and Xcode to compile iOS apps.

Downloading the color images of this book

We also provide you with a PDF file that has color images of the screenshots and diagrams used in this book. The color images will help you better understand the changes in the output.

You can download this file from https://static.packt-cdn.com/downloads/9781801077361_ColorImages.pdf.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. For example; "The Controllers, Models, and Views folders contain ASP.NET Core classes and the .cshtml files for execution on the server."

A block of code is set as follows:

// storing items at index positions 
names[0] = "Kate";
names[1] = "Jack"; 
names[2] = "Rebecca"; 
names[3] = "Tom";

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are highlighted:

// storing items at index positions 
names[0] = "Kate";
names[1] = "Jack"; 
names[2] = "Rebecca"; 
names[3] = "Tom";

Any command-line input or output is written as follows:

dotnet new console

Bold: Indicates a new term, an important word, or words that you see on the screen, for example, in menus or dialog boxes. For example: "Clicking on the Next button moves you to the next screen."

Feedback from our readers is always welcome.

General feedback: If you have questions about any aspect of this book, mention the book title in the subject of your message and email us at [email protected].

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit, www.packtpub.com/support/errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.

Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.

Once you've read C# 10 and .NET 6 - Modern Cross-Platform Development, Sixth Edition, we'd love to hear your thoughts! Please click here to go straight to the Amazon review page for this book and share your feedback.

Your review is important to us and the tech community and will help us make sure we're delivering excellent quality content.

In this first chapter, the goals are setting up your development environment, understanding the similarities and differences between modern .NET, .NET Core, .NET Framework, Mono, Xamarin, and .NET Standard, creating the simplest application possible with C# 10 and .NET 6 using various code editors, and then discovering good places to look for help.

The GitHub repository for this book has solutions using full application projects for all code tasks and notebooks when possible:

https://github.com/markjprice/cs10dotnet6

Simply press the . (dot) key or change .com to .dev in the link above to change the GitHub repository into a live editor using Visual Studio Code for the Web, as shown in Figure 1.1:

Figure 1.1: Visual Studio Code for the Web live editing the book's GitHub repository

This is great to run alongside your chosen code editor as you work through the book's coding tasks. You can compare your code to the solution code and easily copy and paste parts if needed.

Throughout this book, I use the term modern .NET to refer to .NET 6 and its predecessors like .NET 5 that come from .NET Core. I use the term legacy .NET to refer to .NET Framework, Mono, Xamarin, and .NET Standard. Modern .NET is a unification of those legacy platforms and standards.

After this first chapter, the book can be divided into three parts: first, the grammar and vocabulary of the C# language; second, the types available in .NET for building app features; and third, examples of common cross-platform apps you can build using C# and .NET.

Most people learn complex topics best by imitation and repetition rather than reading a detailed explanation of the theory; therefore, I will not overload you with detailed explanations of every step throughout this book. The idea is to get you to write some code and see it run.

You don't need to know all the nitty-gritty details immediately. That will be something that comes with time as you build your own apps and go beyond what any book can teach you.

In the words of Samuel Johnson, author of the English dictionary in 1755, I have committed "a few wild blunders, and risible absurdities, from which no work of such multiplicity is free." I take sole responsibility for these and hope you appreciate the challenge of my attempt to lash the wind by writing this book about rapidly evolving technologies like C# and .NET, and the apps that you can build with them.

This first chapter covers the following topics:

• Setting up your development environment
• Understanding .NET
• Building console apps using Visual Studio 2022
• Building console apps using Visual Studio Code
• Exploring code using .NET Interactive Notebooks
• Reviewing the folders and files for projects
• Making good use of the GitHub repository for this book
• Looking for help

Before you start programming, you'll need a code editor for C#. Microsoft has a family of code editors and Integrated Development Environments (IDEs), which include:

• Visual Studio 2022 for Windows
• Visual Studio 2022 for Mac
• Visual Studio Code for Windows, Mac, or Linux
• GitHub Codespaces

Third parties have created their own C# code editors, for example, JetBrains Rider.

What is the best tool and application type for learning C# and .NET?

When learning, the best tool is one that helps you write code and configuration but does not hide what is really happening. IDEs provide graphical user interfaces that are friendly to use, but what are they doing for you underneath? A more basic code editor that is closer to the action while providing help to write your code is better while you are learning.

Having said that, you can make the argument that the best tool is the one you are already familiar with or that you or your team will use as your daily development tool. For that reason, I want you to be free to choose any C# code editor or IDE to complete the coding tasks in this book, including Visual Studio Code, Visual Studio for Windows, Visual Studio for Mac, or even JetBrains Rider.

In the third edition of this book, I gave detailed step-by-step instructions for both Visual Studio for Windows and Visual Studio Code for all coding tasks. Unfortunately, that got messy and confusing quickly. In this sixth edition, I give detailed step-by-step instructions for how to create multiple projects in both Visual Studio 2022 for Windows and Visual Studio Code only in Chapter 1. After that, I give names of projects and general instructions that work with all tools so you can use whichever tool you prefer.

The best application type for learning the C# language constructs and many of the .NET libraries is one that does not distract with unnecessary application code. For example, there is no need to create an entire Windows desktop application or a website just to learn how to write a switch statement.

For that reason, I believe the best method for learning the C# and .NET topics in Chapters 1 to 12 is to build console applications. Then, in Chapter 13 to 19 onward, you will build websites, services, and graphical desktop and mobile apps.

Another benefit of Visual Studio Code is the .NET Interactive Notebooks extension. This extension provides an easy and safe place to write simple code snippets. It enables you to create a single notebook file that mixes "cells" of Markdown (richly formatted text) and code using C# and other related languages, such as PowerShell, F#, and SQL (for databases).

However, .NET Interactive Notebooks does have some limitations:

• They cannot read input from the user, for example, you cannot use ReadLine or ReadKey.
• They cannot have arguments passed to them.
• They do not allow you to define your own namespaces.
• They do not have any debugging tools (but these are coming in the future).

The most modern and lightweight code editor to choose from, and the only one from Microsoft that is cross-platform, is Microsoft Visual Studio Code. It can run on all common operating systems, including Windows, macOS, and many varieties of Linux, including Red Hat Enterprise Linux (RHEL) and Ubuntu.

Visual Studio Code is a good choice for modern cross-platform development because it has an extensive and growing set of extensions to support many languages beyond C#.

Being cross-platform and lightweight, it can be installed on all platforms that your apps will be deployed to for quick bug fixes and so on. Choosing Visual Studio Code means a developer can use a cross-platform code editor to develop cross-platform apps.

Visual Studio Code has strong support for web development, although it currently has weak support for mobile and desktop development.

Visual Studio Code is supported on ARM processors so that you can develop on Apple Silicon computers and Raspberry Pi.

Visual Studio Code is by far the most popular integrated development environment, with over 70% of professional developers selecting it in the Stack Overflow 2021 survey.

GitHub Codespaces is a fully configured development environment based on Visual Studio Code that can be spun up in an environment hosted in the cloud and accessed through any web browser. It supports Git repos, extensions, and a built-in command-line interface so you can edit, run, and test from any device.

Microsoft Visual Studio 2022 for Mac can create most types of applications, including console apps, websites, web services, desktop, and mobile apps.

To compile apps for Apple operating systems like iOS to run on devices like the iPhone and iPad, you must have Xcode, which only runs on macOS.

Microsoft Visual Studio 2022 for Windows can create most types of applications, including console apps, websites, web services, desktop, and mobile apps. Although you can use Visual Studio 2022 for Windows with its Xamarin extensions to write a cross-platform mobile app, you still need macOS and Xcode to compile it.

It only runs on Windows, version 7 SP1 or later. You must run it on Windows 10 or Windows 11 to create Universal Windows Platform (UWP) apps that are installed from the Microsoft Store and run in a sandbox to protect your computer.

To write and test the code for this book, I used the following hardware:

• HP Spectre (Intel) laptop
• Apple Silicon Mac mini (M1) desktop
• Raspberry Pi 400 (ARM v8) desktop

And I used the following software:

• Visual Studio Code on:
  • macOS on an Apple Silicon Mac mini (M1) desktop
  • Windows 10 on an HP Spectre (Intel) laptop
  • Ubuntu 64 on a Raspberry Pi 400
• Visual Studio 2022 for Windows on:
  • Windows 10 on an HP Spectre (Intel) laptop
• Visual Studio 2022 for Mac on:
  • macOS on an Apple Silicon Mac mini (M1) desktop

I hope that you have access to a variety of hardware and software too, because seeing the differences in platforms deepens your understanding of development challenges, although any one of the above combinations is enough to learn the fundamentals of C# and .NET and how to build practical apps and websites.

Your choice of code editor and operating system for development does not limit where your code gets deployed.

.NET 6 supports the following platforms for deployment:

• Windows: Windows 7 SP1, or later. Windows 10 version 1607, or later, including Windows 11. Windows Server 2012 R2 SP1, or later. Nano Server version 1809, or later.
• Mac: macOS Mojave (version 10.14), or later.
• Linux: Alpine Linux 3.13, or later. CentOS 7, or later. Debian 10, or later. Fedora 32, or later. openSUSE 15, or later. Red Hat Enterprise Linux (RHEL) 7, or later. SUSE Enterprise Linux 12 SP2, or later. Ubuntu 16.04, 18.04, 20.04, or later.
• Android: API 21, or later.
• iOS: 10, or later.

Windows ARM64 support in .NET 5 and later means you can develop on, and deploy to, Windows ARM devices like Microsoft Surface Pro X. But developing on an Apple M1 Mac using Parallels and a Windows 10 ARM virtual machine is apparently twice as fast!

Many professional Microsoft developers use Visual Studio 2022 for Windows in their day-to-day development work. Even if you choose to use Visual Studio Code to complete the coding tasks in this book, you might want to familiarize yourself with Visual Studio 2022 for Windows too.

If you do not have a Windows computer, then you can skip this section and continue to the next section where you will download and install Visual Studio Code on macOS or Linux.

Since October 2014, Microsoft has made a professional quality edition of Visual Studio for Windows available to students, open source contributors, and individuals for free. It is called Community Edition. Any of the editions are suitable for this book. If you have not already installed it, let's do so now:

1. Download Microsoft Visual Studio 2022 version 17.0 or later for Windows from the following link: https://visualstudio.microsoft.com/downloads/.
2. Start the installer.
3. On the Workloads tab, select the following:
   • ASP.NET and web development
   • Azure development
   • .NET desktop development
   • Desktop development with C++
   • Universal Windows Platform development
   • Mobile development with .NET
4. On the Individual components tab, in the Code tools section, select the following:
   • Class Designer
   • Git for Windows
   • PreEmptive Protection - Dotfuscator
5. Click Install and wait for the installer to acquire the selected software and install it.
6. When the installation is complete, click Launch.
7. The first time that you run Visual Studio, you will be prompted to sign in. If you have a Microsoft account, you can use that account. If you don't, then register for a new one at the following link: https://signup.live.com/.
8. The first time that you run Visual Studio, you will be prompted to configure your environment. For Development Settings, choose Visual C#. For the color theme, I chose Blue, but you can choose whatever tickles your fancy.
9. If you want to customize your keyboard shortcuts, navigate to Tools | Options…, and then select the Keyboard section.

In this book, I will avoid showing keyboard shortcuts since they are often customized. Where they are consistent across code editors and commonly used, I will try to show them. If you want to identify and customize your keyboard shortcuts, then you can, as shown at the following link: https://docs.microsoft.com/en-us/visualstudio/ide/identifying-and-customizing-keyboard-shortcuts-in-visual-studio.

Visual Studio Code has rapidly improved over the past couple of years and has pleasantly surprised Microsoft with its popularity. If you are brave and like to live on the bleeding edge, then there is an Insiders edition, which is a daily build of the next version.

Even if you plan to only use Visual Studio 2022 for Windows for development, I recommend that you download and install Visual Studio Code and try the coding tasks in this chapter using it, and then decide if you want to stick with just using Visual Studio 2022 for the rest of the book.

Let's now download and install Visual Studio Code, the .NET SDK, and the C# and .NET Interactive Notebooks extensions:

1. Download and install either the Stable build or the Insiders edition of Visual Studio Code from the following link: https://code.visualstudio.com/.

   More Information: If you need more help installing Visual Studio Code, you can read the official setup guide at the following link: https://code.visualstudio.com/docs/setup/setup-overview.

2. Download and install the .NET SDKs for versions 3.1, 5.0, and 6.0 from the following link: https://www.microsoft.com/net/download.

   To fully learn how to control .NET SDKs, we need multiple versions installed. .NET Core 3.1, .NET 5.0, and .NET 6.0 are the three currently supported versions. You can safely install multiple ones side by side. You will learn how to target the one you want throughout this book.

3. To install the C# extension, you must first launch the Visual Studio Code application.
4. In Visual Studio Code, click the Extensions icon or navigate to View | Extensions.
5. C# is one of the most popular extensions available, so you should see it at the top of the list, or you can enter C# in the search box.
6. Click Install and wait for supporting packages to download and install.
7. Enter .NET Interactive in the search box to find the .NET Interactive Notebooks extension.
8. Click Install and wait for it to install.

In later chapters of this book, you will use more extensions. If you want to install them now, all the extensions that we will use are shown in the following table:

Microsoft releases a new feature version of Visual Studio Code (almost) every month and bug fix versions more frequently. For example:

• Version 1.59, August 2021 feature release
• Version 1.59.1, August 2021 bug fix release

The version used in this book is 1.59, but the version of Microsoft Visual Studio Code is less important than the version of the C# for Visual Studio Code extension that you installed.

While the C# extension is not required, it provides IntelliSense as you type, code navigation, and debugging features, so it's something that's very handy to install and keep updated to support the latest C# language features.

In this book, I will avoid showing keyboard shortcuts used for tasks like creating a new file since they are often different on different operating systems. The situations where I will show keyboard shortcuts are when you need to repeatedly press the key, for example, while debugging. These are also more likely to be consistent across operating systems.

If you want to customize your keyboard shortcuts for Visual Studio Code, then you can, as shown at the following link: https://code.visualstudio.com/docs/getstarted/keybindings.

I recommend that you download a PDF of keyboard shortcuts for your operating system from the following list:

• Windows: https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf
• macOS: https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf
• Linux: https://code.visualstudio.com/shortcuts/keyboard-shortcuts-linux.pdf

.NET 6, .NET Core, .NET Framework, and Xamarin are related and overlapping platforms for developers used to build applications and services. In this section, I'm going to introduce you to each of these .NET concepts.

.NET Framework is a development platform that includes a Common Language Runtime (CLR), which manages the execution of code, and a Base Class Library (BCL), which provides a rich library of classes to build applications from.

Microsoft originally designed .NET Framework to have the possibility of being cross-platform, but Microsoft put their implementation effort into making it work best with Windows.

Since .NET Framework 4.5.2, it has been an official component of the Windows operating system. Components have the same support as their parent products, so 4.5.2 and later follow the life cycle policy of the Windows OS on which it is installed. .NET Framework is installed on over one billion computers, so it must change as little as possible. Even bug fixes can cause problems, so it is updated infrequently.

For .NET Framework 4.0 or later, all of the apps on a computer written for .NET Framework share the same version of the CLR and libraries stored in the Global Assembly Cache (GAC), which can lead to issues if some of them need a specific version for compatibility.

Third parties developed a .NET Framework implementation named the Mono project. Mono is cross-platform, but it fell well behind the official implementation of .NET Framework.

Mono has found a niche as the foundation of the Xamarin mobile platform as well as cross-platform game development platforms like Unity.

Microsoft purchased Xamarin in 2016 and now gives away what used to be an expensive Xamarin extension for free with Visual Studio. Microsoft renamed the Xamarin Studio development tool, which could only create mobile apps, to Visual Studio for Mac and gave it the ability to create other types of projects like console apps and web services. With Visual Studio 2022 for Mac, Microsoft has replaced parts of the Xamarin Studio editor with parts from Visual Studio 2022 for Windows to provide closer parity of experience and performance. Visual Studio 2022 for Mac was also rewritten to be a truly native macOS UI app to improve reliability and work with macOS's built-in assistive technologies.

Today, we live in a truly cross-platform world where modern mobile and cloud development have made Windows, as an operating system, much less important. Because of that, Microsoft has been working on an effort to decouple .NET from its close ties with Windows. While rewriting .NET Framework to be truly cross-platform, they've taken the opportunity to refactor and remove major parts that are no longer considered core.

This new product was branded .NET Core and includes a cross-platform implementation of the CLR known as CoreCLR and a streamlined BCL known as CoreFX.

Scott Hunter, Microsoft Partner Director Program Manager for .NET, has said that "Forty percent of our .NET Core customers are brand-new developers to the platform, which is what we want with .NET Core. We want to bring new people in."

.NET Core is fast-moving, and because it can be deployed side by side with an app, it can change frequently, knowing those changes will not affect other .NET Core apps on the same machine. Most improvements that Microsoft makes to .NET Core and modern .NET cannot be easily added to .NET Framework.

At the Microsoft Build developer conference in May 2020, the .NET team announced that their plans for the unification of .NET had been delayed. They said that .NET 5 would be released on November 10, 2020, and it would unify all the various .NET platforms except mobile. It would not be until .NET 6 in November 2021 that mobile will also be supported by the unified .NET platform.

.NET Core has been renamed .NET and the major version number has skipped the number four to avoid confusion with .NET Framework 4.x. Microsoft plans on annual major version releases every November, rather like Apple does major version number releases of iOS every September.

The following table shows when the key versions of modern .NET were released, when future releases are planned, and which version is used by the various editions of this book:

.NET Core 3.1 included Blazor Server for building web components. Microsoft had also planned to include Blazor WebAssembly in that release, but it was delayed. Blazor WebAssembly was later released as an optional add-on for .NET Core 3.1. I include it in the table above because it was versioned as 3.2 to exclude it from the LTS of .NET Core 3.1.

.NET versions are either Long Term Support (LTS) or Current, as described in the following list:

• LTS releases are stable and require fewer updates over their lifetime. These are a good choice for applications that you do not intend to update frequently. LTS releases will be supported for 3 years after general availability, or 1 year after the next LTS release ships, whichever is longer.
• Current releases include features that may change based on feedback. These are a good choice for applications that you are actively developing because they provide access to the latest improvements. After a 6-month maintenance period, or 18 months after general availability, the previous minor version will no longer be supported.

Both receive critical fixes throughout their lifetime for security and reliability. You must stay up to date with the latest patches to get support. For example, if a system is running 1.0 and 1.0.1 has been released, 1.0.1 will need to be installed to get support.

To better understand your choices of Current and LTS releases, it is helpful to see it visually, with 3-year-long black bars for LTS releases, and variable-length gray bars for Current releases that end with cross-hatching for the 6 months after a new major or minor release that they retain support for, as shown in Figure 1.2:

Figure 1.2: Support for various versions

For example, if you had created a project using .NET Core 3.0, then when Microsoft released .NET Core 3.1 in December 2019, you had to upgrade your project to .NET Core 3.1 by March 2020. (Before .NET 5, the maintenance period for Current releases was only three months.)

If you need long-term support from Microsoft, then choose .NET 6.0 today and stick with it until .NET 8.0, even once Microsoft releases .NET 7.0. This is because .NET 7.0 will be a current release and it will therefore lose support before .NET 6.0 does. Just remember that even with LTS releases you must upgrade to bug fix releases like 6.0.1.

All versions of .NET Core and modern .NET have reached their end of life except those shown in the following list:

• .NET 5.0 will reach end of life in May 2022.
• .NET Core 3.1 will reach end of life on December 3, 2022.
• .NET 6.0 will reach end of life in November 2024.

.NET Runtime versioning follows semantic versioning, that is, a major increment indicates breaking changes, minor increments indicate new features, and patch increments indicate bug fixes.

.NET SDK versioning does not follow semantic versioning. The major and minor version numbers are tied to the runtime version it is matched with. The patch number follows a convention that indicates the major and minor versions of the SDK.

You can see an example of this in the following table:

.NET Runtime updates are compatible with a major version such as 6.x, and updated releases of the .NET SDK maintain the ability to build applications that target previous versions of the runtime, which enables the safe removal of older versions.

You can see which SDKs and runtimes are currently installed using the following commands:

• dotnet --list-sdks
• dotnet --list-runtimes

On Windows, use the App & features section to remove .NET SDKs. On macOS or Windows, use the dotnet-core-uninstall tool. This tool is not installed by default.

For example, while writing the fourth edition, I used the following command every month:

dotnet-core-uninstall remove --all-previews-but-latest --sdk

Modern .NET is modularized compared to the legacy .NET Framework, which is monolithic. It is open source and Microsoft makes decisions about improvements and changes in the open. Microsoft has put particular effort into improving the performance of modern .NET.

It is smaller than the last version of .NET Framework due to the removal of legacy and non-cross-platform technologies. For example, workloads such as Windows Forms and Windows Presentation Foundation (WPF) can be used to build graphical user interface (GUI) applications, but they are tightly bound to the Windows ecosystem, so they are not included with .NET on macOS and Linux.

One of the features of modern .NET is support for running old Windows Forms and WPF applications using the Windows Desktop Pack that is included with the Windows version of .NET Core 3.1 or later, which is why it is bigger than the SDKs for macOS and Linux. You can make some small changes to your legacy Windows app if necessary, and then rebuild it for .NET 6 to take advantage of new features and performance improvements.

ASP.NET Web Forms and Windows Communication Foundation (WCF) are old web application and service technologies that fewer developers are choosing to use for new development projects today, so they have also been removed from modern .NET. Instead, developers prefer to use ASP.NET MVC, ASP.NET Web API, SignalR, and gRPC. These technologies have been refactored and combined into a platform that runs on modern .NET, named ASP.NET Core. You'll learn about the technologies in Chapter 14, Building Websites Using ASP.NET Core Razor Pages, Chapter 15, Building Websites Using the Model-View-Controller Pattern, Chapter 16, Building and Consuming Web Services, and Chapter 18, Building and Consuming Specialized Services.

Entity Framework (EF) 6 is an object-relational mapping technology that is designed to work with data that is stored in relational databases such as Oracle and Microsoft SQL Server. It has gained baggage over the years, so the cross-platform API has been slimmed down, has been given support for non-relational databases like Microsoft Azure Cosmos DB, and has been renamed Entity Framework Core. You will learn about it in Chapter 10, Working with Data Using Entity Framework Core.

If you have existing apps that use the old EF, then version 6.3 is supported on .NET Core 3.0 or later.

Microsoft has created a website using Blazor that shows the major themes of modern .NET: https://themesof.net/.

The situation with .NET in 2019 was that there were three forked .NET platforms controlled by Microsoft, as shown in the following list:

• .NET Core: For cross-platform and new apps
• .NET Framework: For legacy apps
• Xamarin: For mobile apps

Each had strengths and weaknesses because they were all designed for different scenarios. This led to the problem that a developer had to learn three platforms, each with annoying quirks and limitations.

Because of that, Microsoft defined .NET Standard – a specification for a set of APIs that all .NET platforms could implement to indicate what level of compatibility they have. For example, basic support is indicated by a platform being compliant with .NET Standard 1.4.

With .NET Standard 2.0 and later, Microsoft made all three platforms converge on a modern minimum standard, which made it much easier for developers to share code between any flavor of .NET.

For .NET Core 2.0 and later, this added most of the missing APIs that developers need to port old code written for .NET Framework to the cross-platform .NET Core. However, some APIs are implemented but throw an exception to indicate to a developer that they should not actually be used! This is usually due to differences in the operating system on which you run .NET. You'll learn how to handle these exceptions in Chapter 2, Speaking C#.

It is important to understand that .NET Standard is just a standard. You are not able to install .NET Standard in the same way that you cannot install HTML5. To use HTML5, you must install a web browser that implements the HTML5 standard.

To use .NET Standard, you must install a .NET platform that implements the .NET Standard specification. The last .NET Standard, version 2.1, is implemented by .NET Core 3.0, Mono, and Xamarin. Some features of C# 8.0 require .NET Standard 2.1. .NET Standard 2.1 is not implemented by .NET Framework 4.8, so we should treat .NET Framework as legacy.

With the release of .NET 6 in November 2021, the need for .NET Standard has reduced significantly because there is now a single .NET for all platforms, including mobile. .NET 6 has a single BCL and two CLRs: CoreCLR is optimized for server or desktop scenarios like websites and Windows desktop apps, and the Mono runtime is optimized for mobile and web browser apps that have limited resources.

Even now, apps and websites created for .NET Framework will need to be supported, so it is important to understand that you can create .NET Standard 2.0 class libraries that are backward compatible with legacy .NET platforms.

For the first edition of this book, which was written in March 2016, I focused on .NET Core functionality but used .NET Framework when important or useful features had not yet been implemented in .NET Core because that was before the final release of .NET Core 1.0. Visual Studio 2015 was used for most examples, with Visual Studio Code shown only briefly.

The second edition was (almost) completely purged of all .NET Framework code examples so that readers were able to focus on .NET Core examples that truly run cross-platform.

The third edition completed the switch. It was rewritten so that all of the code was pure .NET Core. But giving step-by-step instructions for both Visual Studio Code and Visual Studio 2017 for all tasks added complexity.

The fourth edition continued the trend by only showing coding examples using Visual Studio Code for all but the last two chapters. In Chapter 20, Building Windows Desktop Apps, it used Visual Studio running on Windows 10, and in Chapter 21, Building Cross-Platform Mobile Apps, it used Visual Studio for Mac.

In the fifth edition, Chapter 20, Building Windows Desktop Apps, was moved to Appendix B to make space for a new Chapter 20, Building Web User Interfaces Using Blazor. Blazor projects can be created using Visual Studio Code.

In this sixth edition, Chapter 19, Building Mobile and Desktop Apps Using .NET MAUI, was updated to show how mobile and desktop cross-platform apps can be created using Visual Studio 2022 and .NET MAUI (Multi-platform App UI).

By the seventh edition and the release of .NET 7, Visual Studio Code will have an extension to support .NET MAUI. At that point, readers will be able to use Visual Studio Code for all examples in the book.

The C# compiler (named Roslyn) used by the dotnet CLI tool converts your C# source code into intermediate language (IL) code and stores the IL in an assembly (a DLL or EXE file). IL code statements are like assembly language instructions, which are executed by .NET's virtual machine, known as CoreCLR.

At runtime, CoreCLR loads the IL code from the assembly, the just-in-time (JIT) compiler compiles it into native CPU instructions, and then it is executed by the CPU on your machine.

The benefit of this two-step compilation process is that Microsoft can create CLRs for Linux and macOS, as well as for Windows. The same IL code runs everywhere because of the second compilation step, which generates code for the native operating system and CPU instruction set.

Regardless of which language the source code is written in, for example, C#, Visual Basic, or F#, all .NET applications use IL code for their instructions stored in an assembly. Microsoft and others provide disassembler tools that can open an assembly and reveal this IL code, such as the ILSpy .NET Decompiler extension.

We can summarize and compare .NET technologies today, as shown in the following table:

The goal of this section is to showcase how to build a console app using Visual Studio 2022 for Windows.

If you do not have a Windows computer or you want to use Visual Studio Code, then you can skip this section since the code will be the same, just the tooling experience is different.

Visual Studio 2022 has a concept named a solution that allows you to open and manage multiple projects simultaneously. We will use a solution to manage the two projects that you will create in this chapter.

Let's get started writing code!

1. Start Visual Studio 2022.
2. In the Start window, click Create a new project.
3. In the Create a new project dialog, enter console in the Search for templates box, and select Console Application, making sure that you have chosen the C# project template rather than another language, such as F# or Visual Basic, as shown in Figure 1.3:

   

   Figure 1.3: Selecting the Console Application project template

4. Click Next.
5. In the Configure your new project dialog, enter HelloCS for the project name, enter C:\Code for the location, and enter Chapter01 for the solution name, as shown in Figure 1.4:

   

   Figure 1.4: Configuring names and locations for your new project

6. Click Next.

   We are deliberately going to use the older project template for .NET 5.0 to see what a full console application looks like. In the next section, you will create a console application using .NET 6.0 and see what has changed.

7. In the Additional information dialog, in the Target Framework drop-down list, note the choices of Current and long-term support versions of .NET, and then select .NET 5.0 (Current) and click Create.
8. In Solution Explorer, double-click to open the file named Program.cs, and note that Solution Explorer shows the HelloCS project, as shown in Figure 1.5:

   

   Figure 1.5: Editing Program.cs in Visual Studio 2022

9. In Program.cs, modify line 9 so that the text that is being written to the console says Hello, C#!

The next task is to compile and run the code.

1. In Visual Studio, navigate to Debug | Start Without Debugging.
2. The output in the console window will show the result of running your application, as shown in Figure 1.6:

   

   Figure 1.6: Running the console app on Windows

3. Press any key to close the console window and return to Visual Studio.
4. Select the HelloCS project and then, in the Solution Explorer toolbar, toggle on the Show All Files button, and note that the compiler-generated bin and obj folders are visible, as shown in Figure 1.7:

   

   Figure 1.7: Showing the compiler-generated folders and files

Two compiler-generated folders were created, named obj and bin. You do not need to look inside these folders or understand their files yet. Just be aware that the compiler needs to create temporary folders and files to do its work. You could delete these folders and their files, and they can be recreated later. Developers often do this to "clean" a project. Visual Studio even has a command on the Build menu named Clean Solution that deletes some of these temporary files for you. The equivalent command with Visual Studio Code is dotnet clean.

• The obj folder contains one compiled object file for each source code file. These objects haven't been linked together into a final executable yet.
• The bin folder contains the binary executable for the application or class library. We will look at this in more detail in Chapter 7, Packaging and Distributing .NET Types.

You might be thinking that was a lot of code just to output Hello, C#!.

Although the boilerplate code is written for you by the project template, is there a simpler way?

Well, in C# 9 or later, there is, and it is known as top-level programs.

Let's compare the console app created by the project template, as shown in the following code:

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

To the new top-level program minimum console app, as shown in the following code:

using System;
Console.WriteLine("Hello World!");

That is a lot simpler, right? If you had to start with a blank file and write all the statements yourself, this is better. But how does it work?

During compilation, all the boilerplate code to define a namespace, the Program class, and its Main method, is generated and wrapped around the statements you write.

Key points to remember about top-level programs include the following list:

• Any using statements still must to go at the top of the file.
• There can be only one file like this in a project.

The using System; statement at the top of the file imports the System namespace. This enables the Console.WriteLine statement to work. You will learn more about namespaces in the next chapter.

Let's add a second project to our solution to explore top-level programs:

1. In Visual Studio, navigate to File | Add | New Project.
2. In the Add a new project dialog, in Recent project templates, select Console Application [C#] and then click Next.
3. In the Configure your new project dialog, for the Project name, enter TopLevelProgram, leave the location as C:\Code\Chapter01, and then click Next.
4. In the Additional information dialog, select .NET 6.0 (Long-term support), and then click Create.
5. In Solution Explorer, in the TopLevelProgram project, double-click Program.cs to open it.
6. In Program.cs, note the code consists of only a comment and a single statement because it uses the top-level program feature introduced in C# 9, as shown in the following code:

   // See https://aka.ms/new-console-template for more information
   Console.WriteLine("Hello, World!");
   

But when I introduced the concept of top-level programs earlier, we needed a using System; statement. Why don't we need that here?

The trick is that we do still need to import the System namespace, but it is now done for us using a feature introduced in C# 10. Let's see how:

1. In Solution Explorer, select the TopLevelProgram project and toggle on the Show All Files button, and note that the compiler-generated bin and obj folders are visible.
2. Expand the obj folder, expand the Debug folder, expand the net6.0 folder, and open the file named TopLevelProgram.GlobalUsings.g.cs.
3. Note that this file is automatically created by the compiler for projects that target .NET 6, and that it uses a feature introduced in C# 10 called global imports that imports some commonly used namespaces like System for use in all code files, as shown in the following code:

   // <autogenerated />
   global using global::System;
   global using global::System.Collections.Generic;
   global using global::System.IO;
   global using global::System.Linq;
   global using global::System.Net.Http;
   global using global::System.Threading;
   global using global::System.Threading.Tasks;
   

   I will explain more about this feature in the next chapter. For now, just note that a significant change between .NET 5 and .NET 6 is that many of the project templates, like the one for console applications, use new language features to hide what is really happening.

4. In the TopLevelProgram project, in Program.cs, modify the statement to output a different message and the version of the operating system, as shown in the following code:

   Console.WriteLine("Hello from a Top Level Program!");
   Console.WriteLine(Environment.OSVersion.VersionString);
   

5. In Solution Explorer, right-click the Chapter01 solution, select Set Startup Projects…, set Current selection, and then click OK.
6. In Solution Explorer, click the TopLevelProgram project (or any file or folder within it), and note that Visual Studio indicates that TopLevelProgram is now the startup project by making the project name bold.
7. Navigate to Debug | Start Without Debugging to run the TopLevelProgram project, and note the result, as shown in Figure 1.8:

   

   Figure 1.8: Running a top-level program in a Visual Studio solution with two projects on Windows

The goal of this section is to showcase how to build a console app using Visual Studio Code.

If you never want to try Visual Studio Code or .NET Interactive Notebooks, then please feel free to skip this section and the next, and then continue with the Reviewing the folders and files for projects section.

Both the instructions and screenshots in this section are for Windows, but the same actions will work with Visual Studio Code on the macOS and Linux variants.

The main differences will be native command-line actions such as deleting a file: both the command and the path are likely to be different on Windows or macOS and Linux. Luckily, the dotnet command-line tool will be identical on all platforms.

Visual Studio Code has a concept named a workspace that allows you to open and manage multiple projects simultaneously. We will use a workspace to manage the two projects that you will create in this chapter.

Let's get started writing code!

1. Start Visual Studio Code.
2. Make sure that you do not have any open files, folders, or workspaces.
3. Navigate to File | Save Workspace As….
4. In the dialog box, navigate to your user folder on macOS (mine is named markjprice), your Documents folder on Windows, or any directory or drive in which you want to save your projects.
5. Click the New Folder button and name the folder Code. (If you completed the section for Visual Studio 2022, then this folder will already exist.)
6. In the Code folder, create a new folder named Chapter01-vscode.
7. In the Chapter01-vscode folder, save the workspace as Chapter01.code-workspace.
8. Navigate to File | Add Folder to Workspace… or click the Add Folder button.
9. In the Chapter01-vscode folder, create a new folder named HelloCS.
10. Select the HelloCS folder and click the Add button.
11. Navigate to View | Terminal.

    We are deliberately going to use the older project template for .NET 5.0 to see what a full console application looks like. In the next section, you will create a console application using .NET 6.0 and see what has changed.

12. In TERMINAL, make sure that you are in the HelloCS folder, and then use the dotnet command-line tool to create a new console app that targets .NET 5.0, as shown in the following command:

    dotnet new console -f net5.0
    

13. You will see that the dotnet command-line tool creates a new Console Application project for you in the current folder, and the EXPLORER window shows the two files created, HelloCS.csproj and Program.cs, and the obj folder, as shown in Figure 1.9:

    

    Figure 1.9: The EXPLORER window will show that two files and a folder have been created

14. In EXPLORER, click on the file named Program.cs to open it in the editor window. The first time that you do this, Visual Studio Code may have to download and install C# dependencies like OmniSharp, .NET Core Debugger, and Razor Language Server, if it did not do this when you installed the C# extension or if they need updating. Visual Studio Code will show progress in the Output window and eventually the message Finished, as shown in the following output:

    Installing C# dependencies...
    Platform: win32, x86_64
    Downloading package 'OmniSharp for Windows (.NET 4.6 / x64)' (36150 KB).................... Done!
    Validating download...
    Integrity Check succeeded.
    Installing package 'OmniSharp for Windows (.NET 4.6 / x64)'
    Downloading package '.NET Core Debugger (Windows / x64)' (45048 KB).................... Done!
    Validating download...
    Integrity Check succeeded.
    Installing package '.NET Core Debugger (Windows / x64)'
    Downloading package 'Razor Language Server (Windows / x64)' (52344 KB).................... Done!
    Installing package 'Razor Language Server (Windows / x64)'
    Finished
    

    The preceding output is from Visual Studio Code on Windows. When run on macOS or Linux, the output will look slightly different, but the equivalent components for your operating system will be downloaded and installed.

15. Folders named obj and bin will have been created and when you see a notification saying that required assets are missing, click Yes, as shown in Figure 1.10:

    

    Figure 1.10: Warning message to add required build and debug assets

16. If the notification disappears before you can interact with it, then you can click the bell icon in the far-right corner of the status bar to show it again.
17. After a few seconds, another folder named .vscode will be created with some files that are used by Visual Studio Code to provide features like IntelliSense during debugging, which you will learn more about in Chapter 4, Writing, Debugging, and Testing Functions.
18. In Program.cs, modify line 9 so that the text that is being written to the console says Hello, C#!

    Good Practice: Navigate to File | Auto Save. This toggle will save the annoyance of remembering to save before rebuilding your application each time.

The next task is to compile and run the code:

1. Navigate to View | Terminal and enter the following command:

   dotnet run
   

2. The output in the TERMINAL window will show the result of running your application, as shown in Figure 1.11:

   

Figure 1.11: The output of running your first console application

Let's add a second project to our workspace to explore top-level programs:

1. In Visual Studio Code, navigate to File | Add Folder to Workspace….
2. In the Chapter01-vscode folder, use the New Folder button to create a new folder named TopLevelProgram, select it, and click Add.
3. Navigate to Terminal | New Terminal, and in the drop-down list that appears, select TopLevelProgram. Alternatively, in EXPLORER, right-click the TopLevelProgram folder and then select Open in Integrated Terminal.
4. In TERMINAL, confirm that you are in the TopLevelProgram folder, and then enter the command to create a new console application, as shown in the following command:

   dotnet new console
   

   Good Practice: When using workspaces, be careful when entering commands in TERMINAL. Be sure that you are in the correct folder before entering potentially destructive commands! That is why I got you to create a new terminal for TopLevelProgram before issuing the command to create a new console app.

5. Navigate to View | Command Palette.
6. Enter omni, and then, in the drop-down list that appears, select OmniSharp: Select Project.
7. In the drop-down list of two projects, select the TopLevelProgram project, and when prompted, click Yes to add required assets to debug.

   Good Practice: To enable debugging and other useful features, like code formatting and Go to Definition, you must tell OmniSharp which project you are actively working on in Visual Studio Code. You can quickly toggle active projects by clicking the project/folder to the right of the flame icon on the left side of the status bar.

8. In EXPLORER, in the TopLevelProgram folder, select Program.cs, and then change the existing statement to output a different message and also output the operating system version string, as shown in the following code:

   Console.WriteLine("Hello from a Top Level Program!");
   Console.WriteLine(Environment.OSVersion.VersionString);
   

9. In TERMINAL, enter the command to run a program, as shown in the following command:

   dotnet run
   

10. Note the output in the TERMINAL window, as shown in Figure 1.12:

    

    Figure 1.12: Running a top-level program in a Visual Studio Code workspace with two projects on Windows

If you were to run the program on macOS Big Sur, the environment operating system would be different, as shown in the following output:

Hello from a Top Level Program!
Unix 11.2.3

If you have multiple files that you want to work with at the same time, then you can put them side by side as you edit them:

1. In EXPLORER, expand the two projects.
2. Open both Program.cs files from the two projects.
3. Click, hold, and drag the edit window tab for one of your open files to arrange them so that you can see both files at the same time.

.NET Interactive Notebooks makes writing code even easier than top-level programs. It requires Visual Studio Code, so if you did not install it earlier, please install it now.

First, we need to create a notebook:

1. In Visual Studio Code, close any open workspaces or folders.
2. Navigate to View | Command Palette.
3. Type .net inter, and then select .NET Interactive: Create new blank notebook, as shown in Figure 1.13:

   

   Figure 1.13: Creating a new blank .NET notebook

4. When prompted to select the file extension, choose Create as '.dib'.

   .dib is an experimental file format defined by Microsoft to avoid confusion and compatibility issues with the .ipynb format used by Python interactive notebooks. The file extension was historically only for Jupyter notebooks that can contain an interactive (I) mix of data, Python code (PY), and output in a notebook file (NB). With .NET Interactive Notebooks, the concept has expanded to allow a mix of C#, F#, SQL, HTML, JavaScript, Markdown, and other languages. .dib is polyglot, meaning it supports mixed languages. Conversion between the .dib and .ipynb file formats is supported.

5. Select C# for the default language for code cells in the notebook.
6. If a newer version of .NET Interactive is available, you might have to wait for it to uninstall the older version and install the newer one. Navigate to View | Output and select .NET Interactive : diagnostics in the drop-down list. Please be patient. It can take a few minutes for the notebook to appear because it has to start up a hosting environment for .NET. If nothing happens after a few minutes, then close Visual Studio Code and restart it.
7. Once the .NET Interactive Notebooks extension is downloaded and installed, the OUTPUT window diagnostics will show that a Kernel process has started (your process and port number will be different from the output below), as shown in the following output, which has been edited to save space:

   Extension started for VS Code Stable.
   ...
   Kernel process 12516 Port 59565 is using tunnel uri http://localhost:59565/
   

Next, we can write code in the notebook cells:

1. The first cell should already be set to C# (.NET Interactive), but if it is set to anything else, then click the language selector in the bottom-right corner of the code cell and then select C# (.NET Interactive) as the language mode for that cell, and note your other choices of language for a code cell, as shown in Figure 1.14:

   

   Figure 1.14: Changing the language for a code cell in a .NET Interactive notebook

2. Inside the C# (.NET Interactive) code cell, enter a statement to output a message to the console, and note that you do not need to end the statement with a semicolon, as you normally would in a full application, as shown in the following code:

   Console.WriteLine("Hello, .NET Interactive!")
   

3. Click the Execute Cell button to the left of the code cell and note the output that appears in the gray box under the code cell, as shown in Figure 1.15:

   

   Figure 1.15: Running code in a notebook and seeing the output below

Like any other file, we should save the notebook before continuing further:

1. Navigate to File | Save As….
2. Change to the Chapter01-vscode folder and save the notebook as Chapter01.dib.
3. Close the Chapter01.dib editor tab.

We can mix and match cells containing Markdown and code with special commands:

1. Navigate to File | Open File…, and select the Chapter01.dib file.
2. If you are prompted with Do you trust the authors of these files?, click Open.
3. Hover your mouse above the code block and click + Markup to add a Markdown cell.
4. Type a heading level 1, as shown in the following Markdown:

   # Chapter 1 - Hello, C#! Welcome, .NET!
   Mixing *rich* **text** and code is cool!
   

5. Click the tick in the top-right corner of the cell to stop editing the cell and view the processed Markdown.

   If your cells are in the wrong order, then you can drag and drop to rearrange them.

6. Hover between the Markdown cell and the code cell and click + Code.
7. Type a special command to output version information about .NET Interactive, as shown in the following code:

   #!about
   

8. Click the Execute Cell button and note the output, as shown in Figure 1.16:

   

   Figure 1.16: Mixing Markdown, code, and special commands in a .NET Interactive notebook

When you have multiple code cells in a notebook, you must execute the preceding code cells before their context becomes available in subsequent code cells:

1. At the bottom of the notebook, add a new code cell, and then type a statement to declare a variable and assign an integer value, as shown in the following code:

   int number = 8;
   

2. At the bottom of the notebook, add a new code cell, and then type a statement to output the number variable, as shown in the following code:

   Console.WriteLine(number);
   

3. Note the second code cell does not know about the number variable because it was defined and assigned in another code cell, aka context, as shown in Figure 1.17:

   

   Figure 1.17: The number variable does not exist in the current cell or context

4. In the first cell, click the Execute Cell button to declare and assign a value to the variable, and then in the second cell, click the Execute Cell button to output the number variable, and note that this works. (Alternatively, in the first cell, you can click the Execute Cell and Below button.)

   Good Practice: If you have related code split between two cells, remember to execute the preceding cell before executing the subsequent cell. At the top of the notebook, there are the following buttons – Clear Outputs and Run All. These are very handy because you can click one and then the other to ensure that all code cells are executed properly, as long as they are in the correct order.

Throughout the rest of the chapters, I will not give explicit instructions to use notebooks, but the GitHub repository for the book has solution notebooks when appropriate. I expect many readers will want to run my pre-created notebooks for language and library features covered in Chapters 2 to 12, which they want to see in action and learn about without having to write a complete application, even if it is just a console app:

https://github.com/markjprice/cs10dotnet6/tree/main/notebooks

In this chapter, you created two projects named HelloCS and TopLevelProgram.

Visual Studio Code uses a workspace file to manage multiple projects. Visual Studio 2022 uses a solution file to manage multiple projects. You also created a .NET Interactive notebook.

The result is a folder structure and files that will be repeated in subsequent chapters, although with more than just two projects, as shown in Figure 1.18:

Figure 1.18: Folder structure and files for the two projects in this chapter

Although .code-workspace and .sln files are different, the project folders and files such as HelloCS and TopLevelProgram are identical for Visual Studio 2022 and Visual Studio Code. This means that you can mix and match between both code editors if you like:

• In Visual Studio 2022, with a solution open, navigate to File | Add Existing Project… to add a project file created by another tool.
• In Visual Studio Code, with a workspace open, navigate to File | Add Folder to Workspace… to add a project folder created by another tool.

  Good Practice: Although the source code, like the .csproj and .cs files, is identical, the bin and obj folders that are automatically generated by the compiler could have mismatched file versions that give errors. If you want to open the same project in both Visual Studio 2022 and Visual Studio Code, delete the temporary bin and obj folders before opening the project in the other code editor. This is why I asked you to create a different folder for the Visual Studio Code solutions in this chapter.

The solution code in the GitHub repository for this book includes separate folders for Visual Studio Code, Visual Studio 2022, and .NET Interactive notebook files, as shown in the following list:

• Visual Studio 2022 solutions: https://github.com/markjprice/cs10dotnet6/tree/main/vs4win
• Visual Studio Code solutions: https://github.com/markjprice/cs10dotnet6/tree/main/vscode
• .NET Interactive Notebook solutions: https://github.com/markjprice/cs10dotnet6/tree/main/notebooks

  Good Practice: If you need to, return to this chapter to remind yourself how to create and manage multiple projects in the code editor of your choice. The GitHub repository has step-by-step instructions for four code editors (Visual Studio 2022 for Windows, Visual Studio Code, Visual Studio 2022 for Mac, and JetBrains Rider), along with additional screenshots: https://github.com/markjprice/cs10dotnet6/blob/main/docs/code-editors/.

Git is a commonly used source code management system. GitHub is a company, website, and desktop application that makes it easier to manage Git. Microsoft purchased GitHub in 2018, so it will continue to get closer integration with Microsoft tools.

I created a GitHub repository for this book, and I use it for the following:

• To store the solution code for the book that can be maintained after the print publication date.
• To provide extra materials that extend the book, like errata fixes, small improvements, lists of useful links, and longer articles that cannot fit in the printed book.
• To provide a place for readers to get in touch with me if they have issues with the book.

If you get stuck following any of the instructions in this book, or if you spot a mistake in the text or the code in the solutions, please raise an issue in the GitHub repository:

1. Use your favorite browser to navigate to the following link: https://github.com/markjprice/cs10dotnet6/issues.
2. Click New Issue.
3. Enter as much detail as possible that will help me to diagnose the issue. For example:
   1. Your operating system, for example, Windows 11 64-bit, or macOS Big Sur version 11.2.3.
   2. Your hardware, for example, Intel, Apple Silicon, or ARM CPU.
   3. Your code editor, for example, Visual Studio 2022, Visual Studio Code, or something else, including the version number.
   4. As much of your code and configuration that you feel is relevant and necessary.
   5. Description of expected behavior and the behavior experienced.
   6. Screenshots (if possible).

Writing this book is a side hustle for me. I have a full-time job, so I mostly work on the book at weekends. This means that I cannot always respond immediately to issues. But I want all my readers to be successful with my book, so if I can help you (and others) without too much trouble, then I will gladly do so.

If you'd like to give me more general feedback about the book, then the GitHub repository README.md page has links to some surveys. You can provide the feedback anonymously, or if you would like a response from me, then you can supply an email address. I will only use this email address to answer your feedback.

I love to hear from my readers about what they like about my book, as well as suggestions for improvements and how they are working with C# and .NET, so don't be shy. Please get in touch!

Thank you in advance for your thoughtful and constructive feedback.

I use GitHub to store solutions to all the hands-on, step-by-step coding examples throughout chapters and the practical exercises that are featured at the end of each chapter. You will find the repository at the following link: https://github.com/markjprice/cs10dotnet6.

If you just want to download all the solution files without using Git, click the green Code button and then select Download ZIP, as shown in Figure 1.19:

Figure 1.19: Downloading the repository as a ZIP file

I recommend that you add the preceding link to your favorite bookmarks because I also use the GitHub repository for this book for publishing errata (corrections) and other useful links.

Visual Studio Code has support for Git, but it will use your operating system's Git installation, so you must install Git 2.0 or later first before you get these features.

You can install Git from the following link: https://git-scm.com/download.

If you like to use a GUI, you can download GitHub Desktop from the following link: https://desktop.github.com.

Let's clone the book solution code repository. In the steps that follow, you will use the Visual Studio Code terminal, but you could enter the commands at any command prompt or terminal window:

1. Create a folder named Repos-vscode in your user or Documents folder, or wherever you want to store your Git repositories.
2. In Visual Studio Code, open the Repos-vscode folder.
3. Navigate to View | Terminal, and enter the following command:

   git clone https://github.com/markjprice/cs10dotnet6.git
   

4. Note that cloning all the solutions for all of the chapters will take a minute or so, as shown in Figure 1.20:

   

   Figure 1.20: Cloning the book solution code using Visual Studio Code

This section is all about how to find quality information about programming on the web.

The definitive resource for getting help with Microsoft developer tools and platforms is Microsoft Docs, and you can find it at the following link: https://docs.microsoft.com/.

At the command line, you can ask the dotnet tool for help with its commands:

1. To open the official documentation in a browser window for the dotnet new command, enter the following at the command line or in the Visual Studio Code terminal:

   dotnet help new
   

2. To get help output at the command line, use the -h or --help flag, as shown in the following command:

   dotnet new console -h
   

3. You will see the following partial output:

   Console Application (C#)
   Author: Microsoft
   Description: A project for creating a command-line application that can run on .NET Core on Windows, Linux and macOS
   Options:
     -f|--framework. The target framework for the project.
                         net6.0           - Target net6.0
                         net5.0           - Target net5.0
                         netcoreapp3.1.   - Target netcoreapp3.1
                         netcoreapp3.0.   - Target netcoreapp3.0
                     Default: net6.0
   --langVersion    Sets langVersion in the created project file text – Optional
   

One of the most useful features of a code editor is Go To Definition. It is available in Visual Studio Code and Visual Studio 2022. It will show what the public definition of the type or member looks like by reading the metadata in the compiled assembly.

Some tools, such as ILSpy .NET Decompiler, will even reverse-engineer from the metadata and IL code back into C# for you.

Let's see how to use the Go To Definition feature:

1. In Visual Studio 2022 or Visual Studio Code, open the solution/workspace named Chapter01.
2. In the HelloCS project, in Program.cs, in Main, enter the following statement to declare an integer variable named z:

   int z;
   

3. Click inside int and then right-click and choose Go To Definition.
4. In the code window that appears, you can see how the int data type is defined, as shown in Figure 1.21:

   

   Figure 1.21: The int data type metadata

   You can see that int:

   • Is defined using the struct keyword
   • Is in the System.Runtime assembly
   • Is in the System namespace
   • Is named Int32
   • Is therefore an alias for the System.Int32 type
   • Implements interfaces such as IComparable
   • Has constant values for its maximum and minimum values
   • Has methods such as Parse

   Good Practice: When you try to use Go To Definition in Visual Studio Code, you will sometimes see an error saying No definition found. This is because the C# extension does not know about the current project. To fix this issue, navigate to View | Command Palette, enter omni, select OmniSharp: Select Project, and then select the project that you want to work with.

   Right now, the Go To Definition feature is not that useful to you because you do not yet know what all of this information means.

   By the end of the first part of this book, which consists of Chapters 2 to 6, and which teaches you about C#, you will know enough for this feature to become very handy.

5. In the code editor window, scroll down to find the Parse method with a single string parameter on line 106, and the comments that document it on lines 86 to 105, as shown in Figure 1.22:

   

   Figure 1.22: The comments for the Parse method with a string parameter

In the comments, you will see that Microsoft has documented the following:

• A summary that describes the method.
• Parameters like the string value that can be passed to the method.
• The return value of the method, including its data type.
• Three exceptions that might occur if you call this method, including ArgumentNullException, FormatException, and OverflowException. Now, we know that we could choose to wrap a call to this method in a try statement and which exceptions to catch.

Hopefully, you are getting impatient to learn what all this means!

Be patient for a little longer. You are almost at the end of this chapter, and in the next chapter, you will dive into the details of the C# language. But first, let's see where else you can look for help.

Stack Overflow is the most popular third-party website for getting answers to difficult programming questions. It's so popular that search engines such as DuckDuckGo have a special way to write a query to search the site:

1. Start your favorite web browser.
2. Navigate to DuckDuckGo.com, enter the following query, and note the search results, which are also shown in Figure 1.23:

    !so securestring
   

   

   Figure 1.23: Stack Overflow search results for securestring

You can search Google with advanced search options to increase the likelihood of finding what you need:

1. Navigate to Google.
2. Search for information about garbage collection using a simple Google query, and note that you will probably see a lot of ads for garbage collection services in your local area before you see the Wikipedia definition of garbage collection in computer science.
3. Improve the search by restricting it to a useful site such as Stack Overflow, and by removing languages that we might not care about, such as C++, Rust, and Python, or by adding C# and .NET explicitly, as shown in the following search query:

   garbage collection site:stackoverflow.com +C# -Java
   

To keep up to date with .NET, an excellent blog to subscribe to is the official .NET Blog, written by the .NET engineering teams, and you can find it at the following link: https://devblogs.microsoft.com/dotnet/.

Scott Hanselman from Microsoft has an excellent YouTube channel about computer stuff they didn't teach you: http://computerstufftheydidntteachyou.com/.

I recommend it to everyone working with computers.

Let's now test your knowledge and understanding by trying to answer some questions, getting some hands-on practice, and going into the topics covered throughout this chapter in greater detail.

Try to answer the following questions, remembering that although most answers can be found in this chapter, you should do some online research or code writing to answer others:

1. Is Visual Studio 2022 better than Visual Studio Code?
2. Is .NET 6 better than .NET Framework?
3. What is .NET Standard and why is it still important?
4. Why can a programmer use different languages, for example, C# and F#, to write applications that run on .NET?
5. What is the name of the entry point method of a .NET console application and how should it be declared?
6. What is a top-level program and how do you access any command-line arguments?
7. What do you type at the prompt to build and execute C# source code?
8. What are some benefits of using .NET Interactive Notebooks to write C# code?
9. Where would you look for help for a C# keyword?
10. Where would you look for solutions to common programming problems?

    Appendix, Answers to the Test Your Knowledge Questions, is available to download from a link in the README on the GitHub repository: https://github.com/markjprice/cs10dotnet6.

You don't need Visual Studio Code or even Visual Studio 2022 for Windows or Mac to write C#. You can go to .NET Fiddle – https://dotnetfiddle.net/ – and start coding online.

A book is a curated experience. I have tried to find the right balance of topics to include in the printed book. Other content that I have written can be found in the GitHub repository for this book.

I believe that this book covers all the fundamental knowledge and skills a C# and .NET developer should have or be aware of. Some longer examples are best included as links to Microsoft documentation or third-party article authors.

Use the links on the following page to learn more details about the topics covered in this chapter:

https://github.com/markjprice/cs10dotnet6/blob/main/book-links.md#chapter-1---hello-c-welcome-net

In this chapter, we:

• Set up your development environment.
• Discussed the similarities and differences between modern .NET, .NET Core, .NET Framework, Xamarin, and .NET Standard.
• Used Visual Studio Code with the .NET SDK and Visual Studio 2022 for Windows to create some simple console applications.
• Used .NET Interactive Notebooks to execute snippets of code for learning.
• Learned how to download the solution code for this book from a GitHub repository.
• And, most importantly, learned how to find help.

In the next chapter, you will learn how to "speak" C#.

This chapter is all about the basics of the C# programming language. Over the course of this chapter, you'll learn how to write statements using the grammar of C#, as well as being introduced to some of the common vocabulary that you will use every day. In addition to this, by the end of the chapter, you'll feel confident in knowing how to temporarily store and work with information in your computer's memory.

This chapter covers the following topics:

• Introducing the C# language
• Understanding C# grammar and vocabulary
• Working with variables
• Exploring more about console applications

This part of the book is about the C# language—the grammar and vocabulary that you will use every day to write the source code for your applications.

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!"

This part of the book covers the C# programming language and is written primarily for beginners, so it covers the fundamental topics that all developers need to know, from declaring variables to storing data to how to define your own custom data types.

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 was released in 2002 and included all the important features of a statically typed object-oriented modern language, as you will see throughout Chapters 2 to 6.

C# 2.0 was released in 2005 and focused on enabling strong data typing using generics, to improve code performance and reduce type errors, including the topics listed in the following table:

C# 3.0 was released in 2007 and focused on enabling declarative coding with Language INtegrated Queries (LINQ) and related features like anonymous types and lambda expressions, including the topics listed in the following table:

C# 4.0 was released in 2010 and focused on improving interoperability with dynamic languages like F# and Python, including the topics listed in the following table:

C# 5.0 was released in 2012 and focused on simplifying asynchronous operation support by automatically implementing complex state machines while writing what looks like synchronous statements, including the topics listed in the following table:

C# 6.0 was released in 2015 and focused on minor refinements to the language, including the topics listed in the following table:

C# 7.0 was released in March 2017 and focused on adding functional language features like tuples and pattern matching, as well as minor refinements to the language, including the topics listed in the following table:

C# 7.1 was released in August 2017 and focused on minor refinements to the language, including the topics listed in the following table:

C# 7.2 was released in November 2017 and focused on minor refinements to the language, including the topics listed in the following table:

C# 7.3 was released in May 2018 and focused on performance-oriented safe code that improves ref variables, pointers, and stackalloc. These are advanced and rarely needed for most developers, so they are not covered in this book.

C# 8 was released in September 2019 and focused on a major change to the language related to null handling, including the topics listed in the following table:

C# 9 was released in November 2020 and focused on record types, refinements to pattern matching, and minimal-code console apps, including the topics listed in the following table:

C# 10 was released in November 2021 and focused on features that minimize the amount of code needed in common scenarios, including the topics listed in the following table:

Over the years, Microsoft has submitted a few versions of C# to standards bodies, as shown in the following table:

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:

.NET language compilers for C# and Visual Basic, also known as Roslyn, along with a separate compiler for F#, are distributed as part of the .NET SDK. To use a specific version of C#, you must have at least that version of the .NET SDK installed, as shown in the following table:

When you create class libraries then you can choose to target .NET Standard as well as versions of modern .NET. They have default C# language versions, as shown in the following table:

Let's see what .NET SDK and C# language compiler versions you have available:

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
   

Developer tools like Visual Studio and the dotnet command-line interface assume that you want to use the latest major version of a C# language compiler by default. Before C# 8.0 was released, C# 7.0 was the latest major version and was used by default. To use the improvements in a C# point release like 7.1, 7.2, or 7.3, you had to add a <LangVersion> configuration element to the project file, as shown in the following markup:

<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:

After creating a new project, you can edit the .csproj file and add the <LangVersion> element, as shown highlighted in the following markup:

<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.

To learn simple C# language features, you can use .NET Interactive Notebooks, which remove the need to create an application of any kind.

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.

We will start by writing code that shows 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!.

3. Open the Program.cs file, and at the top of the file, under the comment, add a statement to show the C# version as an error, as shown in the following code:

   #error version
   

4. Run the console application:
   1. In Visual Studio Code, in a terminal, enter the command dotnet run.
   2. In Visual Studio, navigate to Debug | Start Without Debugging. When prompted to continue and run the last successful build, click No.
5. Note the compiler version and language version appear as a compiler error message number CS8304, as shown in Figure 2.1:

   

   Figure 2.1: A compiler error that shows the C# language version

6. The error message in the Visual Studio Code PROBLEMS window or Visual Studio Error List window says Compiler version: '4.0.0...' with language version 10.0.
7. Comment out the statement that causes the error, as shown in the following code:

   // #error version
   

8. Note that the compiler error messages disappear.

The grammar of C# includes statements and blocks. To document your code, you can use comments.

In English, we indicate the end of a sentence with a full stop. A sentence can be composed of multiple words and phrases, with the order of words being part of the grammar. For example, in English, we say "the black cat."

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.

C# indicates the end of a statement with a semicolon. A statement can be composed of multiple variables and expressions. For example, in the following statement, totalPrice is a variable and subtotal + salesTax is an expression:

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.

When writing your code, you're able to add comments to explain your code using a double slash, //. By inserting // the compiler will ignore everything after the // until the end of the line, as shown in the following code:

// 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.

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

Blocks start with a declaration to indicate what is being defined. For example, a block can define the start and end of many language constructs including namespaces, classes, methods, or statements like foreach.

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.

In the project template for console apps when targeting .NET 5.0, note that examples of the grammar of C# have been written for you by the project template. I've added some comments to the statements and blocks, as shown in the following code:

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

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

Some of the predefined, reserved keywords that you will see in this book include using, namespace, class, static, int, string, double, bool, if, switch, break, while, do, for, foreach, and, or, not, record, and init.

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.

The English language has more than 250,000 distinct words, so how does C# get away with only having about 100 keywords? Moreover, why is C# so difficult to learn if it has only 0.0416% of the number of words in the English language?

One of the key differences between a human language and a programming language is that developers need to be able to define the new "words" with new meanings. Apart from the about 100 keywords in the C# language, this book will teach you about some of the hundreds of thousands of "words" that other developers have defined, but you will also learn how to define your own "words."

Programmers all over the world must learn English because most programming languages use English words such as namespace and class. There are programming languages that use other human languages, such as Arabic, but they are rare. If you are interested in learning more, this YouTube video shows a demonstration of an Arabic programming language: https://youtu.be/dkO8cdwf6v8.

By default, Visual Studio Code and Visual Studio show C# keywords in blue to make them easier to differentiate from other code. Both tools allow you to customize the color scheme:

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.

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

Microsoft Word can help you write English by highlighting spelling mistakes with red squiggles, with Word saying that "icecream" should be ice-cream or ice cream, and grammatical errors with blue squiggles, such as a sentence should have an uppercase first letter.

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:

1. In Program.cs, change the L in the WriteLine method to lowercase.
2. Delete the semicolon at the end of the statement.
3. In Visual Studio Code, navigate to View | Problems, or in Visual Studio navigate to View | Error List, and note that a red squiggle appears under the code mistakes and details are shown, as you can see in Figure 2.2:

   

   Figure 2.2: The Error List window showing two compile errors

4. Fix the two coding errors.

System is a namespace, which is like an address for a type. To refer to someone's location exactly, you might use Oxford.HighStreet.BobSmith, which tells us to look for a person named Bob Smith on the High Street in the city of Oxford.

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.

Traditionally, every .cs file that needs to import namespaces would have to start with using statements to import those namespaces. Namespaces like System and System.Linq are needed in almost all .cs files, so the first few lines of every .cs file often had at least a few using statements, as shown in the following code:

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:

1. In Solution Explorer, select the Vocabulary project, toggle on the Show All Files button, and note the compiler-generated bin and obj folders are visible.
2. Expand the obj folder, expand the Debug folder, expand the net6.0 folder, and open the file named Vocabulary.GlobalUsings.g.cs.
3. Note this file is automatically created by the compiler for projects that target .NET 6.0, and that it imports some commonly used namespaces including System.Threading, as shown in the following code:

   // <autogenerated />
   global using global::System;
   global using global::System.Collections.Generic;
   global using global::System.IO;
   global using global::System.Linq;
   global using global::System.Net.Http;
   global using global::System.Threading;
   global using global::System.Threading.Tasks;
   

4. Close the Vocabulary.GlobalUsings.g.cs file.
5. In Solution Explorer, select the project, and then add additional entries to the project file to control which namespaces are implicitly imported, as shown highlighted in the following markup:

   <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <Nullable>enable</Nullable>
       <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
     <ItemGroup>
       <Using Remove="System.Threading" />
       <Using Include="System.Numerics" />
     </ItemGroup>
   </Project>
   

6. Save the changes to the project file.
7. Expand the obj folder, expand the Debug folder, expand the net6.0 folder, and open the file named Vocabulary.GlobalUsings.g.cs.
8. Note this file now imports System.Numerics instead of System.Threading, as shown highlighted in the following code:

   // <autogenerated />
   global using global::System;
   global using global::System.Collections.Generic;
   global using global::System.IO;
   global using global::System.Linq;
   global using global::System.Net.Http;
   global using global::System.Threading.Tasks;
   global using global::System.Numerics;
   

9. Close the Vocabulary.GlobalUsings.g.cs 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>

In English, verbs are doing or action words, like run and jump. In C#, doing or action words are called methods. There are 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'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.

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, and so in order for Fido to fetch a ball, we would use his name.

In C#, their equivalents are types, variables, fields, and properties. For example:

• 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.

It's worth taking 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, everything can be categorized as an animal, vegetable, or mineral. In C#, every type can be categorized as a class, struct, enum, interface, or delegate. You will learn what these mean in Chapter 6, Implementing Interfaces and Inheriting Classes. As examples, the C# keyword string is a class, but int is a struct. So, it is best to use the term type to refer to both.

We know that there are more than 100 keywords in C#, but how many types are there? Let's write some code to find out how many types (and their methods) are available to C# in our simple console application.

Don't worry exactly how this code works for now but know that it uses a technique called reflection:

1. We'll start by importing the System.Reflection namespace at the top of the Program.cs file, as shown in the following code:

   using System.Reflection;
   

2. Delete the statement that writes Hello World! and replace it with the following code:

   Assembly? assembly = Assembly.GetEntryAssembly();
   if (assembly == null) return;
   // loop through the assemblies that this app references
   foreach (AssemblyName name in assembly.GetReferencedAssemblies())
   {
     // load the assembly so we can read its details
     Assembly a = Assembly.Load(name);
     // declare a variable to count the number of methods
     int methodCount = 0;
     // loop through all the types in the assembly
     foreach (TypeInfo t in a.DefinedTypes)
     {
       // add up the counts of methods
       methodCount += t.GetMethods().Count();
     }
     // output the count of types and their methods
     Console.WriteLine(
       "{0:N0} types with {1:N0} methods in {2} assembly.",
       arg0: a.DefinedTypes.Count(),
       arg1: methodCount, arg2: name.Name);
   }
   

3. Run the code. You will see the actual number of types and methods that are available to you in the simplest application when running on your OS. The number of types and methods displayed will be different depending on the operating system that you are using, as shown in the following outputs:

   // Output on Windows
   0 types with 0 methods in System.Runtime assembly.
   106 types with 1,126 methods in System.Linq assembly.
   44 types with 645 methods in System.Console assembly.
   // Output on macOS
   0 types with 0 methods in System.Runtime assembly.
   103 types with 1,094 methods in System.Linq assembly.
   57 types with 701 methods in System.Console assembly.
   

   Why does the System.Runtime assembly contain zero types? This assembly is special because it contains only type-forwarders rather than actual types. A type-forwarder represents a type that has been implemented outside of .NET or for some other advanced reason.

4. Add statements to the top of the file after importing the namespace to declare some variables, as shown highlighted in the following code:

   using System.Reflection;
   // declare some unused variables using types
   // in additional assemblies
   System.Data.DataSet ds;
   HttpClient client;
   

   By declaring variables that use types in other assemblies, those assemblies are loaded with our application, which allows our code to see all the types and methods in them. The compiler will warn you that you have unused variables but that won't stop your code from running.

5. Run the console application again and view the results, which should look similar to the following outputs:

   // Output on Windows
   0 types with 0 methods in System.Runtime assembly.
   383 types with 6,854 methods in System.Data.Common assembly.
   456 types with 4,590 methods in System.Net.Http assembly.
   106 types with 1,126 methods in System.Linq assembly.
   44 types with 645 methods in System.Console assembly.
   // Output on macOS
   0 types with 0 methods in System.Runtime assembly.
   376 types with 6,763 methods in System.Data.Common assembly.
   522 types with 5,141 methods in System.Net.Http assembly.
   103 types with 1,094 methods in System.Linq assembly.
   57 types with 701 methods in System.Console assembly.
   

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!

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

Data usually comes into our program from files, databases, or user input, and it can be put temporarily into variables that will be stored in the memory of the running program. When the program ends, the data in memory is lost. Data is usually output to files and databases, or to the screen or a printer. When using variables, you should think about, firstly, how much space the variable takes in the memory, and, secondly, how fast it can be processed.

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.

There are naming conventions for things, and it is good practice to follow them, as shown in the following table:

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}.");

The message in double quotes in the preceding code wraps onto a second line because the width of a printed page is too narrow. When entering a statement like this in your code editor, type it all in a single line.

When you assign to a variable, you often, but not always, assign a literal value. But what is a literal value? A literal is a notation that represents a fixed value. Data types have different notations for their literal values, and over the next few sections, you will see examples of using literal notation to assign values to variables.

For text, a single letter, such as an A, is stored as a char type.

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);

When storing text in a string variable, you can include escape sequences, which represent special characters like tabs and new lines using a backslash, as shown in the following code:

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:

• Literal string: Characters enclosed in double-quote characters. They can use escape characters like \t for tab. To represent a backslash, use two: \\.
• Verbatim string: A literal string prefixed with @ to disable escape characters so that a backslash is a backslash. It also allows the string value to span multiple lines because the white space characters are treated as themselves instead of instructions to the compiler.
• Interpolated string: A literal string prefixed with $ to enable embedded formatted variables. You will learn more about this later in this chapter.

Numbers are data that we want to perform an arithmetic calculation on, for example, multiplying. A telephone number is not a number. To decide whether a variable should be stored as a number or not, ask yourself whether you need to perform arithmetic operations on the number or whether the number includes non-digit characters such as parentheses or hyphens to format the number, such as (414) 555-1234. In this case, the number is a sequence of characters, so it should be stored as a string.

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.

Let's explore numbers:

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
   

You might know that computers store everything as bits. The value of a bit is either 0 or 1. This is called a binary number system. Humans use a decimal number system.

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.

The following table shows how computers store the decimal number 10. Take note of the bits with the value 1 in the 8 and 2 columns; 8 + 2 = 10:

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.

You can insert underscores anywhere into the digits of a number literal, including decimal, binary, or hexadecimal notation, to improve legibility.

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

To use binary notation, that is, Base 2, using only 1s and 0s, start the number literal with 0b. To use hexadecimal notation, that is, Base 16, using 0 to 9 and A to F, start the number literal with 0x.

Let's enter some code to see some examples:

1. In Program.cs, type statements to declare some number variables using underscore separators, as shown in the following code:

   // three variables that store the number 2 million
   int decimalNotation = 2_000_000;
   int binaryNotation = 0b_0001_1110_1000_0100_1000_0000; 
   int hexadecimalNotation = 0x_001E_8480;
   // check the three variables have the same value
   // both statements output true 
   Console.WriteLine($"{decimalNotation == binaryNotation}"); 
   Console.WriteLine(
     $"{decimalNotation == hexadecimalNotation}");
   

2. Run the code and note the result is that all three numbers are the same, as shown in the following output:

   True
   True
   

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

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.

Most programming languages implement the IEEE Standard for Floating-Point Arithmetic. IEEE 754 is a technical standard for floating-point arithmetic established in 1985 by the Institute of Electrical and Electronics Engineers (IEEE).

The following table shows a simplification of how a computer represents the number 12.75 in binary notation. Note the bits with the value 1 in the 8, 4, ½, and ¼ columns.

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.

C# has an operator named sizeof() that returns the number of bytes that a type uses in memory. Some types have members named MinValue and MaxValue, which return the minimum and maximum values that can be stored in a variable of that type. We are now going to use these features to create a console application to explore number types:

1. In Program.cs, type statements to show the size of three number data types, as shown in the following code:

   Console.WriteLine($"int uses {sizeof(int)} bytes and can store numbers in the range {int.MinValue:N0} to {int.MaxValue:N0}."); 
   Console.WriteLine($"double uses {sizeof(double)} bytes and can store numbers in the range {double.MinValue:N0} to {double.MaxValue:N0}."); 
   Console.WriteLine($"decimal uses {sizeof(decimal)} bytes and can store numbers in the range {decimal.MinValue:N0} to {decimal.MaxValue:N0}.");
   

   The width of the printed pages in this book makes the string values (in double quotes) wrap over multiple lines. You must type them on a single line, or you will get compile errors.

2. Run the code and view the output, as shown in Figure 2.3:

   

   Figure 2.3: Size and range information for common number data types

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.

But you may be asking yourself, why might a double variable be able to store bigger numbers than a decimal variable, yet it's only using half the space in memory? Well, let's now find out!

You will now write some code to compare double and decimal values. Although it isn't hard to follow, don't worry about understanding the syntax right now:

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:

1. Copy and paste the statements that you wrote before (that used the double variables).
2. Modify the statements to use decimal and rename the variables to c and d, as shown in the following code:

   Console.WriteLine("Using decimals:");
   decimal c = 0.1M; // M suffix means a decimal literal value
   decimal d = 0.2M;
   if (c + d == 0.3M)
   {
     Console.WriteLine($"{c} + {d} equals {0.3M}");
   }
   else
   {
     Console.WriteLine($"{c} + {d} does NOT equal {0.3M}");
   }
   

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

   Using decimals:
   0.1 + 0.2 equals 0.3
   

The decimal type is accurate because it stores the number as a large integer and shifts the decimal point. For example, 0.1 is stored as 1, with a note to shift the decimal point one place to the left. 12.75 is stored as 1275, with a note to shift the decimal point two places to the left.

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.

Booleans can only contain one of the two literal values true or false, as shown in the following code:

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.

There is a special type named object that can store any type of data, but its flexibility comes at the cost of messier code and possibly poor performance. Because of those two reasons, you should avoid it whenever possible. The following steps show how to use object types if you need to use them:

1. Use your preferred code editor to add a new Console Application to the Chapter02 workspace/solution named Variables.
2. In Visual Studio Code, select Variables as the active OmniSharp project. When you see the pop-up warning message saying that required assets are missing, click Yes to add them.
3. In Program.cs, type statements to declare and use some variables using the object type, as shown in the following code:

   object height = 1.88; // storing a double in an object 
   object name = "Amir"; // storing a string in an object
   Console.WriteLine($"{name} is {height} metres tall.");
   int length1 = name.Length; // gives compile error!
   int length2 = ((string)name).Length; // tell compiler it is a string
   Console.WriteLine($"{name} has {length2} characters.");
   

4. Run the code and note that the fourth statement cannot compile because the data type of the name variable is not known by the compiler, as shown in Figure 2.4:

   

   Figure 2.4: The object type does not have a Length property

5. Add comment double slashes to the beginning of the statement that cannot compile to "comment out" the statement to make it inactive.
6. Run the code again and note that the compiler can access the length of a string if the programmer explicitly tells the compiler that the object variable contains a string by prefixing with a cast expression like (string), as shown in the following output:

   Amir is 1.88 metres tall. 
   Amir has 4 characters.
   

The object type has been available since the first version of C#, but C# 2.0 and later have a better alternative called generics, which we will cover in Chapter 6, Implementing Interfaces and Inheriting Classes, which will provide us with the flexibility we want, but without the performance overhead.

There is another special type named dynamic that can also store any type of data, but even more than object, its flexibility comes at the cost of performance. The dynamic keyword was introduced in C# 4.0. However, unlike object, the value stored in the variable can have its members invoked without an explicit cast. Let's make use of a dynamic type:

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
   

One limitation of dynamic is that code editors cannot show IntelliSense to help you write the code. This is because the compiler cannot check what the type is during build time. Instead, the CLR checks for the member at runtime and throws an exception if it is missing.

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.

Local variables are declared inside methods, and they only exist during the execution of that method, and once the method returns, the memory allocated to any local variables is released.

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.

Let's explore local variables declared with specific types and using type inference:

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
   

Depending on your code editor and color scheme, it will show green squiggles under each of the variable names and lighten their text color to warn you that the variable is assigned but its value is never used.

You can use the var keyword to declare local variables. The compiler will infer the type from the value that you assign after the assignment operator, =.

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:

1. Modify the previous statements to use var, as shown in the following code:

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

2. Hover your mouse over each of the var keywords and note that your code editor shows a tooltip with information about the type that has been inferred.
3. At the top of the class file, import the namespace for working with XML to enable us to declare some variables using types in that namespace, as shown in the following code:

   using System.Xml;
   

   Good Practice: If you are using .NET Interactive Notebooks, then add using statements in a separate code cell above the code cell where you write the main code. Then click Execute Cell to ensure the namespaces are imported. They will then be available in subsequent code cells.

4. Under the previous statements, add statements to create some new objects, as shown in the following code:

   // good use of var because it avoids the repeated type
   // as shown in the more verbose second statement
   var xml1 = new XmlDocument(); 
   XmlDocument xml2 = new XmlDocument();
   // bad use of var because we cannot tell the type, so we
   // should use a specific type declaration as shown in
   // the second statement
   var file1 = File.CreateText("something1.txt"); 
   StreamWriter file2 = File.CreateText("something2.txt");
   

   Good Practice: Although using var is convenient, some developers avoid using it, to make it easier for a code reader to understand the types in use. Personally, I use it only when the type is obvious. For example, in the preceding code statements, the first statement is just as clear as the second in stating what the type of the xml variables are, but it is shorter. However, the third statement isn't clear in showing the type of the file variable, so the fourth is better because it shows that the type is StreamWriter. If in doubt, spell it out!

With C# 9, Microsoft introduced another syntax for instantiating objects known as target-typed new. When instantiating an object, you can specify the type first and then use new without repeating the type, as shown in the following code:

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)

Most of the primitive types except string are value types, which means that they must have a value. You can determine the default value of a type by using the default() operator and passing the type as a parameter. You can assign the default value of a type by using the default keyword.

The string type is a reference type. This means that string variables contain the memory address of a value, not the value itself. A reference type variable can have a null value, which is a literal that indicates that the variable does not reference anything (yet). null is the default for all reference types.

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

Let's explore default values:

1. Add statements to show the default values of an int, bool, DateTime, and string, as shown in the following code:

   Console.WriteLine($"default(int) = {default(int)}"); 
   Console.WriteLine($"default(bool) = {default(bool)}"); 
   Console.WriteLine($"default(DateTime) = {default(DateTime)}"); 
   Console.WriteLine($"default(string) = {default(string)}");
   

2. Run the code and view the result, noting that your output for the date and time might be formatted differently if you are not running it in the UK, and that null values output as an empty string, as shown in the following output:

   default(int) = 0 
   default(bool) = False
   default(DateTime) = 01/01/0001 00:00:00 
   default(string) =
   

3. Add statements to declare a number, assign a value, and then reset it to its default value, as shown in the following code:

   int number = 13;
   Console.WriteLine($"number has been set to: {number}");
   number = default;
   Console.WriteLine($"number has been reset to its default: {number}");
   

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

   number has been set to: 13
   number has been reset to its default: 0
   

When you need to store multiple values of the same type, you can declare an array. For example, you may do this when you need to store four names in a string 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:

1. Type statements to declare and use an array of string values, as shown in the following code:

   string[] names; // can reference any size array of strings
   // allocating memory for four strings in an array
   names = new string[4];
   // storing items at index positions
   names[0] = "Kate";
   names[1] = "Jack"; 
   names[2] = "Rebecca"; 
   names[3] = "Tom";
   // looping through the names
   for (int i = 0; i < names.Length; i++)
   {
     // output the item at index position i
     Console.WriteLine(names[i]);
   }
   

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

   Kate 
   Jack 
   Rebecca 
   Tom
   

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.

Arrays are useful for temporarily storing multiple items, but collections are a more flexible option when adding and removing items dynamically. You don't need to worry about collections right now, as we will cover them in Chapter 8, Working with Common .NET Types.

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

Console applications are text-based and are run at the command line. They typically perform simple tasks that need to be scripted, such as compiling a file or encrypting a section of a configuration file.

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"

The two most common tasks that a console application performs are writing and reading data. We have already been using the WriteLine method to output, but if we didn't want a carriage return at the end of the lines, we could have used the Write method.

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

This feature is supported by methods like Write and WriteLine, and for methods that do not support the feature, the string parameter can be formatted using the Format method of string.

Let's begin formatting:

1. Use your preferred code editor to add a new Console Application to the Chapter02 workspace/solution named Formatting.
2. In Visual Studio Code, select Formatting as the active OmniSharp project.
3. In Program.cs, type statements to declare some number variables and write them to the console, as shown in the following code:

   int numberOfApples = 12; 
   decimal pricePerApple = 0.35M;
   Console.WriteLine(
     format: "{0} apples costs {1:C}", 
     arg0: numberOfApples,
     arg1: pricePerApple * numberOfApples);
   string formatted = string.Format(
     format: "{0} apples costs {1:C}",
     arg0: numberOfApples,
     arg1: pricePerApple * numberOfApples);
   //WriteToFile(formatted); // writes the string into a file
   

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

C# 6.0 and later have a handy feature named interpolated strings. A string prefixed with $ can use curly braces around the name of a variable or expression to output the current value of that variable or expression at that position in the string, as the following shows:

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.

Another reason to avoid interpolated strings is that they can't be read from resource files to be localized.

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.

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

An N0 format string means a number with a thousand separators and no decimal places, while a C format string means currency. The currency format will be determined by the current thread.

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.

For example, to output a table of fruit and how many of each there are, we might want to left-align the names within a column of 10 characters and right-align the counts formatted as numbers with zero decimal places within a column of six characters:

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
   

We can get text input from the user using the ReadLine method. This method waits for the user to type some text, then as soon as the user presses Enter, whatever the user has typed is returned as a string value.

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.
   

In C# 6.0 and later, the using statement can be used not only to import a namespace but also to further simplify our code by importing a static class. Then, we won't need to enter the Console type name throughout our code. You can use your code editor's find and replace feature to remove the times we have previously written 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.

We can get key input from the user using the ReadKey method. This method waits for the user to press a key or key combination that is then returned as a ConsoleKeyInfo value.

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
   

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

In every version of .NET prior to version 6.0, the console application project template made it obvious, as shown in the following code:

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:

1. Use your preferred code editor to add a new Console Application to the Chapter02 workspace/solution named Arguments. You will not be able to use a .NET Interactive notebook because you cannot pass arguments to a notebook.
2. In Visual Studio Code, select Arguments as the active OmniSharp project.
3. Add a statement to statically import the System.Console type and a statement to output the number of arguments passed to the application, as shown in the following code:

   using static System.Console;
   WriteLine($"There are {args.Length} arguments.");
   

   Good Practice: Remember to statically import the System.Console type in all future projects to simplify your code, as these instructions will not be repeated every time.

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

   There are 0 arguments.
   

5. If you are using Visual Studio, then navigate to Project | Arguments Properties, select the Debug tab, and in the Application arguments box, enter some arguments, save the changes, and then run the console application, as shown in Figure 2.6:

   

   Figure 2.6: Entering application arguments in Visual Studio project properties

6. If you are using Visual Studio Code, then in a terminal, enter some arguments after the dotnet run command, as shown in the following command line:

   dotnet run firstarg second-arg third:arg "fourth arg"
   

7. Note the result indicates four arguments, as shown in the following output:

   There are 4 arguments.
   

8. To enumerate or iterate (that is, loop through) the values of those four arguments, add the following statements after outputting the length of the array:

   foreach (string arg in args)
   {
     WriteLine(arg);
   }
   

9. Run the code again and note the result shows the details of the four arguments, as shown in the following output:

   There are 4 arguments. 
   firstarg
   second-arg 
   third:arg 
   fourth arg
   

We will now use these arguments to allow the user to pick a color for the background, foreground, and cursor size of the output window. The cursor size can be an integer value from 1, meaning a line at the bottom of the cursor cell, up to 100, meaning a percentage of the height of the cursor cell.

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

1. Add statements to warn the user if they do not enter three arguments and then parse those arguments and use them to set the color and dimensions of the console window, as shown in the following code:

   if (args.Length < 3)
   {
     WriteLine("You must specify two colors and cursor size, e.g.");
     WriteLine("dotnet run red yellow 50");
     return; // stop running
   }
   ForegroundColor = (ConsoleColor)Enum.Parse(
     enumType: typeof(ConsoleColor),
     value: args[0],
     ignoreCase: true);
   BackgroundColor = (ConsoleColor)Enum.Parse(
     enumType: typeof(ConsoleColor),
     value: args[1],
     ignoreCase: true);
   CursorSize = int.Parse(args[2]);
   

   Setting the CursorSize is only supported on Windows.

2. In Visual Studio, navigate to Project | Arguments Properties, and change the arguments to: red yellow 50, run the console app, and note the cursor is half the size and the colors have changed in the window, as shown in Figure 2.7:

   

   Figure 2.7: Setting colors and cursor size on Windows

3. In Visual Studio Code, run the code with arguments to set the foreground color to red, the background color to yellow, and the cursor size to 50%, as shown in the following command:

   dotnet run red yellow 50
   

   On macOS, you'll see an unhandled exception, as shown in Figure 2.8:

   

Figure 2.8: An unhandled exception on unsupported macOS

Although the compiler did not give an error or warning, at runtime some API calls may fail on some platforms. Although a console application running on Windows can change its cursor size, on macOS, it cannot, and complains if you try.

So how do we solve this problem? We can solve this by using an exception handler. You will learn more details about the try-catch statement in Chapter 3, Controlling Flow, Converting Types, and Handling Exceptions, so for now, just enter the code:

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.

Another way to handle differences in operating systems is to use the OperatingSystem class in the System namespace, as shown in the following code:

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:

You can then write statements that will compile only for the specified platforms, as shown in the following code:

#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

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.

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."

1. What statement can you type in a C# file to discover the compiler and language version?
2. What are the two types of comments in C#?
3. What is the difference between a verbatim string and an interpolated string?
4. Why should you be careful when using float and double values?
5. How can you determine how many bytes a type like double uses in memory?
6. When should you use the var keyword?
7. What is the newest way to create an instance of a class like XmlDocument?
8. Why should you be careful when using the dynamic type?
9. How do you right-align a format string?
10. What character separates arguments for a console application?

    Appendix, Answers to the Test Your Knowledge Questions is available to download from a link in the README on the GitHub repository: https://github.com/markjprice/cs10dotnet6.

What type would you choose for the following "numbers"?

1. A person's telephone number
2. A person's height
3. A person's age
4. A person's salary
5. A book's ISBN
6. A book's price
7. A book's shipping weight
8. A country's population
9. The number of stars in the universe
10. The number of employees in each of the small or medium businesses in the United Kingdom (up to about 50,000 employees per business)

In the Chapter02 solution/workspace, create a console application project named Exercise02 that outputs the number of bytes in memory that each of the following number types uses and the minimum and maximum values they can have: sbyte, byte, short, ushort, int, uint, long, ulong, float, double, and decimal.

The result of running your console application should look something like Figure 2.9:

Figure 2.9: The result of outputting number type sizes

Use the links on the following page to learn more detail about the topics covered in this chapter:

https://github.com/markjprice/cs10dotnet6/blob/main/book-links.md#chapter-2---speaking-c

In this chapter, you learned how to:

• Declare variables with a specified or an inferred type.
• Use some of the built-in types for numbers, text, and Booleans.
• Choose between number types.
• Control output formatting in console apps.

In the next chapter, you will learn about operators, branching, looping, converting between types, and how to handle exceptions.

This chapter is all about writing code that performs simple operations on variables, makes decisions, performs pattern matching, repeats statements or blocks, converts variable or expression values from one type to another, handles exceptions, and checks for overflows in number variables.

This chapter covers the following topics:

• Operating on variables
• Understanding selection statements
• Understanding iteration statements
• Casting and converting between types
• Handling exceptions
• Checking for overflow

Operators apply simple operations such as addition and multiplication to operands such as variables and literal values. They usually return a new value that is the result of the operation that can be assigned to a variable.

Most operators are binary, meaning that they work on two operands, as shown in the following pseudocode:

var resultOfOperation = firstOperand operator secondOperand;

Examples of binary operators include adding and multiplying, as shown in the following code:

int x = 5;
int y = 3;
int resultOfAdding = x + y;
int resultOfMultiplying = x * y;

Some operators are unary, meaning they work on a single operand, and can apply before or after the operand, as shown in the following pseudocode:

var resultOfOperation = onlyOperand operator; 
var resultOfOperation2 = operator onlyOperand;

Examples of unary operators include incrementors and retrieving a type or its size in bytes, as shown in the following code:

int x = 5;
int postfixIncrement = x++;
int prefixIncrement = ++x;
Type theTypeOfAnInteger = typeof(int); 
int howManyBytesInAnInteger = sizeof(int);

A ternary operator works on three operands, as shown in the following pseudocode:

var resultOfOperation = firstOperand firstOperator 
  secondOperand secondOperator thirdOperand;

Two common unary operators are used to increment, ++, and decrement, --, a number. Let us write some example code to show how they work:

1. If you've completed the previous chapters, then you will already have a Code folder. If not, then you'll need to create it.
2. Use your preferred coding tool to create a new console app, as defined in the following list:
   1. Project template: Console Application / console
   2. Workspace/solution file and folder: Chapter03
   3. Project file and folder: Operators
3. At the top of Program.cs, statically import System.Console.
4. In Program.cs, declare two integer variables named a and b, set a to 3, increment a while assigning the result to b, and then output their values, as shown in the following code:

   int a = 3; 
   int b = a++;
   WriteLine($"a is {a}, b is {b}");
   

5. Before running the console application, ask yourself a question: what do you think the value of b will be when output? Once you've thought about that, run the code, and compare your prediction against the actual result, as shown in the following output:

   a is 4, b is 3
   

   The variable b has the value 3 because the ++ operator executes after the assignment; this is known as a postfix operator. If you need to increment before the assignment, then use the prefix operator.

6. Copy and paste the statements, and then modify them to rename the variables and use the prefix operator, as shown in the following code:

   int c = 3;
   int d = ++c; // increment c before assigning it
   WriteLine($"c is {c}, d is {d}");
   

7. Rerun the code and note the result, as shown in the following output:

   a is 4, b is 3
   c is 4, d is 4
   

   Good Practice: Due to the confusion between prefix and postfix for the increment and decrement operators when combined with an assignment, the Swift programming language designers decided to drop support for this operator in version 3. My recommendation for usage in C# is to never combine the use of ++ and -- operators with an assignment operator, =. Perform the operations as separate statements.

Increment and decrement are unary arithmetic operators. Other arithmetic operators are usually binary and allow you to perform arithmetic operations on two numbers, as the following shows:

1. Add the statements to declare and assign values to two integer variables named e and f, and then apply the five common binary arithmetic operators to the two numbers, as shown in the following code:

   int e = 11; 
   int f = 3;
   WriteLine($"e is {e}, f is {f}"); 
   WriteLine($"e + f = {e + f}"); 
   WriteLine($"e - f = {e - f}"); 
   WriteLine($"e * f = {e * f}"); 
   WriteLine($"e / f = {e / f}"); 
   WriteLine($"e % f = {e % f}");
   

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

   e is 11, f is 3 
   e + f = 14
   e - f = 8 
   e * f = 33 
   e / f = 3 
   e % f = 2
   

   To understand the divide / and modulo % operators when applied to integers, you need to think back to primary school. Imagine you have eleven sweets and three friends.

   How can you divide the sweets between your friends? You can give three sweets to each of your friends, and there will be two left over. Those two sweets are the modulus, also known as the remainder after dividing. If you have twelve sweets, then each friend gets four of them, and there are none left over, so the remainder would be 0.

3. Add statements to declare and assign a value to a double variable named g to show the difference between whole number and real number divisions, as shown in the following code:

   double g = 11.0;
   WriteLine($"g is {g:N1}, f is {f}"); 
   WriteLine($"g / f = {g / f}");
   

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

   g is 11.0, f is 3
   g / f = 3.6666666666666665
   

If the first operand is a floating-point number, such as g with the value 11.0, then the divide operator returns a floating-point value, such as 3.6666666666665, rather than a whole number.

You have already been using the most common assignment operator, =.

To make your code more concise, you can combine the assignment operator with other operators like arithmetic operators, as shown in the following code:

int p = 6;
p += 3; // equivalent to p = p + 3;
p -= 3; // equivalent to p = p - 3;
p *= 3; // equivalent to p = p * 3;
p /= 3; // equivalent to p = p / 3;

Logical operators operate on Boolean values, so they return either true or false. Let's explore binary logical operators that operate on two Boolean values:

1. Use your preferred coding tool to add a new console app to the Chapter03 workspace/solution named BooleanOperators.
   1. In Visual Studio Code, select BooleanOperators 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 start up project for the solution to the current selection.

      Good Practice: Remember to statically import the System.Console type to simplify statements.

2. In Program.cs, add statements to declare two Boolean variables with values of true and false, and then output truth tables showing the results of applying AND, OR, and XOR (exclusive OR) logical operators, as shown in the following code:

   bool a = true;
   bool b = false;
   WriteLine($"AND  | a     | b    ");
   WriteLine($"a    | {a & a,-5} | {a & b,-5} ");
   WriteLine($"b    | {b & a,-5} | {b & b,-5} ");
   WriteLine();
   WriteLine($"OR   | a     | b    ");
   WriteLine($"a    | {a | a,-5} | {a | b,-5} ");
   WriteLine($"b    | {b | a,-5} | {b | b,-5} ");
   WriteLine();
   WriteLine($"XOR  | a     | b    ");
   WriteLine($"a    | {a ^ a,-5} | {a ^ b,-5} ");
   WriteLine($"b    | {b ^ a,-5} | {b ^ b,-5} ");
   

3. Run the code and note the results, as shown in the following output:

   AND  | a     | b    
   a    | True  | False 
   b    | False | False 
   OR   | a     | b    
   a    | True  | True  
   b    | True  | False 
   XOR  | a     | b    
   a    | False | True  
   b    | True  | False
   

For the AND & logical operator, both operands must be true for the result to be true. For the OR | logical operator, either operand can be true for the result to be true. For the XOR ^ logical operator, either operand can be true (but not both!) for the result to be true.

Conditional logical operators are like logical operators, but you use two symbols instead of one, for example, && instead of &, or || instead of |.

In Chapter 4, Writing, Debugging, and Testing Functions, you will learn about functions in more detail, but I need to introduce functions now to explain conditional logical operators, also known as short-circuiting Boolean operators.

A function executes statements and then returns a value. That value could be a Boolean value like true that is used in a Boolean operation. Let's make use of conditional logical operators:

1. At the bottom of Program.cs, write statements to declare a function that writes a message to the console and returns true, as shown in the following code:

   static bool DoStuff()
   {
     WriteLine("I am doing some stuff.");
     return true;
   }
   

   Good Practice: If you are using .NET Interactive Notebook, write the DoStuff function in a separate code cell and then execute it to make its context available to other code cells.

2. After the previous WriteLine statements, perform an AND & operation on the a and b variables and the result of calling the function, as shown in the following code:

   WriteLine();
   WriteLine($"a & DoStuff() = {a & DoStuff()}"); 
   WriteLine($"b & DoStuff() = {b & DoStuff()}");
   

3. Run the code, view the result, and note that the function was called twice, once for a and once for b, as shown in the following output:

   I am doing some stuff. 
   a & DoStuff() = True
   I am doing some stuff. 
   b & DoStuff() = False
   

4. Change the & operators into && operators, as shown in the following code:

   WriteLine($"a && DoStuff() = {a && DoStuff()}"); 
   WriteLine($"b && DoStuff() = {b && DoStuff()}");
   

5. Run the code, view the result, and note that the function does run when combined with the a variable. It does not run when combined with the b variable because the b variable is false so the result will be false anyway, so it does not need to execute the function, as shown in the following output:

   I am doing some stuff. 
   a && DoStuff() = True
   b && DoStuff() = False // DoStuff function was not executed!
   

   Good Practice: Now you can see why the conditional logical operators are described as being short-circuiting. They can make your apps more efficient, but they can also introduce subtle bugs in cases where you assume that the function would always be called. It is safest to avoid them when used in combination with functions that cause side effects.

Bitwise operators affect the bits in a number. Binary shift operators can perform some common arithmetic calculations much faster than traditional operators, for example, any multiplication by a factor of 2.

Let's explore bitwise and binary shift operators:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named BitwiseAndShiftOperators.
2. In Visual Studio Code, select BitwiseAndShiftOperators as the active OmniSharp project. When you see the pop-up warning message saying that required assets are missing, click Yes to add them.
3. In Program.cs, type statements to declare two integer variables with values 10 and 6, and then output the results of applying AND, OR, and XOR bitwise operators, as shown in the following code:

   int a = 10; // 00001010
   int b = 6;  // 00000110
   WriteLine($"a = {a}");
   WriteLine($"b = {b}");
   WriteLine($"a & b = {a & b}"); // 2-bit column only 
   WriteLine($"a | b = {a | b}"); // 8, 4, and 2-bit columns 
   WriteLine($"a ^ b = {a ^ b}"); // 8 and 4-bit columns
   

4. Run the code and note the results, as shown in the following output:

   a = 10
   b = 6
   a & b = 2 
   a | b = 14
   a ^ b = 12 
   

5. In Program.cs, add statements to output the results of applying the left-shift operator to move the bits of the variable a by three columns, multiplying a by 8, and right-shifting the bits of the variable b by one column, as shown in the following code:

   // 01010000 left-shift a by three bit columns
   WriteLine($"a << 3 = {a << 3}");
   // multiply a by 8
   WriteLine($"a * 8 = {a * 8}");
   // 00000011 right-shift b by one bit column
   WriteLine($"b >> 1 = {b >> 1}");
   

6. Run the code and note the results, as shown in the following output:

   a << 3 = 80
   a * 8 = 80
   b >> 1 = 3
   

The 80 result is because the bits in it were shifted three columns to the left, so the 1-bits moved into the 64- and 16-bit columns and 64 + 16 = 80. This is the equivalent of multiplying by 8, but CPUs can perform a bit-shift faster. The 3 result is because the 1-bits in b were shifted one column into the 2- and 1-bit columns.

We can illustrate the operations by converting the integer values into binary strings of zeros and ones:

1. At the bottom of Program.cs, add a function to convert an integer value into a binary (Base2) string of up to eight zeros and ones, as shown in the following code:

   static string ToBinaryString(int value)
   {
     return Convert.ToString(value, toBase: 2).PadLeft(8, '0');
   }
   

2. Above the function, add statements to output a, b, and the results of the various bitwise operators, as shown in the following code:

   WriteLine();
   WriteLine("Outputting integers as binary:");
   WriteLine($"a =     {ToBinaryString(a)}");
   WriteLine($"b =     {ToBinaryString(b)}");
   WriteLine($"a & b = {ToBinaryString(a & b)}");
   WriteLine($"a | b = {ToBinaryString(a | b)}");
   WriteLine($"a ^ b = {ToBinaryString(a ^ b)}");
   

3. Run the code and note the results, as shown in the following output:

   Outputting integers as binary:
   a =     00001010
   b =     00000110
   a & b = 00000010
   a | b = 00001110
   a ^ b = 00001100
   

nameof and sizeof are convenient operators when working with types:

• nameof returns the short name (without the namespace) of a variable, type, or member as a string value, which is useful when outputting exception messages.
• sizeof returns the size in bytes of simple types, which is useful for determining the efficiency of data storage.

There are many other operators; for example, the dot between a variable and its members is called the member access operator and the round brackets at the end of a function or method name are called the invocation operator, as shown in the following code:

int age = 47;
// How many operators in the following statement?
char firstDigit = age.ToString()[0];
// There are four operators:
// = is the assignment operator
// . is the member access operator
// () is the invocation operator
// [] is the indexer access operator

Every application needs to be able to select from choices and branch along different code paths. The two selection statements in C# are if and switch. You can use if for all your code, but switch can simplify your code in some common scenarios such as when there is a single variable that can have multiple values that each require different processing.

The if statement determines which branch to follow by evaluating a Boolean expression. If the expression is true, then the block executes. The else block is optional, and it executes if the if expression is false. The if statement can be nested.

The if statement can be combined with other if statements as else if branches, as shown in the following code:

if (expression1)
{
  // runs if expression1 is true
}
else if (expression2)
{
  // runs if expression1 is false and expression2 if true
}
else if (expression3)
{
  // runs if expression1 and expression2 are false
  // and expression3 is true
}
else
{
  // runs if all expressions are false
}

Each if statement's Boolean expression is independent of the others and, unlike switch statements, does not need to reference a single value.

Let's write some code to explore selection statements like if:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named SelectionStatements.
2. In Visual Studio Code, select SelectionStatements as the active OmniSharp project.
3. In Program.cs, type statements to check if a password is at least eight characters, as shown in the following code:

   string password = "ninja";
   if (password.Length < 8)
   {
     WriteLine("Your password is too short. Use at least 8 characters.");
   }
   else
   {
     WriteLine("Your password is strong.");
   }
   

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

    Your password is too short. Use at least 8 characters.
   

As there is only a single statement inside each block, the preceding code could be written without the curly braces, as shown in the following code:

if (password.Length < 8)
  WriteLine("Your password is too short. Use at least 8 characters."); 
else
  WriteLine("Your password is strong.");

This style of if statement should be avoided because it can introduce serious bugs, for example, the infamous #gotofail bug in Apple's iPhone iOS operating system.

For 18 months after Apple's iOS 6 was released, in September 2012, it had a bug in its Secure Sockets Layer (SSL) encryption code, which meant that any user running Safari, the device's web browser, who tried to connect to secure websites, such as their bank, was not properly secure because an important check was being accidentally skipped.

Just because you can leave out the curly braces doesn't mean you should. Your code is not "more efficient" without them; instead, it is less maintainable and potentially more dangerous.

A feature introduced with C# 7.0 and later is pattern matching. The if statement can use the is keyword in combination with declaring a local variable to make your code safer:

1. Add statements so that if the value stored in the variable named o is an int, then the value is assigned to the local variable named i, which can then be used inside the if statement. This is safer than using the variable named o because we know for sure that i is an int variable and not something else, as shown in the following code:

   // add and remove the "" to change the behavior
   object o = "3"; 
   int j = 4;
   if (o is int i)
   {
     WriteLine($"{i} x {j} = {i * j}");
   }
   else
   {
     WriteLine("o is not an int so it cannot multiply!");
   }
   

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

   o is not an int so it cannot multiply!
   

3. Delete the double-quote characters around the "3" value so that the value stored in the variable named o is an int type instead of a string type.
4. Rerun the code to view the results, as shown in the following output:

   3 x 4 = 12
   

The switch statement is different from the if statement because switch compares a single expression against a list of multiple possible case statements. Every case statement is related to the single expression. Every case section must end with:

• The break keyword (like case 1 in the following code)
• Or the goto case keywords (like case 2 in the following code)
• Or they should have no statements (like case 3 in the following code)
• Or the goto keyword that references a named label (like case 5 in the following code)
• Or the return keyword to leave the current function (not shown in the code)

Let's write some code to explore the switch statements:

1. Type statements for a switch statement. You should note that the penultimate statement is a label that can be jumped to, and the first statement generates a random number between 1 and 6 (the number 7 in the code is an exclusive upper bound). The switch statement branches are based on the value of this random number, as shown in the following code:

   int number = (new Random()).Next(1, 7); 
   WriteLine($"My random number is {number}");
   switch (number)
   {
     case 1: 
       WriteLine("One");
       break; // jumps to end of switch statement
     case 2:
       WriteLine("Two");
       goto case 1;
     case 3: // multiple case section
     case 4:
       WriteLine("Three or four");
       goto case 1;
     case 5:
       goto A_label;
     default:
       WriteLine("Default");
       break;
   } // end of switch statement
   WriteLine("After end of switch");
   A_label:
   WriteLine($"After A_label");
   

   Good Practice: You can use the goto keyword to jump to another case or a label. The goto keyword is frowned upon by most programmers but can be a good solution to code logic in some scenarios. However, you should use it sparingly.

2. Run the code multiple times to see what happens in various cases of random numbers, as shown in the following example output:

   // first random run
   My random number is 4 
   Three or four
   One
   After end of switch
   After A_label
   // second random run
   My random number is 2 
   Two
   One
   After end of switch
   After A_label
   // third random run
   My random number is 6
   Default
   After end of switch
   After A_label
   // fourth random run
   My random number is 1 
   One
   After end of switch
   After A_label
   // fifth random run
   My random number is 5
   After A_label
   

Like the if statement, the switch statement supports pattern matching in C# 7.0 and later. The case values no longer need to be literal values; they can be patterns.

Let's see an example of pattern matching with the switch statement using a folder path. If you are using macOS, then swap the commented statement that sets the path variable and replace my username with your user folder name:

1. Add statements to declare a string path to a file, open it as either a read-only or writeable stream, and then show a message based on what type and capabilities the stream has, as shown in the following code:

   // string path = "/Users/markjprice/Code/Chapter03";
   string path = @"C:\Code\Chapter03";
   Write("Press R for read-only or W for writeable: "); 
   ConsoleKeyInfo key = ReadKey();
   WriteLine();
   Stream? s;
   if (key.Key == ConsoleKey.R)
   {
     s =  File.Open(
       Path.Combine(path, "file.txt"), 
       FileMode.OpenOrCreate, 
       FileAccess.Read);
   }
   else
   {
     s =  File.Open( 
       Path.Combine(path, "file.txt"), 
       FileMode.OpenOrCreate, 
       FileAccess.Write);
   }
   string message; 
   switch (s)
   {
     case FileStream writeableFile when s.CanWrite:
       message = "The stream is a file that I can write to.";
       break;
     case FileStream readOnlyFile:
       message = "The stream is a read-only file.";
       break;
     case MemoryStream ms:
       message = "The stream is a memory address.";
       break;
     default: // always evaluated last despite its current position
       message = "The stream is some other type.";
       break;
     case null:
       message = "The stream is null.";
       break;
   }
   WriteLine(message); 
   

2. Run the code and note that the variable named s is declared as a Stream type so it could be any subtype of stream, such as a memory stream or file stream. In this code, the stream is created using the File.Open method, which returns a file stream and, depending on your key press, it will be writeable or read-only, so the result will be a message that describes the situation, as shown in the following output:

   The stream is a file that I can write to.
   

In .NET, there are multiple subtypes of Stream, including FileStream and MemoryStream. In C# 7.0 and later, your code can more concisely branch, based on the subtype of stream, and declare and assign a local variable to safely use it. You will learn more about the System.IO namespace and the Stream type in Chapter 9, Working with Files, Streams, and Serialization.

Additionally, case statements can include a when keyword to perform more specific pattern matching. In the first case statement in the preceding code, s will only be a match if the stream is a FileStream and its CanWrite property is true.

In C# 8.0 or later, you can simplify switch statements using switch expressions.

Most switch statements are very simple, yet they require a lot of typing. switch expressions are designed to simplify the code you need to type while still expressing the same intent in scenarios where all cases return a value to set a single variable. switch expressions use a lambda, =>, to indicate a return value.

Let's implement the previous code that used a switch statement using a switch expression so that you can compare the two styles:

1. Type statements to set the message based on what type and capabilities the stream has, using a switch expression, as shown in the following code:

   message = s switch
   {
     FileStream writeableFile when s.CanWrite
       => "The stream is a file that I can write to.", 
     FileStream readOnlyFile
       => "The stream is a read-only file.", 
     MemoryStream ms
       => "The stream is a memory address.", 
     null
       => "The stream is null.",
     _
       => "The stream is some other type."
   };
   WriteLine(message);
   

   The main differences are the removal of the case and break keywords. The underscore character _ is used to represent the default return value.

2. Run the code, and note the result is the same as before.

Iteration statements repeat a block of statements either while a condition is true or for each item in a collection. The choice of which statement to use is based on a combination of ease of understanding to solve the logic problem and personal preference.

The while statement evaluates a Boolean expression and continues to loop while it is true. Let's explore iteration statements:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named IterationStatements.
2. In Visual Studio Code, select IterationStatements as the active OmniSharp project.
3. In Program.cs, type statements to define a while statement that loops while an integer variable has a value less than 10, as shown in the following code:

   int x = 0;
   while (x < 10)
   {
     WriteLine(x);
     x++;
   }
   

4. Run the code and view the results, which should be the numbers 0 to 9, as shown in the following output:

   0
   1
   2
   3
   4
   5
   6
   7
   8
   9
   

The do statement is like while, except the Boolean expression is checked at the bottom of the block instead of the top, which means that the block always executes at least once, as the following shows:

1. Type statements to define a do loop, as shown in the following code:

   string? password;
   do
   {
     Write("Enter your password: "); 
     password = ReadLine();
   }
   while (password != "Pa$$w0rd");
   WriteLine("Correct!");
   

2. Run the code, and note that you are prompted to enter your password repeatedly until you enter it correctly, as shown in the following output:

   Enter your password: password 
   Enter your password: 12345678 
   Enter your password: ninja
   Enter your password: correct horse battery staple 
   Enter your password: Pa$$w0rd
   Correct!
   

3. As an optional challenge, add statements so that the user can only make ten attempts before an error message is displayed.

The for statement is like while, except that it is more succinct. It combines:

• An initializer expression, which executes once at the start of the loop.
• A conditional expression, which executes on every iteration at the start of the loop to check whether the looping should continue.
• An iterator expression, which executes on every loop at the bottom of the statement.

The for statement is commonly used with an integer counter. Let's explore some code:

1. Type a for statement to output the numbers 1 to 10, as shown in the following code:

   for (int y = 1; y <= 10; y++)
   {
     WriteLine(y);
   }
   

2. Run the code to view the result, which should be the numbers 1 to 10.

The foreach statement is a bit different from the previous three iteration statements.

It is used to perform a block of statements on each item in a sequence, for example, an array or collection. Each item is usually read-only, and if the sequence structure is modified during iteration, for example, by adding or removing an item, then an exception will be thrown.

Try the following example:

1. Type statements to create an array of string variables and then output the length of each one, as shown in the following code:

   string[] names = { "Adam", "Barry", "Charlie" };
   foreach (string name in names)
   {
     WriteLine($"{name} has {name.Length} characters.");
   }
   

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

   Adam has 4 characters. 
   Barry has 5 characters. 
   Charlie has 7 characters. 
   

A creator of any type that represents multiple items, like an array or collection, should make sure that a programmer can use the foreach statement to enumerate through the type's items.

Technically, the foreach statement will work on any type that follows these rules:

1. The type must have a method named GetEnumerator that returns an object.
2. The returned object must have a property named Current and a method named MoveNext.
3. The MoveNext method must change the value of Current and return true if there are more items to enumerate through or return false if there are no more items.

There are interfaces named IEnumerable and IEnumerable<T> that formally define these rules, but technically the compiler does not require the type to implement these interfaces.

The compiler turns the foreach statement in the preceding example into something like the following pseudocode:

IEnumerator e = names.GetEnumerator();
while (e.MoveNext())
{
  string name = (string)e.Current; // Current is read-only!
  WriteLine($"{name} has {name.Length} characters.");
}

Due to the use of an iterator, the variable declared in a foreach statement cannot be used to modify the value of the current item.

You will often need to convert values of variables between different types. For example, data input is often entered as text at the console, so it is initially stored in a variable of the string type, but it then needs to be converted into a date/time, or number, or some other data type, depending on how it should be stored and processed.

Sometimes you will need to convert between number types, like between an integer and a floating point, before performing calculations.

Converting is also known as casting, and it has two varieties: implicit and explicit. Implicit casting happens automatically, and it is safe, meaning that you will not lose any information.

Explicit casting must be performed manually because it may lose information, for example, the precision of a number. By explicitly casting, you are telling the C# compiler that you understand and accept the risk.

Implicitly casting an int variable into a double variable is safe because no information can be lost as the following shows:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named CastingConverting.
2. In Visual Studio Code, select CastingConverting as the active OmniSharp project.
3. In Program.cs, type statements to declare and assign an int variable and a double variable, and then implicitly cast the integer's value when assigning it to the double variable, as shown in the following code:

   int a = 10;
   double b = a; // an int can be safely cast into a double
   WriteLine(b);
   

4. Type statements to declare and assign a double variable and an int variable, and then implicitly cast the double value when assigning it to the int variable, as shown in the following code:

   double c = 9.8;
   int d = c; // compiler gives an error for this line
   WriteLine(d);
   

5. Run the code and note the error message, as shown in the following output:

   Error: (6,9): error CS0266: Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?)
   

   This error message will also appear in the Visual Studio Error List or Visual Studio Code PROBLEMS window.

   You cannot implicitly cast a double variable into an int variable because it is potentially unsafe and could lose data, like the value after the decimal point. You must explicitly cast a double variable into an int variable using a pair of round brackets around the type you want to cast the double type into. The pair of round brackets is the cast operator. Even then, you must beware that the part after the decimal point will be trimmed off without warning because you have chosen to perform an explicit cast and therefore understand the consequences.

6. Modify the assignment statement for the d variable, as shown in the following code:

   int d = (int)c;
   WriteLine(d); // d is 9 losing the .8 part
   

7. Run the code to view the results, as shown in the following output:

   10
   9
   

   We must perform a similar operation when converting values between larger integers and smaller integers. Again, beware that you might lose information because any value too big will have its bits copied and then be interpreted in ways that you might not expect!

8. Enter statements to declare and assign a long 64-bit variable to an int 32-bit variable, both using a small value that will work and a too-large value that will not, as shown in the following code:

   long e = 10; 
   int f = (int)e;
   WriteLine($"e is {e:N0} and f is {f:N0}"); 
   e = long.MaxValue;
   f = (int)e;
   WriteLine($"e is {e:N0} and f is {f:N0}");
   

9. Run the code to view the results, as shown in the following output:

   e is 10 and f is 10
   e is 9,223,372,036,854,775,807 and f is -1
   

10. Modify the value of e to 5 billion, as shown in the following code:

    e = 5_000_000_000;
    

11. Run the code to view the results, as shown in the following output:

    e is 5,000,000,000 and f is 705,032,704
    

An alternative to using the cast operator is to use the System.Convert type. The System.Convert type can convert to and from all the C# number types, as well as Booleans, strings, and date and time values.

Let's write some code to see this in action:

1. At the top of Program.cs, statically import the System.Convert class, as shown in the following code:

   using static System.Convert;
   

2. At the bottom of Program.cs, type statements to declare and assign a value to a double variable, convert it to an integer, and then write both values to the console, as shown in the following code:

   double g = 9.8;
   int h = ToInt32(g); // a method of System.Convert
   WriteLine($"g is {g} and h is {h}");
   

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

   g is 9.8 and h is 10
   

One difference between casting and converting is that converting rounds the double value 9.8 up to 10 instead of trimming the part after the decimal point.

You have now seen that the cast operator trims the decimal part of a real number and that the System.Convert methods round up or down. However, what is the rule for rounding?

In British primary schools for children aged 5 to 11, pupils are taught to round up if the decimal part is .5 or higher and round down if the decimal part is less.

Let's explore if C# follows the same primary school rule:

1. Type statements to declare and assign an array of double values, convert each of them to an integer, and then write the result to the console, as shown in the following code:

   double[] doubles = new[]
     { 9.49, 9.5, 9.51, 10.49, 10.5, 10.51 };
   foreach (double n in doubles)
   {
     WriteLine($"ToInt32({n}) is {ToInt32(n)}");
   }
   

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

   ToInt32(9.49) is 9
   ToInt32(9.5) is 10
   ToInt32(9.51) is 10
   ToInt32(10.49) is 10
   ToInt32(10.5) is 10
   ToInt32(10.51) is 11
   

We have shown that the rule for rounding in C# is subtly different from the primary school rule:

• It always rounds down if the decimal part is less than the midpoint .5.
• It always rounds up if the decimal part is more than the midpoint .5.
• It will round up if the decimal part is the midpoint .5 and the non-decimal part is odd, but it will round down if the non-decimal part is even.

This rule is known as Banker's Rounding, and it is preferred because it reduces bias by alternating when it rounds up or down. Sadly, other languages such as JavaScript use the primary school rule.

You can take control of the rounding rules by using the Round method of the Math class:

1. Type statements to round each of the double values using the "away from zero" rounding rule, also known as rounding "up," and then write the result to the console, as shown in the following code:

   foreach (double n in doubles)
   {
     WriteLine(format:
       "Math.Round({0}, 0, MidpointRounding.AwayFromZero) is {1}",
       arg0: n,
       arg1: Math.Round(value: n, digits: 0,
               mode: MidpointRounding.AwayFromZero));
   }
   

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

   Math.Round(9.49, 0, MidpointRounding.AwayFromZero) is 9
   Math.Round(9.5, 0, MidpointRounding.AwayFromZero) is 10
   Math.Round(9.51, 0, MidpointRounding.AwayFromZero) is 10
   Math.Round(10.49, 0, MidpointRounding.AwayFromZero) is 10
   Math.Round(10.5, 0, MidpointRounding.AwayFromZero) is 11
   Math.Round(10.51, 0, MidpointRounding.AwayFromZero) is 11
   

   Good Practice: For every programming language that you use, check its rounding rules. They may not work the way you expect!

The most common conversion is from any type into a string variable for outputting as human-readable text, so all types have a method named ToString that they inherit from the System.Object class.

The ToString method converts the current value of any variable into a textual representation. Some types can't be sensibly represented as text, so they return their namespace and type name instead.

Let's convert some types into a string:

1. Type statements to declare some variables, convert them to their string representation, and write them to the console, as shown in the following code:

   int number = 12; 
   WriteLine(number.ToString());
   bool boolean = true; 
   WriteLine(boolean.ToString());
   DateTime now = DateTime.Now; 
   WriteLine(now.ToString());
   object me = new(); 
   WriteLine(me.ToString());
   

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

   12
   True
   02/28/2021 17:33:54
   System.Object
   

When you have a binary object like an image or video that you want to either store or transmit, you sometimes do not want to send the raw bits because you do not know how those bits could be misinterpreted, for example, by the network protocol transmitting them or another operating system that is reading the store binary object.

The safest thing to do is to convert the binary object into a string of safe characters. Programmers call this Base64 encoding.

The Convert type has a pair of methods, ToBase64String and FromBase64String, that perform this conversion for you. Let's see them in action:

1. Type statements to create an array of bytes randomly populated with byte values, write each byte nicely formatted to the console, and then write the same bytes converted to Base64 to the console, as shown in the following code:

   // allocate array of 128 bytes
   byte[] binaryObject = new byte[128];
   // populate array with random bytes
   (new Random()).NextBytes(binaryObject); 
   WriteLine("Binary Object as bytes:");
   for(int index = 0; index < binaryObject.Length; index++)
   {
     Write($"{binaryObject[index]:X} ");
   }
   WriteLine();
   // convert to Base64 string and output as text
   string encoded = ToBase64String(binaryObject);
   WriteLine($"Binary Object as Base64: {encoded}");
   

   By default, an int value would output assuming decimal notation, that is, base10. You can use format codes such as :X to format the value using hexadecimal notation.

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

   Binary Object as bytes:
   B3 4D 55 DE 2D E BB CF BE 4D E6 53 C3 C2 9B 67 3 45 F9 E5 20 61 7E 4F 7A 81 EC 49 F0 49 1D 8E D4 F7 DB 54 AF A0 81 5 B8 BE CE F8 36 90 7A D4 36 42
   4 75 81 1B AB 51 CE 5 63 AC 22 72 DE 74 2F 57 7F CB E7 47 B7 62 C3 F4 2D
   61 93 85 18 EA 6 17 12 AE 44 A8 D B8 4C 89 85 A9 3C D5 E2 46 E0 59 C9 DF
   10 AF ED EF 8AA1 B1 8D EE 4A BE 48 EC 79 A5 A 5F 2F 30 87 4A C7 7F 5D C1 D
   26 EE
   Binary Object as Base64: s01V3i0Ou8++TeZTw8KbZwNF +eUgYX5PeoHsSfBJHY7U99tU r6CBBbi+zvg2kHrUNkIEdYEbq1HOBWOsInLedC9Xf8vnR7diw/QtYZOFGOoGFxKuRKgNuEyJha k81eJG4FnJ3xCv7e+KobGN7kq+SO x5pQpfLzCHSsd/XcENJu4=
   

The second most common conversion is from strings to numbers or date and time values.

The opposite of ToString is Parse. Only a few types have a Parse method, including all the number types and DateTime.

Let's see Parse in action:

1. Type statements to parse an integer and a date and time value from strings and then write the result to the console, as shown in the following code:

   int age = int.Parse("27");
   DateTime birthday = DateTime.Parse("4 July 1980");
   WriteLine($"I was born {age} years ago."); 
   WriteLine($"My birthday is {birthday}."); 
   WriteLine($"My birthday is {birthday:D}.");
   

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

   I was born 27 years ago.
   My birthday is 04/07/1980 00:00:00. 
   My birthday is 04 July 1980.
   

   By default, a date and time value outputs with the short date and time format. You can use format codes such as D to output only the date part using the long date format.

   Good Practice: Use the standard date and time format specifiers, as shown at the following link: https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings#table-of-format-specifiers

One problem with the Parse method is that it gives errors if the string cannot be converted.

1. Type a statement to attempt to parse a string containing letters into an integer variable, as shown in the following code:

   int count = int.Parse("abc");
   

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

   Unhandled Exception: System.FormatException: Input string was not in a correct format.
   

As well as the preceding exception message, you will see a stack trace. I have not included stack traces in this book because they take up too much space.

To avoid errors, you can use the TryParse method instead. TryParse attempts to convert the input string and returns true if it can convert it and false if it cannot.

The out keyword is required to allow the TryParse method to set the count variable when the conversion works.

Let's see TryParse in action:

1. Replace the int count declaration with statements to use the TryParse method and ask the user to input a count for a number of eggs, as shown in the following code:

   Write("How many eggs are there? "); 
   string? input = ReadLine(); // or use "12" in notebook
   if (int.TryParse(input, out int count))
   {
     WriteLine($"There are {count} eggs.");
   }
   else
   {
     WriteLine("I could not parse the input.");
   }
   

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

   How many eggs are there? 12
   There are 12 eggs.
   

3. Run the code, enter twelve (or change the string value to "twelve" in a notebook), and view the result, as shown in the following output:

   How many eggs are there? twelve
   I could not parse the input.
   

You can also use methods of the System.Convert type to convert string values into other types; however, like the Parse method, it gives an error if it cannot convert.

You've seen several scenarios where errors have occurred when converting types. Some languages return error codes when something goes wrong. .NET uses exceptions that are richer and designed only for failure reporting compared to return values that have multiple uses. When this happens, we say a runtime exception has been thrown.

When an exception is thrown, the thread is suspended and if the calling code has defined a try-catch statement, then it is given a chance to handle the exception. If the current method does not handle it, then its calling method is given a chance, and so on up the call stack.

As you have seen, the default behavior of a console application or a .NET Interactive notebook is to output a message about the exception, including a stack trace, and then stop running the code. The application is terminated. This is better than allowing the code to continue executing in a potentially corrupt state. Your code should only catch and handle exceptions that it understands and can properly fix.

When you know that a statement can cause an error, you should wrap that statement in a try block. For example, parsing from text to a number can cause an error. Any statements in the catch block will be executed only if an exception is thrown by a statement in the try block.

We don't have to do anything inside the catch block. Let's see this in action:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named HandlingExceptions.
2. In Visual Studio Code, select HandlingExceptions as the active OmniSharp project.
3. Type statements to prompt the user to enter their age and then write their age to the console, as shown in the following code:

   WriteLine("Before parsing"); 
   Write("What is your age? "); 
   string? input = ReadLine(); // or use "49" in a notebook
   try
   {
     int age = int.Parse(input); 
     WriteLine($"You are {age} years old.");
   }
   catch
   {
   }
   WriteLine("After parsing");
   

   You will see the following compiler message: Warning CS8604 Possible null reference argument for parameter 's' in 'int int.Parse(string s)'. By default in new .NET 6 projects, Microsoft has enabled nullable reference types so you will see many more compiler warnings like this. In production code, you should add code to check for null and handle that possibility appropriately. In this book, I will not include these null checks because the code samples are not designed to be production quality and null checks everywhere will clutter the code and use up valuable pages. In this case, it is impossible for input to be null because the user must press Enter for ReadLine to return and that will return an empty string. You will see hundreds of more examples of potentially null variables throughout the code samples in this book. Those warnings are safe to ignore for the book code examples. You only need similar warnings when you write your own production code. You will see more about null handling in Chapter 6, Implementing Interfaces and Inheriting Classes.

   This code includes two messages to indicate before parsing and after parsing to make clearer the flow through the code. These will be especially useful as the example code grows more complex.

4. Run the code, enter 49, and view the result, as shown in the following output:

   Before parsing
   What is your age? 49
   You are 49 years old. 
   After parsing
   

5. Run the code, enter Kermit, and view the result, as shown in the following output:

   Before parsing
   What is your age? Kermit
   After parsing
   

When the code was executed, the error exception was caught and the default message and stack trace were not output, and the console application continued running. This is better than the default behavior, but it might be useful to see the type of error that occurred.

To get information about any type of exception that might occur, you can declare a variable of type System.Exception to the catch block:

1. Add an exception variable declaration to the catch block and use it to write information about the exception to the console, as shown in the following code:

   catch (Exception ex)
   {
     WriteLine($"{ex.GetType()} says {ex.Message}");
   }
   

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

   Before parsing
   What is your age? Kermit
   System.FormatException says Input string was not in a correct format. 
   After parsing
   

Now that we know which specific type of exception occurred, we can improve our code by catching just that type of exception and customizing the message that we display to the user:

1. Leave the existing catch block, and above it, add a new catch block for the format exception type, as shown in the following highlighted code:

   catch (FormatException)
   {
     WriteLine("The age you entered is not a valid number format.");
   }
   catch (Exception ex)
   {
     WriteLine($"{ex.GetType()} says {ex.Message}");
   }
   

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

   Before parsing
   What is your age? Kermit
   The age you entered is not a valid number format. 
   After parsing
   

   The reason we want to leave the more general catch below is that there might be other types of exceptions that can occur.

3. Run the code, enter 9876543210, and view the result, as shown in the following output:

   Before parsing
   What is your age? 9876543210
   System.OverflowException says Value was either too large or too small for an Int32.
   After parsing
   

   Let's add another catch block for this type of exception.

4. Leave the existing catch blocks, and add a new catch block for the overflow exception type, as shown in the following highlighted code:

   catch (OverflowException)
   {
     WriteLine("Your age is a valid number format but it is either too big or small.");
   }
   catch (FormatException)
   {
     WriteLine("The age you entered is not a valid number format.");
   }
   

5. Run the code, enter 9876543210, and view the result, as shown in the following output:

   Before parsing
   What is your age? 9876543210
   Your age is a valid number format but it is either too big or small. 
   After parsing
   

The order in which you catch exceptions is important. The correct order is related to the inheritance hierarchy of the exception types. You will learn about inheritance in Chapter 5, Building Your Own Types with Object-Oriented Programming. However, don't worry too much about this—the compiler will give you build errors if you get exceptions in the wrong order anyway.

You can also add filters to a catch statement using the when keyword, as shown in the following code:

Write("Enter an amount: ");
string? amount = ReadLine();
try
{
  decimal amountValue = decimal.Parse(amount);
}
catch (FormatException) when (amount.Contains("$"))
{
  WriteLine("Amounts cannot use the dollar sign!");
}
catch (FormatException)
{
  WriteLine("Amounts must only contain digits!");
}

Earlier, we saw that when casting between number types, it was possible to lose information, for example, when casting from a long variable to an int variable. If the value stored in a type is too big, it will overflow.

The checked statement tells .NET to throw an exception when an overflow happens instead of allowing it to happen silently, which is done by default for performance reasons.

We will set the initial value of an int variable to its maximum value minus one. Then, we will increment it several times, outputting its value each time. Once it gets above its maximum value, it overflows to its minimum value and continues incrementing from there. Let's see this in action:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named CheckingForOverflow.
2. In Visual Studio Code, select CheckingForOverflow as the active OmniSharp project.
3. In Program.cs, type statements to declare and assign an integer to one less than its maximum possible value, and then increment it and write its value to the console three times, as shown in the following code:

   int x = int.MaxValue - 1; 
   WriteLine($"Initial value: {x}"); 
   x++;
   WriteLine($"After incrementing: {x}"); 
   x++;
   WriteLine($"After incrementing: {x}"); 
   x++;
   WriteLine($"After incrementing: {x}");
   

4. Run the code and view the result that shows the value overflowing silently and wrapping around to large negative values, as shown in the following output:

   Initial value: 2147483646
   After incrementing: 2147483647
   After incrementing: -2147483648
   After incrementing: -2147483647
   

5. Now, let's get the compiler to warn us about the overflow by wrapping the statements using a checked statement block, as shown highlighted in the following code:

   checked
   {
     int x = int.MaxValue - 1; 
     WriteLine($"Initial value: {x}"); 
     x++;
     WriteLine($"After incrementing: {x}"); 
     x++;
     WriteLine($"After incrementing: {x}"); 
     x++;
     WriteLine($"After incrementing: {x}");
   }
   

6. Run the code and view the result that shows the overflow being checked and causing an exception to be thrown, as shown in the following output:

   Initial value: 2147483646
   After incrementing: 2147483647
   Unhandled Exception: System.OverflowException: Arithmetic operation resulted in an overflow.
   

7. Just like any other exception, we should wrap these statements in a try statement block and display a nicer error message for the user, as shown in the following code:

   try
   {
     // previous code goes here
   }
   catch (OverflowException)
   {
     WriteLine("The code overflowed but I caught the exception.");
   } 
   

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

   Initial value: 2147483646
   After incrementing: 2147483647
   The code overflowed but I caught the exception.
   

The previous section was about the default overflow behavior at runtime and how to use the checked statement to change that behavior. This section is about compile time overflow behavior and how to use the unchecked statement to change that behavior.

A related keyword is unchecked. This keyword switches off overflow checks performed by the compiler within a block of code. Let's see how to do this:

1. Type the following statement at the end of the previous statements. The compiler will not compile this statement because it knows it would overflow:

   int y = int.MaxValue + 1;
   

2. Hover your mouse pointer over the error, and note a compile-time check is shown as an error message, as shown in Figure 3.1:

   

   Figure 3.1: A compile-time check in the PROBLEMS window

3. To disable compile-time checks, wrap the statement in an unchecked block, write the value of y to the console, decrement it, and repeat, as shown in the following code:

   unchecked
   {
     int y = int.MaxValue + 1; 
     WriteLine($"Initial value: {y}"); 
     y--;
     WriteLine($"After decrementing: {y}"); 
     y--;
     WriteLine($"After decrementing: {y}");
   }
   

4. Run the code and view the results, as shown in the following output:

   Initial value: -2147483648
   After decrementing: 2147483647
   After decrementing: 2147483646 
   

Of course, it would be rare that you would want to explicitly switch off a check like this because it allows an overflow to occur. But perhaps you can think of a scenario where you might want that behavior.

Test your knowledge and understanding by answering some questions, get some hands-on practice, and explore with deeper research into this chapter's topics.

Answer the following questions:

1. What happens when you divide an int variable by 0?
2. What happens when you divide a double variable by 0?
3. What happens when you overflow an int variable, that is, set it to a value beyond its range?
4. What is the difference between x = y++; and x = ++y;?
5. What is the difference between break, continue, and return when used inside a loop statement?
6. What are the three parts of a for statement and which of them are required?
7. What is the difference between the = and == operators?
8. Does the following statement compile?

   for ( ; true; ) ;
   

9. What does the underscore _ represent in a switch expression?
10. What interface must an object implement to be enumerated over by using the foreach statement?

What will happen if this code executes?

int max = 500;
for (byte i = 0; i < max; i++)
{
  WriteLine(i);
}

Create a console application in Chapter03 named Exercise02 and enter the preceding code. Run the console application and view the output. What happens?

What code could you add (don't change any of the preceding code) to warn us about the problem?

FizzBuzz is a group word game for children to teach them about division. Players take turns to count incrementally, replacing any number divisible by three with the word fizz, any number divisible by five with the word buzz, and any number divisible by both with fizzbuzz.

Create a console application in Chapter03 named Exercise03 that outputs a simulated FizzBuzz game counting up to 100. The output should look something like Figure 3.2:

Figure 3.2: A simulated FizzBuzz game output

Create a console application in Chapter03 named Exercise04 that asks the user for two numbers in the range 0-255 and then divides the first number by the second:

Enter a number between 0 and 255: 100
Enter another number between 0 and 255: 8
100 divided by 8 is 12

Write exception handlers to catch any thrown errors, as shown in the following output:

Enter a number between 0 and 255: apples
Enter another number between 0 and 255: bananas 
FormatException: Input string was not in a correct format.

What are the values of x and y after the following statements execute?

1. Increment and addition operators:

   x = 3;
   y = 2 + ++x;
   

2. Binary shift operators:

   x = 3 << 2;
   y = 10 >> 1;
   

3. Bitwise operators:

   x = 10 & 8;
   y = 10 | 7;
   

Use the links on the following page to learn about the topics covered in this chapter in more detail:

https://github.com/markjprice/cs10dotnet6/blob/main/book-links.md#chapter-3---controlling-flow-and-converting-types

In this chapter, you experimented with some operators, learned how to branch and loop, how to convert between types, and how to catch exceptions.

You are now ready to learn how to reuse blocks of code by defining functions, how to pass values into them and get values back, and how to track down bugs in your code and squash them!

This chapter is about writing functions to reuse code, debugging logic errors during development, logging exceptions during runtime, unit testing your code to remove bugs, and ensuring stability and reliability.

This chapter covers the following topics:

• Writing functions
• Debugging during development
• Logging during runtime
• Unit testing
• Throwing and catching exceptions in functions

A fundamental principle of programming is Don't Repeat Yourself (DRY).

While programming, if you find yourself writing the same statements over and over again, then turn those statements into a function. Functions are like tiny programs that complete one small task. For example, you might write a function to calculate sales tax and then reuse that function in many places in a financial application.

Like programs, functions usually have inputs and outputs. They are sometimes described as black boxes, where you feed some raw materials in one end, and a manufactured item emerges at the other. Once created, you don't need to think about how they work.

Let's say that you want to help your child learn their times tables, so you want to make it easy to generate a times table for a number, such as the 12 times table:

1 x 12 = 12
2 x 12 = 24
...
12 x 12 = 144

You previously learned about the for statement earlier in this book, so you know that it can be used to generate repeated lines of output when there is a regular pattern, such as the 12 times table, as shown in the following code:

for (int row = 1; row <= 12; row++)
{
  Console.WriteLine($"{row} x 12 = {row * 12}");
}

However, instead of outputting the 12 times table, we want to make this more flexible, so it could output the times table for any number. We can do this by creating a function.

Let's explore functions by creating one to output any times table for numbers 0 to 255 multiplied by 1 to 12:

1. Use your preferred coding tool to create a new console app, as defined in the following list:
   1. Project template: Console Application / console
   2. Workspace/solution file and folder: Chapter04
   3. Project file and folder: WritingFunctions
2. Statically import System.Console.
3. In Program.cs, write statements to define a function named TimesTable, as shown in the following code:

   static void TimesTable(byte number)
   {
     WriteLine($"This is the {number} times table:");
     for (int row = 1; row <= 12; row++)
     {
       WriteLine($"{row} x {number} = {row * number}");
     }
     WriteLine();
   }
   

   In the preceding code, note the following:

   • TimesTable must have a byte value passed to it as a parameter named number.
   • TimesTable is a static method because it will be called by the static method Main.
   • TimesTable does not return a value to the caller, so it is declared with the void keyword before its name.
   • TimesTable uses a for statement to output the times table for the number passed to it.
4. After the statement that statically imports the Console class and before the TimesTable function, call the function and pass in a byte value for the number parameter, for example, 6, as shown highlighted in the following code:

   using static System.Console;
   TimesTable(6);
   

   Good Practice: If a function has one or more parameters where just passing the values may not provide enough meaning, then you can optionally specify the name of the parameter as well as its value, as shown in the following code: TimesTable(number: 6).

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

   This is the 6 times table:
   1 x 6 = 6
   2 x 6 = 12
   3 x 6 = 18
   4 x 6 = 24
   5 x 6 = 30
   6 x 6 = 36
   7 x 6 = 42
   8 x 6 = 48
   9 x 6 = 54
   10 x 6 = 60
   11 x 6 = 66
   12 x 6 = 72
   

6. Change the number passed into the TimesTable function to other byte values between 0 and 255 and confirm that the output times tables are correct.
7. Note that if you try to pass a non-byte number, for example, an int or double or string, an error is returned, as shown in the following output:

   Error: (1,12): error CS1503: Argument 1: cannot convert from 'int' to 'byte'
   

The previous function performed actions (looping and writing to the console), but it did not return a value. Let's say that you need to calculate sales or value-added tax (VAT). In Europe, VAT rates can range from 8% in Switzerland to 27% in Hungary. In the United States, state sales taxes can range from 0% in Oregon to 8.25% in California.

Let's implement a function to calculate taxes in various regions around the world:

1. Add a function named CalculateTax, as shown in the following code:

   static decimal CalculateTax(
     decimal amount, string twoLetterRegionCode)
   {
     decimal rate = 0.0M;
     switch (twoLetterRegionCode)
     {
       case "CH": // Switzerland
         rate = 0.08M;
         break;
       case "DK": // Denmark
       case "NO": // Norway
         rate = 0.25M;
         break;
       case "GB": // United Kingdom
       case "FR": // France
         rate = 0.2M;
         break;
       case "HU": // Hungary
         rate = 0.27M;
         break;
       case "OR": // Oregon
       case "AK": // Alaska
       case "MT": // Montana
         rate = 0.0M;
         break;
       case "ND": // North Dakota
       case "WI": // Wisconsin
       case "ME": // Maine
       case "VA": // Virginia
         rate = 0.05M;
         break;
       case "CA": // California
         rate = 0.0825M;
         break;
       default: // most US states
         rate = 0.06M;
         break;
     }
     return amount * rate;
   }
   

   In the preceding code, note the following:

   • CalculateTax has two inputs: a parameter named amount that will be the amount of money spent, and a parameter named twoLetterRegionCode that will be the region the amount is spent in.
   • CalculateTax will perform a calculation using a switch statement and then return the sales tax or VAT owed on the amount as a decimal value; so, before the name of the function, we have declared the data type of the return value to be decimal.
2. Comment out the TimesTable method call and call the CalculateTax method, passing values for the amount such as 149 and a valid region code such as FR, as shown in the following code:

   // TimesTable(6);
   decimal taxToPay = CalculateTax(amount: 149, twoLetterRegionCode: "FR"); 
   WriteLine($"You must pay {taxToPay} in tax.");
   

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

   You must pay 29.8 in tax.
   

Can you think of any problems with the CalculateTax function as written? What would happen if the user enters a code such as fr or UK? How could you rewrite the function to improve it? Would using a switch expression instead of a switch statement be clearer?

Numbers that are used to count are called cardinal numbers, for example, 1, 2, and 3, whereas numbers used to order are ordinal numbers, for example, 1st, 2nd, and 3rd. Let's create a function to convert cardinals to ordinals:

1. Write a function named CardinalToOrdinal that converts a cardinal int value into an ordinal string value; for example, it converts 1 into 1st, 2 into 2nd, and so on, as shown in the following code:

   static string CardinalToOrdinal(int number)
   {
     switch (number)
     {
       case 11: // special cases for 11th to 13th
       case 12:
       case 13:
         return $"{number}th";
       default:
         int lastDigit = number % 10;
         string suffix = lastDigit switch
         {
           1 => "st",
           2 => "nd",
           3 => "rd",
           _ => "th"
         };
         return $"{number}{suffix}";
     }
   }
   

   From the preceding code, note the following:

   • CardinalToOrdinal has one input: a parameter of the int type named number, and one output: a return value of the string type.
   • A switch statement is used to handle the special cases of 11, 12, and 13.
   • A switch expression then handles all other cases: if the last digit is 1, then use st as the suffix; if the last digit is 2, then use nd as the suffix; if the last digit is 3, then use rd as the suffix; and if the last digit is anything else, then use th as the suffix.
2. Write a function named RunCardinalToOrdinal that uses a for statement to loop from 1 to 40, calling the CardinalToOrdinal function for each number and writing the returned string to the console, separated by a space character, as shown in the following code:

   static void RunCardinalToOrdinal()
   {
     for (int number = 1; number <= 40; number++)
     {
       Write($"{CardinalToOrdinal(number)} ");
     }
     WriteLine();
   }
   

3. Comment out the CalculateTax statements, and call the RunCardinalToOrdinal method, as shown in the following code:

   // TimesTable(6);
   // decimal taxToPay = CalculateTax(amount: 149, twoLetterRegionCode: "FR"); 
   // WriteLine($"You must pay {taxToPay} in tax.");
   RunCardinalToOrdinal();
   

4. Run the code and view the results, as shown in the following output:

   1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11th 12th 13th 14th 15th 16th 17th 18th 19th 20th 21st 22nd 23rd 24th 25th 26th 27th 28th 29th 30th 31st 32nd 33rd 34th 35th 36th 37th 38th 39th 40th
   

The factorial of 5 is 120, because factorials are calculated by multiplying the starting number by one less than itself, and then by one less again, and so on, until the number is reduced to 1. An example can be seen here: 5 x 4 x 3 x 2 x 1 = 120.

Factorials are written like this: 5!, where the exclamation mark is read as bang, so 5! = 120, that is, five bang equals one hundred and twenty. Bang is a good name for factorials because they increase in size very rapidly, just like an explosion.

We will write a function named Factorial; this will calculate the factorial for an int passed to it as a parameter. We will use a clever technique called recursion, which means a function that calls itself within its implementation, either directly or indirectly:

1. Add a function named Factorial, and a function to call it, as shown in the following code:

   static int Factorial(int number)
   {
     if (number < 1)
     {
       return 0;
     }
     else if (number == 1)
     {
       return 1;
     }
     else
     {
       return number * Factorial(number - 1);
     }
   }
   

   As before, there are several noteworthy elements of the preceding code, including the following:

   • If the input parameter number is zero or negative, Factorial returns 0.
   • If the input parameter number is 1, Factorial returns 1, and therefore stops calling itself.
   • If the input parameter number is larger than one, which it will be in all other cases, Factorial multiplies the number by the result of calling itself and passing one less than number. This makes the function recursive.

   More Information: Recursion is clever, but it can lead to problems, such as a stack overflow due to too many function calls because memory is used to store data on every function call, and it eventually uses too much. Iteration is a more practical, if less succinct, solution in languages such as C#. You can read more about this at the following link: https://en.wikipedia.org/wiki/Recursion_(computer_science)#Recursion_versus_iteration.

2. Add a function named RunFactorial that uses a for statement to output the factorials of numbers from 1 to 14, calls the Factorial function inside its loop, and then outputs the result, formatted using the code N0, which means number format uses thousand separators with zero decimal places, as shown in the following code:

   static void RunFactorial()
   {
     for (int i = 1; i < 15; i++)
     {
       WriteLine($"{i}! = {Factorial(i):N0}");
     }
   }
   

3. Comment out the RunCardinalToOrdinal method call and call the RunFactorial method.
4. Run the code and view the results, as shown in the following output:

   1! = 1
   2! = 2
   3! = 6
   4! = 24
   5! = 120
   6! = 720
   7! = 5,040
   8! = 40,320
   9! = 362,880
   10! = 3,628,800
   11! = 39,916,800
   12! = 479,001,600
   13! = 1,932,053,504
   14! = 1,278,945,280
   

It is not immediately obvious in the previous output, but factorials of 13 and higher overflow the int type because they are so big. 12! is 479,001,600, which is about half a billion. The maximum positive value that can be stored in an int variable is about two billion. 13! is 6,227,020,800, which is about six billion and when stored in a 32-bit integer it overflows silently without showing any problems.

Do you remember what we can do to be notified of a numeric overflow?

What should you do to get notified when an overflow happens? Of course, we could solve the problem for 13! and 14! by using a long (64-bit integer) instead of an int (32-bit integer), but we will quickly hit the overflow limit again.

The point of this section is to understand that numbers can overflow and how to show that rather than ignore it, not specifically how to calculate factorials higher than 12!.

1. Modify the Factorial function to check for overflows, as shown highlighted in the following code:

   checked // for overflow
   {
     return number * Factorial(number - 1);
   }
   

2. Modify the RunFactorial function to handle overflow exceptions when calling the Factorial function, as shown highlighted in the following code:

   try
   {
     WriteLine($"{i}! = {Factorial(i):N0}");
   }
   catch (System.OverflowException)
   {
     WriteLine($"{i}! is too big for a 32-bit integer.");
   }
   

3. Run the code and view the results, as shown in the following output:

   1! = 1
   2! = 2
   3! = 6
   4! = 24
   5! = 120
   6! = 720
   7! = 5,040
   8! = 40,320
   9! = 362,880
   10! = 3,628,800
   11! = 39,916,800
   12! = 479,001,600
   13! is too big for a 32-bit integer.
   14! is too big for a 32-bit integer.
   

By default, when calling a function such as CardinalToOrdinal, code editors will show a tooltip with basic information, as shown in Figure 4.1:

Figure 4.1: A tooltip showing the default simple method signature

Let's improve the tooltip by adding extra information:

1. If you are using Visual Studio Code with the C# extension, you should navigate to View | Command Palette | Preferences: Open Settings (UI), and then search for formatOnType and make sure that is enabled. C# XML documentation comments are a built-in feature of Visual Studio 2022.
2. On the line above the CardinalToOrdinal function, type three forward slashes ///, and note that they are expanded into an XML comment that recognizes that the function has a single parameter named number.
3. Enter suitable information for the XML documentation comment for a summary and to describe the input parameter and the return value for the CardinalToOrdinal function, as shown in the following code:

   /// <summary>
   /// Pass a 32-bit integer and it will be converted into its ordinal equivalent.
   /// </summary>
   /// <param name="number">Number is a cardinal value e.g. 1, 2, 3, and so on.</param>
   /// <returns>Number as an ordinal value e.g. 1st, 2nd, 3rd, and so on.</returns>
   

4. Now, when calling the function, you will see more details, as shown in Figure 4.2:

   

Figure 4.2: A tooltip showing the more detailed method signature

At the time of writing the sixth edition, C# XML documentation comments do not work in .NET Interactive notebooks.

F# is Microsoft's strongly typed functional-first programming language that, like C#, compiles to IL to be executed by .NET. Functional languages evolved from lambda calculus; a computational system based only on functions. The code looks more like mathematical functions than steps in a recipe.

Some of the important attributes of functional languages are defined in the following list:

• Modularity: The same benefit of defining functions in C# applies to functional languages. Break up a large complex code base into smaller pieces.
• Immutability: Variables in the C# sense do not exist. Any data value inside a function cannot change. Instead, a new data value can be created from an existing one. This reduces bugs.
• Maintainability: Code is cleaner and clearer (for mathematically inclined programmers!).

Since C# 6, Microsoft has worked to add features to the language to support a more functional approach. For example, adding tuples and pattern matching in C# 7, non-null reference types in C# 8, and improving pattern matching and adding records, that is, immutable objects in C# 9.

In C# 6, Microsoft added support for expression-bodied function members. We will look at an example of this now.

The Fibonacci sequence of numbers always starts with 0 and 1. Then the rest of the sequence is generated using the rule of adding together the previous two numbers, as shown in the following sequence of numbers:

0 1 1 2 3 5 8 13 21 34 55 ...

The next term in the sequence would be 34 + 55, which is 89.

We will use the Fibonacci sequence to illustrate the difference between an imperative and declarative function implementation:

1. Add a function named FibImperative that will be written in an imperative style, as shown in the following code:

   static int FibImperative(int term)
   {
     if (term == 1)
     {
       return 0;
     }
     else if (term == 2)
     {
       return 1;
     }
     else
     {
       return FibImperative(term - 1) + FibImperative(term - 2);
     }
   }
   

2. Add a function named RunFibImperative that calls FibImperative inside a for statement that loops from 1 to 30, as shown in the following code:

   static void RunFibImperative()
   {
     for (int i = 1; i <= 30; i++)
     {
       WriteLine("The {0} term of the Fibonacci sequence is {1:N0}.",
         arg0: CardinalToOrdinal(i),
         arg1: FibImperative(term: i));
     }
   }
   

3. Comment out the other method calls and call the RunFibImperative method.
4. Run the code and view the results, as shown in the following output:

   The 1st term of the Fibonacci sequence is 0.
   The 2nd term of the Fibonacci sequence is 1.
   The 3rd term of the Fibonacci sequence is 1.
   The 4th term of the Fibonacci sequence is 2.
   The 5th term of the Fibonacci sequence is 3.
   The 6th term of the Fibonacci sequence is 5.
   The 7th term of the Fibonacci sequence is 8.
   The 8th term of the Fibonacci sequence is 13.
   The 9th term of the Fibonacci sequence is 21.
   The 10th term of the Fibonacci sequence is 34.
   The 11th term of the Fibonacci sequence is 55.
   The 12th term of the Fibonacci sequence is 89.
   The 13th term of the Fibonacci sequence is 144.
   The 14th term of the Fibonacci sequence is 233.
   The 15th term of the Fibonacci sequence is 377.
   The 16th term of the Fibonacci sequence is 610.
   The 17th term of the Fibonacci sequence is 987.
   The 18th term of the Fibonacci sequence is 1,597.
   The 19th term of the Fibonacci sequence is 2,584.
   The 20th term of the Fibonacci sequence is 4,181.
   The 21st term of the Fibonacci sequence is 6,765.
   The 22nd term of the Fibonacci sequence is 10,946.
   The 23rd term of the Fibonacci sequence is 17,711.
   The 24th term of the Fibonacci sequence is 28,657.
   The 25th term of the Fibonacci sequence is 46,368.
   The 26th term of the Fibonacci sequence is 75,025.
   The 27th term of the Fibonacci sequence is 121,393.
   The 28th term of the Fibonacci sequence is 196,418.
   The 29th term of the Fibonacci sequence is 317,811.
   The 30th term of the Fibonacci sequence is 514,229.
   

5. Add a function named FibFunctional written in a declarative style, as shown in the following code:

   static int FibFunctional(int term) => 
     term switch
     {
       1 => 0,
       2 => 1,
       _ => FibFunctional(term - 1) + FibFunctional(term - 2)
     };
   

6. Add a function to call it inside a for statement that loops from 1 to 30, as shown in the following code:

   static void RunFibFunctional()
   {
     for (int i = 1; i <= 30; i++)
     {
       WriteLine("The {0} term of the Fibonacci sequence is {1:N0}.",
         arg0: CardinalToOrdinal(i),
         arg1: FibFunctional(term: i));
     }
   }
   

7. Comment out the RunFibImperative method call, and call the RunFibFunctional method.
8. Run the code and view the results (which will be the same as before).

In this section, you will learn how to debug problems at development time. You must use a code editor that has debugging tools such as Visual Studio or Visual Studio Code. At the time of writing, you cannot use .NET Interactive Notebooks to debug code, but this is expected to be added in the future.

Let's explore debugging by creating a console app with a deliberate bug that we will then use the debugger tools in your code editor to track down and fix:

1. Use your preferred coding tool to add a new Console Application to the Chapter04 workspace/solution named Debugging.
2. In Visual Studio Code, select Debugging as the active OmniSharp project. When you see the pop-up warning message saying that required assets are missing, click Yes to add them.
3. In Visual Studio, set the startup project for the solution to the current selection.
4. In Program.cs, add a function with a deliberate bug, as shown in the following code:

   static double Add(double a, double b)
   {
     return a * b; // deliberate bug!
   }
   

5. Below the Add function, write statements to declare and set some variables and then add them together using the buggy function, as shown in the following code:

   double a = 4.5;
   double b = 2.5;
   double answer = Add(a, b); 
   WriteLine($"{a} + {b} = {answer}");
   WriteLine("Press ENTER to end the app.");
   ReadLine(); // wait for user to press ENTER
   

6. Run the console application and view the result, as shown in the following partial output:

   4.5 + 2.5 = 11.25
   

But wait, there's a bug! 4.5 added to 2.5 should be 7, not 11.25!

We will use the debugging tools to hunt for and squash the bug.

Breakpoints allow us to mark a line of code that we want to pause at to inspect the program state and find bugs.

Let's set a breakpoint and then start debugging using Visual Studio 2022:

1. Click in the statement that declares the variable named a.
2. Navigate to Debug | Toggle Breakpoint or press F9. A red circle will then appear in the margin bar on the left-hand side and the statement will be highlighted in red to indicate that a breakpoint has been set, as shown in Figure 4.3:

   

   Figure 4.3: Toggling breakpoints using Visual Studio 2022

   Breakpoints can be toggled off with the same action. You can also left-click in the margin to toggle a breakpoint on and off, or right-click a breakpoint to see more options, such as delete, disable, or edit conditions or actions for an existing breakpoint.

3. Navigate to Debug | Start Debugging or press F5. Visual Studio starts the console application and then pauses when it hits the breakpoint. This is known as break mode. Extra windows titled Locals (showing current values of local variables), Watch 1 (showing any watch expressions you have defined), Call Stack, Exception Settings, and Immediate Window appear. The Debugging toolbar appears. The line that will be executed next is highlighted in yellow, and a yellow arrow points at the line from the margin bar, as shown in Figure 4.4:

   

Figure 4.4: Break mode in Visual Studio 2022

If you do not want to see how to use Visual Studio Code to start debugging then you can skip the next section and continue to the section titled Navigating with the debugging toolbar.

Let's set a breakpoint and then start debugging using Visual Studio Code:

1. Click in the statement that declares the variable named a.
2. Navigate to Run | Toggle Breakpoint or press F9. A red circle will appear in the margin bar on the left-hand side to indicate that a breakpoint has been set, as shown in Figure 4.5:

   

   Figure 4.5: Toggling breakpoints using Visual Studio Code

   Breakpoints can be toggled off with the same action. You can also left-click in the margin to toggle a breakpoint on and off, or right-click to see more options, such as remove, edit, or disable an existing breakpoint; or adding a breakpoint, conditional breakpoint, or logpoint when a breakpoint does not yet exist.

   Logpoints, also known as tracepoints, indicate that you want to record some information without having to actually stop executing the code at that point.

3. Navigate to View | Run, or in the left navigation bar you can click the Run and Debug icon (the triangle "play" button and "bug"), as shown in Figure 4.5.
4. At the top of the DEBUG window, click on the dropdown to the right of the Start Debugging button (green triangular "play" button), and select .NET Core Launch (console) (Debugging), as shown in Figure 4.6:

   

   Figure 4.6: Selecting the project to debug using Visual Studio Code

   Good Practice: If you do not see a choice in the dropdown list for the Debugging project, it is because that project does not have the assets needed to debug. Those assets are stored in the .vscode folder. To create the .vscode folder for a project, navigate to View | Command Palette, select OmniSharp: Select Project, and then select the Debugging project. After a few seconds, when prompted, Required assets to build and debug are missing from 'Debugging'. Add them?, click Yes to add the missing assets.

5. At the top of the DEBUG window, click the Start Debugging button (green triangular "play" button), or navigate to Run | Start Debugging, or press F5. Visual Studio Code starts the console application and then pauses when it hits the breakpoint. This is known as break mode. The line that will be executed next is highlighted in yellow, and a yellow block points at the line from the margin bar, as shown in Figure 4.7:

   

   Figure 4.7: Break mode in Visual Studio Code

Visual Studio Code shows a floating toolbar with buttons to make it easy to access debugging features. Visual Studio 2022 has one button in its Standard toolbar to start or continue debugging and a separate Debugging toolbar for the rest of the tools.

Both are shown in Figure 4.8 and as described in the following list:

Figure 4.8: Debugging toolbars in Visual Studio 2022 and Visual Studio Code

• Continue/F5: This button will continue running the program from the current position until it ends or hits another breakpoint.
• Step Over/F10, Step Into/F11, and Step Out/Shift + F11 (blue arrows over dots): These buttons step through the code statements in various ways, as you will see in a moment.
• Restart/Ctrl or Cmd + Shift + F5 (circular arrow): This button will stop and then immediately restart the program with the debugger attached again.
• Stop/Shift + F5 (red square): This button will stop the debugging session.

While debugging, both Visual Studio Code and Visual Studio show extra windows that allow you to monitor useful information, such as variables, while you step through your code.

The most useful windows are described in the following list:

• VARIABLES, including Locals, which shows the name, value, and type for any local variables automatically. Keep an eye on this window while you step through your code.
• WATCH, or Watch 1, which shows the value of variables and expressions that you manually enter.
• CALL STACK, which shows the stack of function calls.
• BREAKPOINTS, which shows all your breakpoints and allows finer control over them.

When in break mode, there is also a useful window at the bottom of the edit area:

• DEBUG CONSOLE or Immediate Window enables live interaction with your code. You can interrogate the program state, for example, by entering the name of a variable. For example, you can ask a question such as, "What is 1+2?" by typing 1+2 and pressing Enter, as shown in Figure 4.9:

  

Figure 4.9: Interrogating the program state

Let's explore some ways to step through the code using either Visual Studio or Visual Studio Code:

1. Navigate to Run/Debug | Step Into, or click on the Step Into button in the toolbar, or press F11. The yellow highlight steps forward one line.
2. Navigate to Run/Debug | Step Over, or click on the Step Over button in the toolbar, or press F10. The yellow highlight steps forward one line. At the moment, you can see that there is no difference between using Step Into or Step Over.
3. You should now be on the line that calls the Add method, as shown in Figure 4.10:

   

   Figure 4.10: Stepping into and over code

   The difference between Step Into and Step Over can be seen when you are about to execute a method call:

   • If you click on Step Into, the debugger steps into the method so that you can step through every line in that method.
   • If you click on Step Over, the whole method is executed in one go; it does not skip over the method without executing it.
4. Click on Step Into to step inside the method.
5. Hover your mouse pointer over the a or b parameters in the code editing window and note that a tooltip appears showing their current value.
6. Select the expression a * b, right-click the expression, and select Add to Watch or Add Watch. The expression is added to the WATCH window, showing that this operator is multiplying a by b to give the result 11.25.
7. In the WATCH or Watch 1 window, right-click the expression and choose Remove Expression or Delete Watch.
8. Fix the bug by changing * to + in the Add function.
9. Stop debugging, recompile, and restart debugging by clicking the circular arrow Restart button or pressing Ctrl or Cmd + Shift + F5.
10. Step over the function, take a minute to note how it now calculates correctly, and click the Continue button or press F5.
11. With Visual Studio Code, note that when writing to the console during debugging, the output appears in the DEBUG CONSOLE window instead of the TERMINAL window, as shown in Figure 4.11:

    

    Figure 4.11: Writing to the DEBUG CONSOLE during debugging