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 Code
• Visual Studio 2019
• Visual Studio 2019 for Mac

Using Visual Studio Code for cross-platform development

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

Using Visual Studio Code means a developer can use a cross-platform code editor to developer cross-platform apps. Therefore, I have chosen to use Visual Studio Code for all but the last two chapters for this book, because they need special features not available in Visual Studio Code for building Windows and mobile apps.

If you prefer to use Visual Studio 2019 or Visual Studio for Mac instead of Visual Studio Code, then of course you can, but I will assume that you are already familiar with how to use them and so I will not give step-by-step instructions for using them in this book.

Using Visual Studio 2019 for Windows app development

Microsoft Visual Studio 2019 only runs on Windows, version 7 SP1 or later. You must run it on Windows 10 to create Universal Windows Platform (UWP) apps. It is the only Microsoft developer tool that can create Windows apps, so we will use it in Chapter 20, Building Windows Desktop Apps.

Using Visual Studio for Mac for mobile development

To create apps for the Apple operating systems like iOS to run on devices like iPhone and iPad, you must have Xcode, but that tool only runs on macOS. Although you can use Visual Studio 2019 on Windows with its Xamarin extensions to write a cross-platform mobile app, you still need macOS and Xcode to compile it.

So, we will use Visual Studio 2019 for Mac on macOS in Chapter 21, Building Cross-Platform Mobile Apps Using Xamarin.Forms.

Recommended tools for chapters

To help you to set up the best environment to use in this book, the following table summarizes which tools and operating systems I recommend be used for each of the chapters in this book:

To write this book, I used my MacBook Pro and the following listed software:

• Visual Studio Code on macOS as my primary code editor.
• Visual Studio Code on Windows 10 in a virtual machine to test OS-specific behavior like working with the filesystem.
• Visual Studio 2019 on Windows 10 in a virtual machine to build Windows apps.
• Visual Studio 2019 for Mac on macOS to build mobile apps.

Deploying cross-platform

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

.NET Core 3.0 supports the following platforms for deployment:

• Windows: Windows 7 SP1, or later. Windows 10 version 1607, or later. Windows Server 2012 R2 SP1, or later. Nano Server version 1803, or later.
• Mac: macOS High Sierra (version 10.13), or later.
• Linux: RHEL 6, or later. RHEL, CentOS, Oracle Linux version 7, or later. Ubuntu 16.04, or later. Fedora 29, or later. Debian 9, or later. openSUSE 15, or later.

Understanding Microsoft Visual Studio Code versions

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

• Version 1.38, August 2019 feature release.
• Version 1.38.1, August 2019 bug fix release.

The version used in this book is 1.38.1 released on 11 September 2019, but the version of Microsoft Visual Studio Code is less important than the version of the C# for Visual Studio Code extension that you will install 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. To support C# 8.0, you should install C# extension version 1.21.3 or later.

In this book, I will show keyboard shortcuts and screenshots of Visual Studio Code using the macOS version. Visual Studio Code on Windows and variants of Linux are practically identical, although keyboard shortcuts are likely different.

Some common keyboard shortcuts that we will use are shown in the following table:

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

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.

Downloading and installing Visual Studio Code

Now you are ready to download and install Visual Studio Code, its C# extension, and the .NET Core 3.0 SDK.

1. Download and install either the Stable build or the Insiders edition of Visual Studio Code from the following link: https://code.visualstudio.com/.
2. Download and install the .NET Core SDK from the following link: https://www.microsoft.com/net/download.
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, as shown in the following screenshot:

   

6. Click Install and wait for supporting packages to download and install.

Installing other extensions

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:

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

Understanding the .NET Framework

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

All of the apps on a computer written for the .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.

Understanding the Mono and Xamarin projects

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 2019. 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 apps. With Visual Studio 2019 for Mac, Microsoft has replaced parts of the Xamarin Studio editor with parts from Visual Studio for Windows to provide closer parity of experience and performance.

Understanding .NET Core

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 library of classes 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. Improvements that Microsoft can make to .NET Core cannot be added to .NET Framework.

Understanding future versions of .NET

At the Microsoft Build developer conference in May 2019, the .NET team announced that after .NET Core 3.0 is released in September 2019, .NET Core will be renamed .NET and the major version number will skip the number four to avoid confusion with .NET Framework 4.x. So, the next version of .NET Core will be .NET 5.0 and it is scheduled for release in November 2020. After that, Microsoft plans on annual major version releases every November, rather like Apple does major version number releases of iOS every second week in September.

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

I cannot promise 5th and 6th editions of this book to match future releases of .NET, but that would be a safe bet.

Understanding .NET Core support

.NET Core 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. .NET Core 3.1 will be an LTS release.

.NET Core 1.0 and 1.1 reached end of life and went out of support on 27 June 2019, 3 years after the initial .NET Core 1.0 release.

• 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 3-month maintenance period, the previous minor version will no longer be supported. For example, after 1.2 releases systems running version 1.1 will have 3 months to update to 1.2 to remain eligible for support. .NET Core 3.0 is a Current release so if .NET Core 3.1 releases in November 2019 as planned, then you will need to upgrade to it by February 2020.

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.

What is different about .NET Core?

.NET Core is smaller than the current version of .NET Framework due to the fact that legacy technologies have been removed. For example, 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 have been removed from .NET Core on macOS and Linux.

One of the new features of .NET Core 3.0 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.0 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 Core to take advantage of new features and performance improvements. You'll learn about support for building these types of Windows apps in Chapter 20, Building Windows Desktop Apps.

The latest technology used to build Windows apps is the Universal Windows Platform (UWP), which is built on a custom version of .NET Core. UWP is not part of .NET Core because it is not cross-platform.

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 .NET Core. Instead, developers prefer to use ASP.NET MVC and ASP.NET Web API. These two technologies have been refactored and combined into a new product that runs on .NET Core, named ASP.NET Core. You'll learn about the technologies in Chapter 15, Building Websites Using ASP.NET Core Razor Pages, Chapter 16, Building Websites Using the Model-View-Controller Pattern, and Chapter 18, Building and Consuming Web 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, will be given support for non-relational databases like Microsoft Azure Cosmos DB, and named Entity Framework Core. You will learn about it in Chapter 11, Working with Databases 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.

In addition to removing large pieces from .NET Framework in order to make .NET Core, Microsoft has componentized the .NET Core into NuGet packages, those being small chunks of functionality that can be deployed independently.

Microsoft's primary goal is not to make .NET Core smaller than .NET Framework. The goal is to componentize .NET Core to support modern technologies and to have fewer dependencies, so that deployment requires only those packages that your application needs.

Understanding .NET Standard

The situation with .NET in 2019 is that there are 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 has strengths and weaknesses because they are all designed for different scenarios. This has led to the problem that a developer must 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 can 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 makes it much easier for developers to share code between any flavor of .NET.

For .NET Core 2.0 and later, this added a number 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 Core. 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 the .NET Standard, you must install a .NET platform that implements the .NET Standard specification. .NET Standard 2.0 is implemented by the latest versions of .NET Framework, .NET Core, and Xamarin.

The latest .NET Standard, 2.1, is only 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.

.NET platforms and tools used by the book editions

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 multiple tools added unnecessary complexity.

In this fourth edition, we'll continue the trend by only showing coding examples using Visual Studio Code for all but the last two chapters of this book. In Chapter 20, Building Windows Desktop Apps, you'll need to use Visual Studio 2019 running on Windows 10, and in Chapter 21, Building Cross-Platform Mobile Apps Using Xamarin.Forms, you'll need to use Visual Studio 2019 for Mac.

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 Core'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 three-step compilation process is that Microsoft is able to create CLRs for Linux and macOS, as well as for Windows. The same IL code runs everywhere because of the second compilation process, 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 like the ILSpy .NET Decompiler extension.

Understanding .NET Native

Another .NET initiative is called .NET Native. This compiles C# code to native CPU instructions ahead of time (AoT), rather than using the CLR to compile IL code JIT to native code later. .NET Native improves execution speed and reduces the memory footprint for applications because the native code is generated at build time and then deployed instead of the IL code.

Comparing .NET technologies

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

By the end of 2020, Microsoft promises that there will be a single .NET platform instead of three. .NET 5.0 is planned to have a single BCL and two runtimes: one optimized for server or desktop scenarios like websites and Windows desktop apps based on the .NET Core runtime, and one optimized for mobile apps based on the Xamarin runtime.

The goal of this section is to showcase how to build a console app using Visual Studio Code. Both instructions and screenshots in this section are for macOS, but the same actions will work with Visual Studio Code on Windows 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.

Writing code using Visual Studio Code

Let's get started writing code!

1. Start Visual Studio Code.
2. On macOS, navigate to File | Open..., or press Cmd + O. On Windows, navigate to File | Open Folder…, or press Ctrl + K Ctrl + O. On both OSes, you can click the Open Folder button in the EXPLORER pane or click the Open Folder… link on the Welcome page, as shown in the following screenshot:

   

3. 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.
4. Click the New Folder button and name the folder Code.
5. In the Code folder, create a new folder named Chapter01.
6. In the Chapter01 folder, create a new folder named HelloCS.
7. Select the HelloCS folder and on macOS click Open or on Windows click Select Folder.
8. Navigate to View | Terminal, or on macOS press Ctrl + ` (backtick) and on Windows press Ctrl + ' (single quote). Confusingly on Windows the key combination Ctrl + ` (backtick) splits the current window!
9. In TERMINAL, enter the following command:

   dotnet new console

10. 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.proj and Program.cs, as shown in the following screenshot:

    

11. 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, the Razor Language Server, and the .NET Core debugger, if it did not do this when you installed the C# extension.
12. If you see a warning saying that required assets are missing, click Yes, as shown in the following screenshot:

    

13. After a few seconds, a folder named .vscode will appear in the EXPLORER pane. These are used during debugging, as you will learn in Chapter 4, Writing, Debugging, and Testing Functions.
14. In Program.cs, modify line 9 so that the text that is being written to the console says, Hello, C#!
15. Navigate to File | Auto Save. This toggle will save the annoyance of remembering to save before rebuilding your application each time.

Compiling and running code using dotnet CLI

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 the following screenshot:

   

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 recently purchased GitHub, so it will continue to get closer integration with Microsoft tools.

I used GitHub to store solutions to all the practical exercises that are featured at the end of each chapter. You will find the repository for this chapter at the following link: https://github.com/markjprice/cs8dotnetcore3.

Using Git with Visual Studio Code

Visual Studio Code has support for Git, but it will use your OS'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

Cloning the book solution code repository

Let's clone the book solution code repository.

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

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

4. Cloning all of the solutions for all of the chapters will take a minute or so, as shown in the following screenshot:

   

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

Reading Microsoft documentation

The definitive resource for getting help with Microsoft developer tools and platforms used to be Microsoft Developer Network (MSDN). Now, it is Microsoft Docs, and you can find it at the following link: https://docs.microsoft.com/.

Getting help for the dotnet tool

At the command line, you can ask the dotnet tool for help about 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 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:                                                     
     --langVersion  Sets langVersion in the created project file
                    text - Optional
     --no-restore   If specified, skips the automatic restore of the project on create.
                    bool - Optional
                    Default: false / (*) true
   * Indicates the value used if the switch is provided without a value.

Getting definitions of types and their members

One of the most useful keyboard shortcuts in Visual Studio Code is F12 to Go To Definition. This will show what the public definition of the type or member looks like by reading the metadata in the compiled assembly. Some tools like ILSpy .NET Decompiler will even reverse-engineer from the metadata and IL code back into C# for you.

1. In Visual Studio Code, open the HelloCS folder.
2. In Program.cs, inside the Main method, enter the following statement to declare an integer variable named z:

   int z;

3. Click inside int and then press F12, or right-click and choose Go To Definition. In the new code window that appears, you can see how the int data type is defined, as shown in the following screenshot:

   

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

     Good Practice: When you try to use Go To Definition you will sometimes see an error saying, No definition found. This is because the C# extension does not know about the current project. Navigate to View | Command Palette, enter and select OmniSharp: Select Project, and then select the correct 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 these terms mean.

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

4. In the code editor window, scroll down to find the Parse method with a single string parameter starting on line 86, as shown in the following screenshot:

   

In the comment, you will see that Microsoft has documented what exceptions might occur if you call this method, including ArgumentNullException, FormatException, and OverflowException. Now, we know that we need 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.

Looking for answers on Stack Overflow

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 the following screenshot:

   !so securestring

   

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.
2. Search for information about garbage collection using a simple Google query, and note that you will probably see a Wikipedia definition of garbage collection in computer science, and then a list of garbage collection services in your local area, as shown in the following screenshot:

   

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

Subscribing to the official .NET blog

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://blogs.msdn.microsoft.com/dotnet/

Let's now test your knowledge and understanding by trying to answer some questions, getting some hands-on practice, and exploring with deeper research into the topics covered throughout this chapter.

Exercise 1.1 – Test your knowledge

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

1. Why can a programmer use different languages, for example, C# and F#, to write applications that run on .NET Core?
2. What do you type at the prompt to create a console app?
3. What do you type at the prompt to build and execute C# source code?
4. What is the Visual Studio Code keyboard shortcut to view Terminal?
5. Is Visual Studio 2019 better than Visual Studio Code?
6. Is .NET Core better than .NET Framework?
7. What is .NET Standard and why is it important?
8. What is the name of the entry point method of a .NET console application and how should it be declared?
9. Where would you look for help about a C# keyword?
10. Where would you look for solutions to common programming problems?

Exercise 1.2 – Practice C# anywhere

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

Microsoft is also working on an online version of Visual Studio Code that can run in any browser but currently it is only available in private preview. Eventually, it will be accessible to everyone at the following link: https://online.visualstudio.com/

Exercise 1.3 – Explore topics

You can use the following links to read more details about the topics we've covered in this chapter:

• Welcome to .NET Core: http://dotnet.github.io
• .NET Core Command-Line Interface (CLI) tool: https://aka.ms/dotnet-cli-docs
• .NET Core runtime, CoreCLR: https://github.com/dotnet/coreclr/
• .NET Core Roadmap: https://github.com/dotnet/core/blob/master/roadmap.md
• .NET Standard FAQ: https://github.com/dotnet/standard/blob/master/docs/faq.md
• Stack Overflow: http://stackoverflow.com/
• Google Advanced Search: http://www.google.com/advanced_search
• Microsoft Virtual Academy: https://mva.microsoft.com/
• Microsoft Channel 9: Developer Videos: https://channel9.msdn.com/

In this chapter, we set up your development environment, discussed the differences between .NET Framework, .NET Core, Xamarin, and .NET Standard, we used Visual Studio Code and .NET Core SDK to create a simple console application, we learned how to download the solution code for this book from a GitHub repository, and most importantly, how to find help.

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