Let’s get started by introducing you to the code solutions, structure, and content of this book.

Getting code solutions for this book

The GitHub repository for this book has solutions that use full application projects for all code tasks and exercises, found at the following link:

https://github.com/markjprice/cs13net9

After navigating to the GitHub repository in your web browser, press the . (dot) key on your keyboard, or manually change .com to .dev in the link to convert the repository into a live code editor based on VS Code, called GitHub Codespaces, as shown in Figure 1.1:

Figure 1.1: GitHub Codespaces live-editing the book’s GitHub repository

VS Code in a web browser is great to run alongside your chosen local 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.

.NET terms used in this book

Throughout this book, I use the term modern .NET to refer to .NET 9 and its predecessors, like .NET 6, that derive 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.

The structure and style of this book

After this first chapter, the book will be divided into three parts: language, libraries, and web development.

First, we will cover the grammar and vocabulary of the C# language; second, we will cover the types available in the .NET libraries for building app features; and third, we will cover the fundamentals of cross-platform websites, services, and browser apps that 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.

Topics covered by this book

The following topics are covered in this book:

• Language fundamentals: Fundamental features of the C# language, from declaring variables to writing functions and object-oriented programming.
• Library fundamentals: Fundamental features of the .NET base class library, as well as some important optional packages for common tasks like database access.
• Modern web development fundamentals: Modern features of the ASP.NET Core framework for server-side and client-side website and web service development. This includes Blazor and Minimal APIs and excludes controller-based features like MVC and Web API, or legacy features like Razor Pages.

This book, C# 13 and .NET 9 – Modern Cross-Platform Development Fundamentals, is best read linearly, chapter by chapter, because it builds up fundamental skills and knowledge.

Topics covered by Apps and Services with .NET 8

The following topics are available in a companion book, Apps and Services with .NET 8:

• Data: SQL Server and Azure Cosmos DB.
• Specialized libraries: Dates, times, time zones, and internationalization; common third-party libraries for image handling, logging, mapping, and generating PDFs; multitasking and concurrency; and many more.
• Services: Caching, queuing, background services, gRPC, GraphQL, Azure Functions, SignalR, and Minimal APIs.
• User interfaces: ASP.NET Core, Blazor, and .NET MAUI.

This book can be read more like a cookbook, so if you are especially interested in building gRPC services, then you can read that chapter without the preceding chapters about minimal API services.

Topics covered by Tools and Skills for .NET 8

The following topics are available in a companion book, Tools and Skills for .NET 8:

• Debugging and memory analysis.
• All the important types of testing, from unit and integration to performance and web UI testing.
• Docker and .NET Aspire for local distributed development and testing.
• Design patterns and solution architecture.
• Preparing for an interview to get the .NET developer career that you want.

Finding all my books

To see a list of all the books I have published with Packt, you can use the following link:

https://subscription.packtpub.com/search?query=mark+j.+price

A similar list is available on Amazon:

https://www.amazon.com/Mark-J-Price/e/B071DW3QGN/

You can search other book-selling sites for my books too.

Before you start programming, you’ll need a code editor for C#, either from Microsoft or a third party.

Microsoft has a family of code editors and Integrated Development Environments (IDEs), which include:

• Visual Studio for Windows
• VS Code for Windows, Mac, or Linux
• VS Code for the Web or GitHub Codespaces

Third parties have created their own C# code editors; for example, JetBrains has the cross-platform Rider, which is available for Windows, Mac, or Linux and since October 2024 is free for non-commercial use. Rider is popular with more experienced .NET developers.

Most readers use Visual Studio, which is a large and complex tool that can do many things. But Visual Studio likes to provide its own mechanism to do as much as possible, and a .NET developer who uses it could easily think that Visual Studio is the only way to complete a .NET-related task, like modifying project configuration or editing a code file.

Always try to remember that Visual Studio and all the other code editors are just tools that do work for you that you could do manually. They just show you a view above what is really happening in the files you’re working on, like the project file and all the C# code files.

You could just use a plain text editor to manually edit the project and code files. Ultimately, you use the dotnet command-line interface to compile– aka build– the project files into a runnable assembly packaged as either a .dll or .exe file, as shown in Figure 1.2:

Figure 1.2: All code editors ultimately just change underlying files

Choosing the appropriate tool and application type for learning

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 can be better while you are learning.

Having said that, you could 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 VS Code, Visual Studio, and even Rider.

In this book, I give detailed step-by-step instructions in this chapter on how to create multiple projects in both Visual Studio and VS Code. There are also links to online instructions for other code editors, as shown at the following link: https://github.com/markjprice/cs13net9/blob/main/docs/code-editors/README.md.

In subsequent chapters, I will only give the names of projects along with general instructions, 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 11 is to build console apps. Then, in Chapters 12 to 15, which are about web development, you will build websites and services using the modern parts of ASP.NET Core, including Blazor and Minimal APIs.

VS Code for cross-platform development

The most modern and lightweight code editor to choose from, and the only one from Microsoft that is cross-platform, is VS 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.

VS 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#. The most important extension for C# and .NET developers is the C# Dev Kit that was released in preview in June 2023, as it turns VS Code from a general-purpose code editor into a tool optimized for C# and .NET developers.

Being cross-platform and lightweight, VS Code and its extensions can be installed on all platforms that your apps will be deployed to for quick bug fixes and so on. Choosing VS Code means a developer can use a cross-platform code editor to develop cross-platform apps. VS Code is supported on ARM processors so that you can develop on Apple Silicon computers and Raspberry Pi computers.

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

VS Code is by far the most popular code editor or IDE, with over 73% of professional developers selecting it in a Stack Overflow survey, which you can read at the following link: https://survey.stackoverflow.co/2024/.

GitHub Codespaces for development in the cloud

GitHub Codespaces is a fully configured development environment, based on VS 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.

But note that for your GitHub Codespaces experience to be fully functional and practically useful, it does have a license cost.

Visual Studio for general development

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

Visual Studio only runs on Windows 10 version 1909 or later, Home, Professional, Education, or Enterprise; or on Windows 11 version 21H2 or later, Home, Pro, Pro Education, Pro for Workstations, Enterprise, or Education. Windows Server 2016 and later are also supported. 32-bit operating systems and Windows S mode are not supported.

What I used

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

• Windows 11 on a Surface Laptop 7 Copilot+ PC with Visual Studio, VS Code, and Rider.
• macOS on an Apple Silicon Mac mini (M1) desktop with VS Code and Rider.

I hope that you have access to a variety of hardware and software too, as 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.

Deploying cross-platform

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

.NET 9 supports the following platforms for deployment:

• Windows: Windows 10 version 1607 or later, Windows 11 version 22000 or later, Windows Server 2012 R2 SP1 or later, and Nano Server version 2019 or 2022.
• Mac: macOS Catalina version 10.15 or later and in the Rosetta 2 x64 emulator.
• Linux: Alpine Linux 3.19 or 3.20, CentOS Stream 9, Debian 12, Fedora 40, openSUSE 15.5 or 15.6, RHEL 8 or 9, SUSE Enterprise Linux 15.5 or 15.6, and Ubuntu 20.04, 22.04, or 24.04.
• Android: API 21 or later is the minimum SDK target. Versions 12, 12.1, 13, and 14.
• iOS and iPadOS: 15, 16, or 17. iOS 12.2 is used as the minimum SDK target.
• Mac Catalyst: 12, 13, or 14.

Windows Arm64 support in .NET 5 and later means you can develop on, and deploy to, Windows Arm devices like Microsoft’s Windows Dev Kit 2023 (formerly known as Project Volterra) and Surface Pro 11 and Surface Laptop 7.

All versions of .NET that are supported can be automatically patched via Microsoft Update on Windows.

Downloading and installing Visual Studio

Many professional .NET developers use Visual Studio in their day-to-day development work. Even if you choose to use VS Code to complete the coding tasks in this book, you might want to familiarize yourself with Visual Studio too. It is not until you have written a decent amount of code with a tool that you can really judge if it fits your needs.

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 VS Code on macOS or Linux.

Since October 2014, Microsoft has made a professional-quality edition of Visual Studio 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 the latest version of Visual Studio from the following link: https://visualstudio.microsoft.com/downloads/.

2. Run the installer to start the installation.
3. On the Workloads tab, select the following:
   • ASP.NET and web development.
   • .NET desktop development (because this includes console apps).
   • Desktop development with C++ with all default components (because this enables you to publish console apps and web services that start faster and have smaller memory footprints).
4. Click Install and wait for the installer to acquire the selected software, and then install it.
5. When the installation is complete, click Launch.
6. 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/.
7. 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.
8. If you want to customize your keyboard shortcuts, navigate to Tools | Options…, and then select the Keyboard section.

Keyboard shortcuts for Visual Studio

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://learn.microsoft.com/en-us/visualstudio/ide/identifying-and-customizing-keyboard-shortcuts-in-visual-studio.

Downloading and installing VS Code

VS 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 the Insiders edition, which is a daily build of the next version.

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

Let’s now download and install VS Code, the .NET SDK, and the C# Dev Kit extension:

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

2. Download and install the .NET SDK for version 9.0 and version 8.0 from the following link: https://www.microsoft.com/net/download.

3. To install the C# Dev Kit extension with a user interface, you must first launch the VS Code application.
4. In VS Code, click the Extensions icon or navigate to View | Extensions.
5. C# Dev Kit 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 the supporting packages to download and install.

Installing other extensions

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

Table 1.1: VS Code extensions for .NET development

You can install a VS Code extension at the command prompt or terminal, as shown in Table 1.2:

Table 1.2: Managing VS Code extensions at the command prompt

For example, to install the C# Dev Kit extension, enter the following at the command prompt:

code --install-extension ms-dotnettools.csdevkit

Understanding VS Code versions

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

• Version 1.93.0, August 2024 feature release
• Version 1.93.1, August 2024 bug fix release

The version used in this book is 1.93.0, the August 2024 feature release, but the version of VS Code is less important than the version of the C# Dev Kit or C# extension that you install. I recommend C# Dev Kit v1.10.18 or later with C# extension v2.45.20 or later.

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.

Keyboard shortcuts for VS Code

If you want to customize your keyboard shortcuts for VS 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 VS Code 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

“Those who cannot remember the past are condemned to repeat it.”

– George Santayana

.NET, .NET Core, .NET Framework, .NET Standard, and Xamarin are related and overlapping platforms for developers used to build applications and services.

If you are not familiar with the history of .NET, then I will introduce you to each of these .NET concepts at the following link:

https://github.com/markjprice/cs13net9/blob/main/docs/ch01-dotnet-history.md

As time moves on, more and more readers already know the history of .NET, so it would be a waste of space in the book to continue to include it. But if you are new to it, then make sure you read all the extras that I provide online, like the preceding one.

Understanding .NET support

.NET versions are either Long-Term Support (LTS), Standard-Term Support (STS) (formerly known as Current), or Preview, as described in the following list:

• LTS releases are a good choice for applications that you do not intend to update frequently, although you must update the .NET runtime for your production code monthly. LTS releases are supported by Microsoft for 3 years after General Availability (GA), or 1 year after the next LTS release ships, whichever is longer.
• STS 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. STS releases are supported by Microsoft for 18 months after GA, or 6 months after the next STS or LTS release ships, whichever is longer.
• Preview releases are for public testing. These are a good choice for adventurous programmers who want to live on the bleeding edge, or programming book authors who need to have early access to new language features, libraries, and app and service platforms. Preview releases are not usually supported by Microsoft, but some preview or Release Candidate (RC) releases may be declared Go Live, meaning they are supported by Microsoft in production.

STS and LTS releases receive critical patches throughout their lifetime for security and reliability.

To better understand your choices of STS and LTS releases, it is helpful to see them visualized, with 3-year-long black bars for LTS releases, and 1½-year-long gray bars for STS releases, as shown in Figure 1.3:

Figure 1.3: Support durations for recent and planned STS and LTS releases

During the lifetime of .NET 9, .NET 8 will still be supported and .NET 10 will be released. I have tried to be cognizant that you might choose to use .NET 8 or .NET 10 with this book; however, obviously, the book cannot cover new features of .NET 10, since I don’t know what they will be!

If you need LTS from Microsoft, then set your .NET projects to target .NET 8 today and then migrate to .NET 10 after it is released in November 2025. This is because .NET 9 is an STS release, and therefore, it will lose support in May 2026, before .NET 8 does in November 2026. As soon as .NET 10 is released, start upgrading your .NET 8 projects to it. You will have a year to do so before .NET 8 reaches its end of life.

At the time of publishing in November 2024, all versions of modern .NET have reached their EOL, except those shown in the following list, which are ordered by their EOL dates:

• .NET 9 will reach EOL in May 2026.
• .NET 8 will reach EOL in November 2026.
• .NET 10 will be available from November 2025 and it will reach EOL in November 2028.

Understanding end of life (EOL)

End of support or end of life (EOL) means the date after which bug fixes, security updates, or technical assistance are no longer available from Microsoft.

For example, now that .NET 6 has reached end of support on November 12, 2024, you can expect the following:

• Projects that use .NET 6 will continue to run.
• No new security updates will be issued for .NET 6 and therefore continuing to use an unsupported version will increasingly expose you to security vulnerabilities.
• You might not be able to access technical support for any .NET 6 applications that you continue to use.
• You will get NETSDK1138 build warnings when targeting .NET 6 from a later SDK like the .NET 9 SDK.
• You will get warnings in Visual Studio when targeting .NET 6.

Understanding .NET support phases

The lifetime of a version of .NET passes through several phases, during which they have varying levels of support, as described in the following list:

• Preview: These are not supported at all. .NET 9 Preview 1 to Preview 7 were in this support phase from February 2024 to August 2024.
• Go Live: These are supported until GA, and then they become immediately unsupported. You must upgrade to the final release version as soon as it is available. .NET 9 Release Candidate 1 and Release Candidate 2 were in this support phase in September and October 2024, respectively.
• Active: .NET 9 will be in this support phase from November 2024 to November 2025.
• Maintenance: Supported only with security fixes for the last 6 months of its lifetime. .NET 9 will be in this support phase from November 2025 to May 2026.
• EOL: Not supported. .NET 9 will reach its EOL in May 2026.

Understanding .NET runtime and .NET SDK versions

If you have not built a standalone app, then the .NET runtime is the minimum you need to install so that an operating system can run a .NET application. The .NET SDK includes the .NET runtime, as well as the compilers and other tools needed to build .NET code and apps.

.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 they are matched with. The third number follows a convention that indicates the minor and patch versions of the SDK. The third number starts at 100 for the initial version (equivalent to 0.0 for the minor and patch numbers). The first digit increments with minor increments, and the other two digits increment with patch increments.

You can see an example of this in Table 1.3:

Table 1.3: Examples of changes and versions for a .NET runtime and SDK

Listing and removing versions of .NET

.NET runtime updates are compatible with a major version such as 9.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
dotnet --info

On Windows, use the Apps & features section to remove .NET SDKs.

On Linux, there is no single mechanism, but you can learn more at the following link:

https://learn.microsoft.com/en-us/dotnet/core/install/remove-runtime-sdk-versions?pivots=os-linux

Understanding intermediate language

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, the newer name for the Common Language Runtime (CLR) in modern .NET. The legacy .NET Framework has a CLR that is Windows-only, and modern .NET has one for each OS, like Windows, macOS, and Linux. These days, they are all commonly referred to as CLRs.

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. You will learn more about this in Chapter 7, Packaging and Distributing .NET Types, in an online section found at the following link: https://github.com/markjprice/cs13net9/blob/main/docs/ch07-decompiling.md.

So, the compilation process typically involves translating source code into IL, which is then compiled into machine code at runtime by the CLR using JIT compilation. Ahead-of-Time (AOT) compilation is an alternative to this approach, and you will learn about it in Chapter 7, Packaging and Distributing .NET Types.

Comparing .NET technologies

We can summarize and compare the current .NET technologies, as shown in Table 1.4:

Visual Studio, Rider, and even VS Code (with the C# Dev Kit extension installed) all have a concept called 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.

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

If you do not have a Windows computer or want to use VS Code, then you can skip this section, since the code will be the same; just the tooling experience is different. However, I recommend that you review this section because it does explain some of the code and how top-level programs work, and that information applies to all code editors.

This section is also available in the GitHub repository (so it can be updated after publishing if needed) at the following link:

https://github.com/markjprice/cs13net9/blob/main/docs/code-editors/vs.md

If you want to see similar instructions for using Rider, they are available in the GitHub repository at the following link:

https://github.com/markjprice/cs13net9/blob/main/docs/code-editors/rider.md

Writing code using Visual Studio

Let’s get started writing code:

1. Start Visual Studio.
2. In the Create a new project dialog, select the C# language to filter the project templates, enter console in the Search for templates box, and then select Console App.

3. Click Next.
4. In the Configure your new project dialog, enter HelloCS for the project name, C:\cs13net9 for the location, and Chapter01 for the solution name.

5. Click Next.
6. In the Additional information dialog, in the Framework drop-down list, note that your .NET SDK choices indicate if that version is Standard Term Support, Long Term Support, Preview, or Out of support, and then select .NET 9.0 (Standard Term Support).

7. Leave the checkbox labeled Do not use top-level statements clear. (Later in this chapter, you will create a console app that selects this option, so you will see the difference.)
8. Leave the checkbox labeled Enable native AOT publish clear. You will learn what this option does in Chapter 7, Packaging and Distributing .NET Types.
9. Click Create.
10. If you cannot see Solution Explorer, then navigate to View | Solution Explorer.
11. If code is not shown, then in Solution Explorer, double-click the file named Program.cs to open it, and note that Solution Explorer shows the HelloCS project, as shown in Figure 1.4:

Figure 1.4: Editing Program.cs in Visual Studio

12. In Program.cs, note that the code consists of only a comment and a single statement, as shown in the following code:

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

    This template uses the top-level program feature introduced in C# 9, which I will explain later in this chapter. As the comment in the code says, you can read more about this template at the following link: https://aka.ms/new-console-template.

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

    All code examples and commands that you must review or type are shown in plain text, so you will never have to read code or commands from a screenshot, like in Figure 1.4, which might be too small or too faint in print.

Compiling and running code using Visual Studio

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

Figure 1.5: Running the console app on Windows

3. Press any key to close the console app window and return to Visual Studio.
4. Optionally, close the Properties pane to make more vertical space for Solution Explorer.
5. Double-click the HelloCS project, and note that the HelloCS.csproj project file shows that this project has its target framework set to net9.0, as shown in Figure 1.6.
6. 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.6:

Figure 1.6: Showing the compiler-generated folders and files

Understanding the compiler-generated folders and files

Two compiler-generated folders were created, named obj and bin, as described in the following list:

• 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 do not need to look inside these folders or understand their files yet (but feel free to browse around if you are curious).

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 will be automatically recreated the next time you “build” or run the project. Developers often delete these temporary folders and files 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 the CLI is dotnet clean.

Understanding top-level programs

If you have seen older .NET projects before, then you might have expected more code, even just to output a simple message. This project has minimal statements because some of the required code is written for you by the compiler when you target .NET 6 or later.

If you had created the project with .NET SDK 5 or earlier, or if you had selected the checkbox labeled Do not use top-level statements, then the Program.cs file would have more statements, as shown in the following code:

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

During compilation with .NET SDK 6 or later, all the boilerplate code to define the Program class and its Main method is generated and wrapped around the statements you write.

This uses a feature introduced in .NET 5 called top-level programs, but it was not until .NET 6 that Microsoft updated the project template for console apps to use top-level statements by default. Then, in .NET 7 and later, Microsoft added options to use the older style if you prefer:

• If you are using Visual Studio, select the checkbox labeled Do not use top-level statements.
• If you are using the dotnet CLI at the command prompt, add a switch:

  dotnet new console --use-program-main
  

Requirements for top-level programs

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

• There can be only one file like the file you use for top-level program code in a project.
• Any using statements must be at the top of the file.
• If you declare any classes or other types, they must be at the bottom of the file.
• Although you should name the entry-point method Main if you explicitly define it, the method is named <Main>$ when created by the compiler.

Implicitly imported namespaces

The using System; statement at the top of the file imports the System namespace. This enables the Console.WriteLine statement to work. But why do we not have to import it in our project?

The trick is that we still need to import the System namespace, but it is now done for us using a combination of features introduced in C# 10 and .NET 6. Let’s see how:

1. In Solution Explorer, expand the obj, Debug, and net9.0 folders, and open the file named HelloCS.GlobalUsings.g.cs.
2. Note that this file is automatically created by the compiler for projects that target .NET 6 or later and uses a feature introduced in C# 10, called global namespace imports, which 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;
   

3. In Solution Explorer, click the Show All Files button to hide the bin and obj folders.

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

Revealing the hidden code by throwing an exception

Now let’s discover how the hidden code has been written:

1. In Program.cs, after the statement that outputs the message, add a statement to throw a new exception, as shown in the following code:

   throw new Exception();
   

2. In Visual Studio, navigate to Debug | Start Without Debugging. (Do not start the project with debugging, or the exception will be caught by the debugger!)
3. The output in the console window will show the result of running your application, including that a hidden Program class was defined by the compiler, with a method named <Main>$ that has a parameter named args to pass in arguments, as shown in Figure 1.7 and the following output:

   Hello, C#!
   Unhandled exception. System.Exception: Exception of type 'System.Exception' was thrown.
      at Program.<Main>$(String[] args) in C:\cs13net9\Chapter01\HelloCS\Program.cs:line 3
   

Figure 1.7: Throwing an exception to reveal the hidden Program.<Main>$ method

4. Press any key to close the console app window and return to Visual Studio.

Revealing the namespace for the Program class

Now, let’s discover what namespace the Program class has been defined within:

1. In Program.cs, before the statement that throws an exception, add statements to get the name of the namespace of the Program class, and then write it to the console, as shown in the following code:

   string name = typeof(Program).Namespace ?? "<null>";
   Console.WriteLine($"Namespace: {name}");
   

2. In Visual Studio, navigate to Debug | Start Without Debugging.
3. The output in the console window will show the result of running your application, including that the hidden Program class was defined without a namespace, as shown in the following output:

   Namespace: <null>
   

4. Press any key to close the console app window and return to Visual Studio.

Adding a second project using Visual Studio

Let’s add a second project to our solution to explore how to work with multiple projects:

1. In Visual Studio, navigate to File | Add | New Project….

   Warning! The above step adds a new project to the existing solution. Do NOT navigate to File | New | Project…, which instead is meant to be used to create a new project and solution (although the dialog box has a dropdown to choose to add to an existing solution too).

2. In the Add a new project dialog, in Recent project templates, select Console App [C#], and then click Next.
3. In the Configure your new project dialog, for Project name, enter AboutMyEnvironment, leave the location as C:\cs13net9\Chapter01, and then click Next.
4. In the Additional information dialog, select .NET 9.0 (Standard Term Support) and select the Do not use top-level statements checkbox.

5. Click Create.
6. In the AboutMyEnvironment project, in Program.cs, note the statements to define a namespace that matches the project name, an internal class named Program, and a static method named Main with a parameter named args that returns nothing (void), as shown in the following code:

   namespace AboutMyEnvironment
   {
     internal class Program
     {
       static void Main(string[] args)
       {
         Console.WriteLine("Hello, World!");
       }
     }
   }
   

7. In Program.cs, in the Main method, replace the existing Console.WriteLine statement with statements to output the current directory, the version of the operating system, and the namespace of the Program class, as shown in the following code:

   Console.WriteLine(Environment.CurrentDirectory);
   Console.WriteLine(Environment.OSVersion.VersionString);
   Console.WriteLine("Namespace: {0}",
     typeof(Program).Namespace ?? "<null>");
   

8. In Solution Explorer, right-click the Chapter01 solution, and then select Configure Startup Projects….
9. In the Solution ‘Chapter01’ Property Pages dialog box, set Startup Project to Current selection, and then click OK.
10. In Solution Explorer, click the AboutMyEnvironment project (or any file or folder within it), and note that Visual Studio indicates that AboutMyEnvironment is now the startup project by making the project name bold.

11. Navigate to Debug | Start Without Debugging to run the AboutMyEnvironment project, and note the result, as shown in the following output and Figure 1.8:

    C:\cs13net9\Chapter01\AboutMyEnvironment\bin\Debug\net9.0
    Microsoft Windows NT 10.0.26100.0
    Namespace: AboutMyEnvironment
    

Figure 1.8: Running a console app in a Visual Studio solution with two projects

12. Press any key to close the console app window and return to Visual Studio.

    When Visual Studio runs a console app, it executes it from the <projectname>\bin\Debug\net9.0 folder. It will be important to remember this when we work with the filesystem in later chapters. When using VS Code, or more accurately, the dotnet CLI, it has different behavior, as you are about to see.

The goal of this section is to showcase how to build a console app using VS Code and the dotnet CLI.

If you never want to try VS Code or the dotnet command-line tool, then please feel free to skip this section, and then continue with the Making good use of the GitHub repository for this book section.

Both the instructions and screenshots in this section are for Windows, but the same actions will work with VS 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, macOS, and Linux. Luckily, the dotnet CLI tool itself and its commands are identical on all platforms.

Writing code using VS Code

Let’s get started writing code!

1. Start your favorite tool for working with the filesystem, for example, File Explorer on Windows or Finder on Mac.
2. Navigate to your C: drive on Windows, your user folder on macOS or Linux (mine are named markjprice and home/markjprice), or any directory or drive in which you want to save your projects.
3. Create a new folder named cs13net9. (If you completed the section for Visual Studio, then this folder will already exist.)
4. In the cs13net9 folder, create a new folder named Chapter01-vscode.

5. In the Chapter01-vscode folder, open the command prompt or terminal. For example, on Windows, right-click on the folder and then select Open in Terminal.
6. At the command prompt or terminal, use the dotnet CLI to create a new solution named Chapter01, as shown in the following command:

   dotnet new sln --name Chapter01
   

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

   The template "Solution File" was created successfully.
   

8. At the command prompt or terminal, use the dotnet CLI to create a new subfolder and project for a console app named HelloCS, as shown in the following command:

   dotnet new console --output HelloCS
   

9. At the command prompt or terminal, use the dotnet CLI to add the project to the solution, as shown in the following command:

   dotnet sln add HelloCS
   

10. Note the results, as shown in the following output:

    Project `HelloCS\HelloCS.csproj` added to the solution.
    

11. At the command prompt or terminal, start VS Code and open the current folder, indicated with a . (dot), as shown in the following command:

    code .
    

12. If you are prompted with Do you trust the authors of the files in this folder?, select the Trust the authors of all files in the parent folder ‘cs13net9’ checkbox, and then click Yes, I trust the authors.
13. In VS Code, in EXPLORER, in the CHAPTER01-VSCODE folder view, expand the HelloCS folder, and you will see that the dotnet command-line tool created two files, HelloCS.csproj and Program.cs, and the bin and obj folders, as shown in Figure 1.9:

Figure 1.9: EXPLORER shows that two files and temporary folders have been created

14. Navigate to View | Output.
15. In the OUTPUT pane, select C# Dev Kit, and note that the tool has recognized and processed the solution.
16. At the bottom of EXPLORER, note SOLUTION EXPLORER.
17. Drag SOLUTION EXPLORER to the top of the EXPLORER pane and expand it.
18. In SOLUTION EXPLORER, expand the HelloCS project, and then click the file named Program.cs to open it in the editor window.
19. In Program.cs, modify line 2 so that the text that is being written to the console says Hello, C#!.

In the preceding steps, I showed you how to use the dotnet CLI to create solutions and projects. Finally, with the August 2024 or later releases of the C# Dev Kit, VS Code has an improved project creation experience that provides you access to the same options you can use when creating a new project through the dotnet CLI.

To enable this ability, you must change a setting, as shown in the following configuration:

"csharp.experimental.dotnetNewIntegration": true

In VS Code, navigate to File | Preferences | Settings, search for dotnet new, and then select the Csharp > Experimental: Dotnet New Integration checkbox.

You can learn more at the following link:

https://devblogs.microsoft.com/dotnet/whats-new-in-csharp-dev-kit-august-2024/#create-new-project-configuration-options

Compiling and running code using the dotnet CLI

The next task is to compile and run the code:

1. In SOLUTION EXPLORER, right-click on any file in the HelloCS project and choose Open In Integrated Terminal.
2. In TERMINAL, enter the following command: dotnet run.
3. The output in the TERMINAL window will show the result of running your application.
4. In Program.cs, after the statement that outputs the message, add statements to get the name of the namespace of the Program class, write it to the console, and then throw a new exception, as shown in the following code:

   string name = typeof(Program).Namespace ?? "<null>";
   Console.WriteLine($"Namespace: {name}");
   throw new Exception();
   

5. In TERMINAL, enter the following command: dotnet run.

6. The output in the TERMINAL window will show the result of running your application, including that a hidden Program class was defined by the compiler, with a method named <Main>$ that has a parameter named args to pass in arguments, and that it does not have a namespace, as shown in the following output:

   Hello, C#!
   Namespace: <null>
   Unhandled exception. System.Exception: Exception of type 'System.Exception' was thrown.
      at Program.<Main>$(String[] args) in C:\cs13net9\Chapter01-vscode\HelloCS\Program.cs:line 7
   

Adding a second project using VS Code

Let’s add a second project to explore how to work with multiple projects:

1. In TERMINAL, change to the Chapter01-vscode directory, as shown in the following command:

   cd ..
   

2. In TERMINAL, create a new console app project named AboutMyEnvironment, using the older non-top-level program style, as shown in the following command:

   dotnet new console -o AboutMyEnvironment --use-program-main
   

3. In TERMINAL, use the dotnet CLI to add the new project folder to the solution, as shown in the following command:

   dotnet sln add AboutMyEnvironment
   

4. Note the results, as shown in the following output:

   Project `AboutMyEnvironment\AboutMyEnvironment.csproj` added to the solution.
   

5. In SOLUTION EXPLORER, in the AboutMyEnvironment project, open Program.cs, and then in the Main method, change the existing statement to output the current directory, the operating system version string, and the namespace of the Program class, as shown in the following code:

   Console.WriteLine(Environment.CurrentDirectory);
   Console.WriteLine(Environment.OSVersion.VersionString);
   Console.WriteLine("Namespace: {0}",
     typeof(Program).Namespace ?? "<null>");
   

6. In SOLUTION EXPLORER, right-click on any file in the AboutMyEnvironment project and choose Open In Integrated Terminal.
7. In TERMINAL, enter the command to run the project, as shown in the following command: dotnet run.
8. Note the output in the TERMINAL window, as shown in the following output:

   C:\cs13net9\Chapter01-vscode\AboutMyEnvironment
   Microsoft Windows NT 10.0.26100.0
   Namespace: AboutMyEnvironment
   

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

Unix 13.5.2

Summary of steps for VS Code

Follow these steps to create a solution and projects using VS Code, as shown in Table 1.5:

Table 1.5: Summary of steps to create a solution and projects using VS Code

Summary of other project types used in this book

A Console App / console project is just one type of project template. In this book, you will also create projects using the following project templates, as shown in Table 1.6:

Table 1.6: Project template names for various code editors

The steps for adding any type of new project to a solution are the same. Only the type name of the project template differs and, sometimes, some command-line switches to control options. I will always specify what those switches and options should be if they differ from the defaults.

A summary of project template defaults, options, and switches can be found here: https://github.com/markjprice/cs13net9/blob/main/docs/ch01-project-options.md.

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 optional sections about topics 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.

Understanding the solution code on GitHub

The solution code in the GitHub repository for this book includes folders for each chapter that can be opened with any of the following code editors:

• Visual Studio or Rider: Open the .sln solution file.
• VS Code: Open the folder that contains the solution file.

Chapters 1 to 11 each have their own solution file named ChapterXX.sln, where XX is the chapter number 01 to 11. Chapters 12 to 15 share a single solution file named ModernWeb.sln.

All the code solutions can be found at the following link:

https://github.com/markjprice/cs13net9/tree/main/code

Raising 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/cs13net9/issues.
2. Click New Issue.
3. Enter as much detail as possible that will help me to diagnose the issue. For example:
   • The specific section title, page number, and step number.
   • As much of your code and configuration that you feel is relevant and necessary.
   • A description of the expected behavior and the behavior experienced.
   • Screenshots (you can drag and drop image files into the Issue box).

The following is less relevant but might be useful:

• Your code editor, for example, Visual Studio, VS Code, Rider, or something else, including the version number.
• Your operating system, for example, Windows 11 64-bit or macOS Ventura version 13.5.2
• Your hardware, for example, Intel, Apple Silicon, or ARM CPU

I cannot always respond immediately to issues. But I want all my readers to find success with my book, so if I can help you (and others) without too much trouble, then I will gladly do so.

Giving me feedback

If you’d like to give me more general feedback about the book, then either email me at markjprice@gmail.com or ask me a question on Discord in the book channel. 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.

Please join me and your fellow readers on Discord using this invite: https://packt.link/csharp13dotnet9.

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.

Avoiding common mistakes

After working through the step-by-step tasks in this book, readers often then strike out on their own and attempt to write similar code, but sometimes, they hit problems and either raise an issue in the GitHub repository or post a question to the Discord channel for the book.

From these, I have noted some common mistakes, so I maintain a page in the repository to highlight and explain these potential traps and how to fix them:

https://github.com/markjprice/cs13net9/blob/main/docs/errata/common-mistakes.md

Downloading solution code from the GitHub repository

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

Figure 1.10: Downloading the repository as a ZIP file

Using Git with VS Code and the command prompt

VS Code has integrations with Git, but it will use your operating system’s Git installation, so you must install Git 2 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.

Cloning the book solution code repository

Let’s clone the book solution code repository. In the steps that follow, you will use the VS Code terminal, but you can 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. Open the Repos-vscode folder at the command prompt or terminal, and then enter the following command:

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

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

Microsoft Learn documentation and Ask Learn

The definitive resource for getting help with Microsoft developer tools and platforms is in the technical documentation on Microsoft Learn, and you can find it at the following link: https://learn.microsoft.com/en-us/docs.

“One of the most ambitious and impactful projects our engineers have built recently is Ask Learn, an API that provides generative AI capabilities to Microsoft Q&A.” - Bob Tabor, Microsoft’s Skilling organization

You can read about it at the following link:

https://devblogs.microsoft.com/engineering-at-microsoft/how-we-built-ask-learn-the-rag-based-knowledge-service/

Documentation links in this book

The official Microsoft documentation for .NET needs to cover all versions. The default version shown in the documentation is always the most recent GA version.

For example, between November 2024 and November 2025, the default version of .NET shown in the documentation pages will be for .NET 9. Between November 2025 and November 2026, the default version of .NET will be for .NET 10. The following link will automatically direct to the current version, depending on the current date:

https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.stringsyntaxattribute

After November 2025, to view the documentation page specifically for .NET 9, append ?view=net-9.0 to the end of a link. For example, use the following link:

https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.stringsyntaxattribute?view=net-9.0

All documentation links in this book do not specify a version. If you want to force the documentation to show the version for .NET 8 because you need to target an LTS version (three years) instead of .NET 9, which is an STS version (18 months), then append ?view=net-8.0 to the end of a link.

You can check what versions a .NET feature supports by appending #applies-to to the end of a link, for example:

https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.stringsyntaxattribute#applies-to

We can, therefore, see that the StringSyntax attribute is only available in .NET 7 or later.

Getting help from the dotnet tool

At the command prompt, you can ask the dotnet tool for help with its commands. The syntax is:

dotnet help <command>

This will cause your web browser to open a page in the documentation about the specified command. Common dotnet commands include new, build, run, and many more.

Another type of help is command-line documentation. It follows this syntax:

dotnet <command> -?|-h|--help

For example, dotnet new -? or dotnet new -h or dotnet new --help outputs documentation about the new command at the command prompt.

Let’s try some examples:

1. To open the official documentation in a web browser window for the dotnet build command, enter the following at the command prompt or in the VS Code terminal, and note the page opened in your web browser:

   dotnet help build
   

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

   dotnet build -?
   

3. You will see the following partial output:

   Description:
     .NET Builder
   Usage:
     dotnet build [<PROJECT | SOLUTION>...] [options]
   Arguments:
     <PROJECT | SOLUTION>  The project or solution file to operate on. If a file is not specified, the command will search the current directory for one.
   Options:
     --ucr, --use-current-runtime         Use current runtime as the target runtime.
     -f, --framework <FRAMEWORK>          The target framework to build for. The target framework must also be specified in the project file.
   ...
     -?, -h, --help                       Show command line help.
   

4. Repeat both types of help requests for the following commands: add, help, list, new, and run, remembering that new might not show its web page, due to a bug introduced in .NET 7.

Getting definitions of types and their members

One of the most useful features of a code editor is Go To Definition (F12). It is available in VS Code, Visual Studio, and Rider. 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 the metadata and IL code back into C# or another language for you.

A similar and related feature is named Go To Implementation (Ctrl + F12). Instead of reading the metadata or decompiling, this will show the actual source code if that is embedded, using the optional source link feature.

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

1. In your preferred code editor, open the solution/folder named Chapter01.

If you are using Visual Studio:

• Navigate to Tools | Options.
• In the search box, enter navigation to source.
• Select Text Editor | C# | Advanced.
• Clear the Enable navigation to Source Link and Embedded sources checkbox, and then click OK, as shown in Figure 1.11:

Figure 1.11: Disabling Source Link for the Go To Definition feature

2. In the HelloCS project, at the bottom of Program.cs, enter the following statement to declare an integer variable named z:

   int z;
   

3. Click on int, right-click on int, and then choose Go To Definition in Visual Studio or VS Code. In Rider, choose Go to | Go to Declaration or Usages.
4. In the code window that appears, you can see how the int data type is defined, as shown in the following code:

   #region Assembly System.Runtime, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
   // C:\Program Files\dotnet\packs\Microsoft.NETCore.App.Ref\9.0.0\ref\net9.0\System.Runtime.dll
   #endregion
   #nullable enable
   using System.Diagnostics.CodeAnalysis;
   using System.Globalization;
   using System.Numerics;
   using System.Runtime.CompilerServices;
   namespace System
   {
     public readonly struct Int32 : IComparable,
       IComparable<Int32>, IConvertible, ...
     {
       public const Int32 MaxValue = 2147483647;
       public const Int32 MinValue = -2147483648;
       ...
     }
   }
   

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 (2147483647) and minimum (-2147483648) values.
• Has methods such as Parse (not visible in the preceding code).

5. In the code editor window, scroll down to find the Parse method with a single string parameter, as shown in the following code:

   public static Int32 Parse(string s)
   

6. Expand the code and review the comments that document this method, as shown in Figure 1.12:

Figure 1.12: The comments for the Parse method with a single 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.

Configuring inline aka inlay hints

Throughout the code in this book, when calling a method, I often explicitly specify named parameters to help you learn what is going on. For example, I have specified the names of the parameters format and arg0 in the following code:

Console.WriteLine(format: "Value is {0}.", arg0: 19.8);

Inline hints, aka inlay hints, show the names of parameters without you having to type them, as shown in Figure 1.13:

Figure 1.13: Configuring inline hints, aka inlay hints

Most code editors have this feature, which you can enable permanently or only when a key combination like Alt + F1 or Ctrl is held down:

• In Visual Studio, navigate to Tools | Options, then Text Editor | C# | Advanced, scroll down to the Inline Hints section, select the Display inline parameter name hints checkbox, and then click OK.
• In VS Code, navigate to File | Preferences | Settings, search for inlay, select the C# filter, and then select the Display inline parameter name hints checkbox.
• In Rider, in Settings, navigate to Editor | Inlay Hints | C# | Parameter Name Hints.

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.

Looking for answers on Stack Overflow

Stack Overflow is the most popular third-party website for getting answers to difficult programming questions. Let’s see an example:

1. Start your favorite web browser.
2. Navigate to stackoverflow.com; in the search box, enter securestring and note the search results.

Searching for answers using Google

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

1. Navigate to Google at the following link: https://www.google.com/.
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, 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
   

Getting help on Discord and other chat forums

Asking questions in programming forums and Discord channels is an art as much as it is a science. To maximize your chances of receiving a helpful answer, there’s a blend of clarity, specificity, and community awareness that you should aim for.

Here are some tips for asking questions:

• Ask in a public channel, not in private. Please do not direct message an author with a question or a friend request. Remember, every question asked and answered builds the collective knowledge and resourcefulness of the whole community. Asking in public also allows other readers to help you, not just the author. The community that Packt and I have built around my books is friendly and smart. Let us all help you.
• Research before asking: It’s important to look for answers yourself before turning to the community. Use search engines, official documentation, and the search function within the forum or Discord server. This not only respects the community’s time but also helps you learn more effectively. Another place to look first is the errata and improvements section of the book, found at the following link: https://github.com/markjprice/cs13net9/blob/main/docs/errata/README.md.
• Be specific and concise: Clearly state what you’re trying to achieve, what you’ve tried so far, and where you’re stuck. A concise question is more likely to get a quick response.
• Specify the book location: If you are stuck on a particular part of the book, specify the page number and section title so that others can look up the context of your question.
• Show your work: Demonstrating that you’ve made an effort to solve the problem yourself not only provides context but also helps others understand your thought process and where you might have gone down a wrong path.
• Prepare your question: Avoid too broad or vague questions. Screenshots of errors or code snippets (with proper formatting) can be very helpful.

  Oddly, I’ve been seeing more and more examples of readers taking photos of their screens and posting those. These are harder to read and limited in what they can show. It’s better to copy and paste the text of your code or the error message so that others can copy and paste it themselves. Alternatively, at least take a high-resolution screenshot instead of a photo with your phone camera at a jaunty angle!

• Format your code properly: Most forums and Discord servers support code formatting using Markdown syntax. Use formatting to make your code more readable. For example, surround code keywords in single backticks, like `public void`, and surround code blocks with three backticks with optional language code, as shown in the following code:

  ```cs
  using static System.Console;
  WriteLine("This is C# formatted code.");
  ```
  

  Good Practice: After the three backticks that start a code block in Markdown, specify a language short name like cs, csharp, js, javascript, json, html, css, cpp, xml, mermaid, python, java, ruby, go, sql, bash, or shell.

• Be polite and patient: Remember, you’re asking for help from people who are giving their time voluntarily. A polite tone and patience while waiting for a response go a long way. Channel participants are often in a different time zone, so you may not see your question answered until the next day.
• Be ready to actively participate: After asking your question, stay engaged. You might receive follow-up questions for clarification. Responding promptly and clearly can significantly increase your chances of getting a helpful answer. When I ask a question, I set an alarm for three hours later to go back and see if anyone has responded. If there hasn’t been a response yet, then I set another alarm for 24 hours later.

Incorporating these approaches when asking questions not only increases your likelihood of getting a useful response but also contributes positively to the community, by showing respect for others’ time and effort.

Searching the .NET source code

Sometimes, you can learn a lot from seeing how the Microsoft teams have implemented .NET. The source for the entire code base for .NET is available in public GitHub repositories. For example, you might know that there is a built-in attribute to validate an email address.

Let’s search the repositories for the word “email” and see if we can find out how it works:

1. Use your preferred web browser to navigate to https://github.com/search.
2. Click advanced search.
3. In the search box, type email.
4. In the In these respositories box, type dotnet/runtime. (Other repositories that you might want to search include dotnet/core, dotnet/aspnetcore, dotnet/wpf, and dotnet/winforms.)
5. In the Written in this language box, select C#.
6. At the top right of the page, note how the advanced query has been written for you. Click Search, then the Code filter, and note that the results include EmailAddressAttribute, as shown in Figure 1.14:

Figure 1.14: Advanced search for email in the dotnet/runtime repository

7. Click the source file, and note that it implements email validation by checking that the string value contains an @ symbol but not as the first or last character, as shown in the following code:

   // only return true if there is only 1 '@' character
   // and it is neither the first nor the last character
   int index = valueAsString.IndexOf('@');
   return
       index > 0 &&
       index != valueAsString.Length - 1 &&
       index == valueAsString.LastIndexOf('@');
   

8. Close the browser.

Source code in documentation

When you read API reference documentation, you often want to review the actual source code. For .NET APIs that have Source Link enabled, have an accessible PDB, and are hosted in a public GitHub repository, links to source code are included in the definition metadata. For example, the String class documentation page now has this new Source link, and its IndexOf method has a Source link to another of its source files, as shown in Figure 1.15:

Figure 1.15: Documentation with links to source files

Official .NET blog, standups, and news

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

To watch .NET team members walk through previews of new features, you can watch monthly “standups,” available at the following link:

https://dotnet.microsoft.com/en-us/live/community-standup

You can subscribe to the latest .NET news at the following link:

https://github.com/dotnet/core/discussions/categories/news

Watching Scott Hanselman’s videos

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

I recommend it to everyone working with computers.

AI tools like ChatGPT and GitHub Copilot

One of the biggest changes in coding and development in the past few years is the emergence of generative artificial intelligence (AI) tools that can help with coding tasks, like completing a code statement, implementing an entire function, writing unit tests, and suggesting debugging fixes for existing code.

You can read what developers say about AI tools in the 2023 Stack Overflow Developer Survey: “44% of them use AI tools in their development process now, and 26% plan to soon” (https://stackoverflow.blog/2023/06/14/hype-or-not-developers-have-something-to-say-about-ai/):

“From research to debugging to documentation, developers are using Generative AI to save time doing various tedious tasks at work. The biggest use case is writing code. This was how 82.55% of developers reported using Generative AI in the recent Stack Overflow Developer Survey.”

ChatGPT currently has several models for individuals: 4o mini (free), 4o (free but limited), and 4o with 5x more requests and other benefits, like early access to new features and DALL·E image generation ($20 per month). It also has pricing for enterprises. You can check their pricing at the following link: https://openai.com/chatgpt/pricing/.

ChatGPT example

Let’s say you need to write a C# function to validate an email address. You might go to ChatGPT and enter the following prompt:

write a c# function to validate an email address

It responds with a complete class with methods, as shown in Figure 1.16:

Figure 1.16: ChatGPT writes a function to validate an email address

It then provides an explanation of the code and examples of how to call the function, as shown in the following code:

bool isValid = EmailValidator.IsValidEmail("test@example.com");
Console.WriteLine(isValid ? "Valid" : "Invalid");

But is a general-purpose generative AI like ChatGPT the best partner for a C# programmer?

GitHub Copilot for programmers

Microsoft has a service specifically for programmers, named GitHub Copilot, that can help autocomplete code directly in your code editor. It has plugins for code editors, including Visual Studio, VS Code, and JetBrains IntelliJ-based IDEs.

GitHub Copilot is free for students, teachers, and some open-source project maintainers. For everyone else, it has a 30-day free trial, and then it costs $10 per month or $100 per year for individuals. Once you have an account, you can then sign up for waiting lists to get the more advanced experimental GitHub Copilot features.

You should check online which Copilot features are available for various code editors. As you can imagine, this is a fast-changing world, and some of what I might write in the book today will be out of date by the time you read it: https://github.com/features/copilot.

So what can GitHub Copilot do for you today?

Imagine that you have just added a new class file named Product.cs. You click inside the Product class, press Enter to insert a blank line, and then pause for a second as you think about what you need to type… and then GitHub Copilot generates some sample code in gray, as shown in Figure 1.17:

Figure 1.17: GitHub Copilot suggesting how to define a Product class

At this point, you can glance over the code and, if it is close to what you want, just press Tab to insert it all, or press Alt + . (dot) to toggle between other suggestions.

Sometimes, it is too far from what you need, and you’d be better off ignoring its suggestion completely and just writing it yourself. But usually, there’s something there that’s usable or reminds you of the syntax you need to use. And sometimes, it feels like magic, writing dozens of lines of exactly what you need.

Microsoft feeds its AI tools with code from public GitHub repositories, including all the repositories I have created since 2016 for all the editions of this book. This means that it can suggest code completions for the readers of this book that are surprisingly accurate predictions, including my frequent use of pop culture references in my code. It’s like I, Mark J. Price, am the “ghost in the machine” guiding your coding.

It’s easy to imagine a custom ChatGPT that has ingested all the official Microsoft .NET documentation, every public blog article written about .NET, and perhaps even hundreds of books about .NET, and then having a conversation with it to find a bug or suggest how to solve a programming problem.

Here are some more links about using AI for coding:

• A Beginner’s Guide to Prompt Engineering with GitHub Copilot: https://dev.to/github/a-beginners-guide-to-prompt-engineering-with-github-copilot-3ibp
• The Register article about AI: https://www.theregister.com/2024/01/27/ai_coding_automatic/
• StackOverflow 2024 survey – Code editor / IDE: https://survey.stackoverflow.co/2024/technology#1-integrated-development-environment
• StackOverflow 2024 survey – AI search tools: https://survey.stackoverflow.co/2024/technology#1-ai-search-and-developer-tools

Disabling tools when they get in the way

Although these tools can be helpful, they can also get in your way, especially when learning, because they sometimes do work for you without telling you. If you do not do that work for yourself at least a few times, you won’t learn fully.

To configure IntelliSense for C# in Visual Studio:

1. Navigate to Tools | Options.
2. In the Options dialog box tree view, navigate to Text Editor | C# | IntelliSense.
3. Click the ? button in the caption bar to view the documentation.

To configure GitHub Copilot in Visual Studio:

1. Navigate to Tools | Options.
2. In the Options dialog box tree view, navigate to GitHub | Copilot.
3. Set Enable Globally to True or False, and then click OK.

To disable GitHub Copilot in VS Code:

1. In the status bar, on the right, to the left of the notification icon, click the GitHub Copilot icon.
2. In the popup, click Disable Globally.
3. To enable it, click the GitHub Copilot icon again and then click Enable Globally.

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.

Exercise 1.1 – Online material

Online material can be extra content written by me for this book, or it can be references to content created by Microsoft or third parties.

Current versions of .NET

You can check what the latest version of .NET is for various platforms and what is officially supported at the following link: https://versionsof.net.

If you need to know more about support for the legacy .NET Framework, you can read about it at the following link: https://learn.microsoft.com/en-us/lifecycle/products/microsoft-net-framework.

Upgrade to a new .NET version

.NET releases new versions annually. Some developers begin upgrading as soon as a new version drops, while others prefer to wait until their current version reaches end-of-support. Upgrading involves several important considerations that you can read about at the following link:

https://learn.microsoft.com/en-us/dotnet/core/install/upgrade

freeCodeCamp and C# certification

For many years, Microsoft had an exam for C# 5, Exam 70-483: Programming in C#. I taught hundreds of developers the skills needed to get qualified and pass it. Sadly, that exam was retired a few years ago.

In August 2023, Microsoft announced a new foundational certification for C# alongside a free 35-hour online course. You can read more about how to qualify for the certification at the following link:

https://www.freecodecamp.org/learn/foundational-c-sharp-with-microsoft/

C# certification signup: https://aka.ms/learningseries/csharp/signup

Explore Polyglot Notebooks

Complete the following online-only section to explore how you can use Polyglot Notebooks with its .NET Interactive engine:

https://github.com/markjprice/cs13net9/blob/main/docs/ch01-polyglot-notebooks.md

Windows development

This book is about modern cross-platform development. But what about graphical user interface (GUI) development especially for Windows?

You can read an article discussing this at the following link:

https://visualstudiomagazine.com/articles/2024/02/13/desktop-dev.aspx

C# versus other languages

Even Microsoft does not use C# and .NET for all its own development needs. You can read an interesting discussion about C# and Rust at the following link:

https://www.reddit.com/r/dotnet/comments/1aezqmg/comment/ko8lnf2/

The key quote at the preceding Reddit link is this:

“There’s been a lot of hype around Rust, and for good reason. But it’s a system language. It’s not like Microsoft is about to go rewrite millions and millions of lines of code and toss out C# (for anyone getting nervous ). They’re just being pragmatic and using an effective tool for the job.”

Free computer science course

Harvard CS50: Introduction to Computer Science: https://pll.harvard.edu/course/cs50-introduction-computer-science

.NET newsletters

There are email newsletters that you can subscribe to get daily or weekly updates, hints, and tips. Some of the better ones include the following:

• Milan Jovanovic’s The .NET Weekly: https://www.milanjovanovic.tech/blog
• C# Digest: https://csharpdigest.net/
• Alvin Ashcraft’s The Morning Dew: https://www.alvinashcraft.com/
• Mukesh’s .NET Newsletter: https://newsletter.codewithmukesh.com/
• JetBrains’ dotInsights: https://www.jetbrains.com/lp/dotinsights-monthly/

Exercise 1.2 – Practice exercises

The following practice exercises will go deeper into the topics for this chapter.

Practice C# anywhere with a browser

You don’t need to download and install VS Code or even Visual Studio to write C#. You can start coding online at any of the following links:

• SharpLab: https://sharplab.io/
• C# Online Compiler | .NET Fiddle: https://dotnetfiddle.net/
• W3Schools C# Online Compiler: https://www.w3schools.com/cs/cs_compiler.php

Alpha versions of .NET

You can (but probably shouldn’t) download future versions of .NET, including alpha versions from the following link:

https://github.com/dotnet/sdk/blob/main/documentation/package-table.md

For more about using .NET 10 with this book, please see the following link: https://github.com/markjprice/cs13net9/blob/main/docs/dotnet10.md.

Exercise 1.3 – Test your knowledge

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 better than VS Code?
2. Are .NET 5 and later versions 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 a top-level program, and how do you access any command-line arguments?
6. What is the name of the entry point method of a .NET console app, and how should it be explicitly declared if you are not using the top-level program feature?
7. What namespace is the Program class defined in with a top-level program?
8. Where would you look for help for a C# keyword?
9. Where would you look first for solutions to common programming problems?
10. What should you do after getting AI to write code for you?

Exercise 1.4 – Explore topics

A printed book is a curated experience. I have tried to find the right balance of topics to include in this 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/cs13net9/blob/main/docs/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 in an online article.
• Used Visual Studio and VS Code with the .NET SDK CLI to create a couple of simple console apps, grouped in a solution.
• Learned how to download the solution code for this book from its GitHub repository.
• Learned how to find help. This could be in the traditional way, by using help command switches, documentation, and articles, or the modern way, by having a conversation with coding expert AI or using an AI-based tool to perform “grunt work.”

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

Learn more on Discord

To join the Discord community for this book – where you can share feedback, ask questions to the author, and learn about new releases – follow the QR code below:

https://packt.link/csharp13dotnet9

Leave a Review!

Thank you for purchasing this book from Packt Publishing—we hope you enjoy it! Your feedback is invaluable and helps us improve and grow. Once you’ve completed reading it, please take a moment to leave an Amazon review; it will only take a minute, but it makes a big difference for readers like you.

Scan the QR or visit the link to receive a free ebook of your choice.

https://packt.link/NzOWQ