I’ve been working hard on the latest edition of my book, ASP.NET Core in Action, Third Edition, working through the final review process. There’s a lot of new content in this edition, so we chose to remove one of the appendices from the book, trying to make sense of the .NET ecosystem. Rather than throw it away, I’ve turned it into a couple of posts here!

Although this post didn’t make it into the book, if you like what you see, take a look at ASP.NET Core in Action—for now you can even get a 35% discount by entering the code au35loc into the discount code box at checkout at manning.com. On top of that, you’ll also get ebook copies of the first and second editions, free!

This post covers:

• The history of .NET, leading to the development of .NET Core
• The position of .NET 7 in the .NET ecosystem

In the next post I’ll cover:

• Sharing code between projects with .NET Standard
• The future of .NET Standard with .NET 7

The .NET ecosystem has changed a lot since .NET was first introduced, but the development of .NET Core and .NET 5+ has resulted in a particularly large degree of churn and the introduction of many new concepts.

This churn isn’t surprising given Microsoft’s newfound transparency regarding the development process and building in the open on GitHub. Unfortunately, it can be confusing for developers new to .NET, and even to seasoned veterans! In this post, I’ll try to straighten out some of the terms that developers new to .NET often find confusing, as well as provide some context for the changes.

In this post I’ll discuss the history of the .NET ecosystem, how it has evolved, and the issues Microsoft were attempting to solve. As part of this, I’ll discuss the similarities and differences between .NET 7, .NET Core, and .NET Framework.

.NET Core wasn’t developed in isolation, and one of its primary design goals was to improve the ability to share code between multiple frameworks. In the next post I’ll describe how this was achieved in pre-.NET Core days, using Portable Class Libraries (PCLs) and the successor approach using .NET Standard. Finally, in the next post, I’ll discuss what .NET 7 means for .NET Standard.

Exploring the .NET platforms that prompted .NET Core

If you’re a .NET developer, chances are you’re already familiar with the .NET Framework. The .NET Framework, version 4.8.1 at the time of writing, is a Windows-only development platform that you can use for both desktop and web development. It’s installed by default on Windows and was historically used for most desktop and server .NET development.

If you’re a mobile developer, you might also be familiar with the Xamarin framework, which uses the cross-platform Mono implementation of the .NET Framework. This is an alternative platform to the .NET Framework that you can use to build mobile applications on Windows, Android, and iOS.

Historically, these two platforms were completely separate, but they consisted of many similar components and implemented similar APIs. Each platform contained libraries and app models specific to their platform, but they used similar fundamental libraries and types, as shown in figure 1.

At the bottom of each stack is the tooling that allows you to compile and run .NET applications, such as the compiler and the common language runtime (CLR). At the top of each stack, you have the app-specific libraries that you use to build applications for your platform. For example, you could build a Windows Forms app on the .NET Framework, but not using the Xamarin platform, and vice versa for an iOS app.

In the middle of each stack you have the Base Class Libraries (BCLs). These are the fundamental .NET types you use in your apps on a daily basis: the int and string types, the file-reading APIs, the Task APIs, and so on. Although both .NET platforms have many similar types, they’re fundamentally different, so you can’t guarantee a type will exist on both platforms, or that it will expose the same methods and properties.

I’ve only discussed two platforms so far, the .NET Framework and Xamarin, but .NET has many different implementations. Windows also had the Windows 8/8.1 platform and the Universal Windows Platform (UWP). On phones, in addition to Xamarin, there was the Windows Phone 8.1 and Silverlight Phone platforms. The list goes on and on (Unity, .NET Compact Framework (CF), .NET Micro…)!

Each of these platforms uses a slightly different set of APIs (classes and methods) in their BCLs. Platforms have a certain number of similar APIs between them in their BCLs, but the intersection is patchy. On top of that, the