About .NET Core

.NET Core has the following characteristics:

  • Cross-platform: Runs on Windows, macOS and Linux operating systems.
  • Consistent across architecures: Runs your code with the same behavior on multiple architectures, including x64, x86, and ARM.
  • Command-line tools: Includes easy-to-use command-line tools that be used for local development and in continuous-integration scenarios.
  • Flexible deployment: Can be included in your app or installed side-by-side user- or machine-wide. Can be used with Docker containers.
  • Compatible: .NET Core is compatible with .NET Framework, Xamarin and Mono, via .NET Standard.
  • Open source: The .NET Core platform is open source, using MIT and Apache 2 licenses. .NET Core is a .NET Foundation project.
  • Supported by Microsoft: .NET Core is supported by Microsoft, per .NET Core Support.

Languages

C#, Visual Basic, and F# languages can be used to write applications and libraries for .NET Core. These languages are or can be integrated into your favorite text editors and IDEs, including Visual Studio, Visual Studio Code, Sublime Text and Vim. This integration is provided, in part, by the good folks from the OmniSharp and Ionide projects.

APIs

.NET Core exposes APIs for many scenarios, a few of which follow:

.NET Core provides compatibility with .NET Framework and Mono APIs by implementing the .NET Standard specification.

Frameworks

Multiple frameworks have been built on top of .NET Core:

Composition

.NET Core is composed of the following parts:

  • The .NET Core runtime, which provides a type system, assembly loading, a garbage collector, native interop and other basic services. .NET Core framework libraries provide primitive data types, app composition types and fundamental utilities.
  • The ASP.NET runtime, which provides a framework for building modern cloud based internet connected applications, such as web apps, IoT apps and mobile backends.
  • The .NET Core CLI tools and language compilers (Roslyn and F#) that enable the .NET Core developer experience.
  • The dotnet tool, which is used to launch .NET Core apps and CLI tools. It selects the runtime and hosts the runtime, provides an assembly loading policy and launches apps and tools.

These components are distributed in the following ways:

  • .NET Core Runtime -- includes the .NET Core runtime and framework libraries.
  • ASP.NET Core Runtime -- includes ASP.NET Core and .NET Core runtime and framework libraries.
  • .NET Core SDK -- includes the .NET CLI Tools, ASP.NET Core runtime, and .NET Core runtime and framework.

Open Source

.NET Core is open source (MIT license) and was contributed to the .NET Foundation by Microsoft in 2014. It is now one of the most active .NET Foundation projects. It can be freely adopted by individuals and companies, including for personal, academic or commercial purposes. Multiple companies use .NET Core as part of apps, tools, new platforms and hosting services. Some of these companies make significant contributions to .NET Core on GitHub and provide guidance on the product direction as part of the .NET Foundation Technical Steering Group.

Designed for Adaptability

.NET Core has been built as a very similar but unique product relative to other .NET products. It has been designed to enable broad adaptability to new platforms and workloads. It has several OS and CPU ports available and may be ported to many more.

The product is broken into several pieces, enabling the various parts to be adapted to new platforms at different times. The runtime and platform-specific foundational libraries must be ported as a unit. Platform-agnostic libraries should work as-is on all platforms, by construction. There is a project bias to reducing platform-specific implementations to increase developer efficiency, preferring platform-neutral C# code whenever an algorithm or API can be implemented in-full or in-part that way.

People commonly ask how .NET Core is implemented in order to support multiple operating systems. They typically ask if there are separate implementations or if conditional compilation is used. It's both, with a strong bias towards conditional compilation.

You can see in the chart below that the vast majority of CoreFX is platform-neutral code that is shared across all platforms. Platform-neutral code can be implemented as a single portable assembly that is used on all platforms.

CoreFX: Lines of Code per Platform

Windows and Unix implementations are similar in size. Windows has a larger implementation since CoreFX implements some Windows-only features, such as Microsoft.Win32.Registry but does not yet implement many Unix-only concepts. You will also see that the majority of the Linux and macOS implementations are shared across a Unix implementation, while the Linux- and macOS-specific implementations are roughly similar in size.

There are a mix of platform-specific and platform-neutral libraries in .NET Core. You can see the pattern in a few examples:

Comparisons to other .NET implementations

It is perhaps easiest to understand the size and shape of .NET Core by comparing it to existing .NET implementations.

Comparison with .NET Framework

.NET was first announced by Microsoft in 2000 and then evolved from there. The .NET Framework has been the primary .NET implementation produced by Microsoft during that nearly two decade period.

The major differences between .NET Core and the .NET Framework:

  • App-models -- .NET Core does not support all the .NET Framework app-models. In particular, it doesn't support ASP.NET Web Forms and MVC. It was announced that .NET Core 3 will support WPF and Windows Forms.
  • APIs -- .NET Core contains a large subset of .NET Framework Base Class Library, with a different factoring (assembly names are different; members exposed on types differ in key cases). These differences require changes to port source to .NET Core in some cases (see [microsoft/dotnet-apiport[(https://github.com/microsoft/dotnet-apiport)). .NET Core implements the .NET Standard API specification.
  • Subsystems -- .NET Core implements a subset of the subsystems in the .NET Framework, with the goal of a simpler implementation and programming model. For example, Code Access Security (CAS) is not supported, while reflection is supported.
  • Platforms -- The .NET Framework supports Windows and Windows Server while .NET Core also supports macOS and Linux.
  • Open Source -- .NET Core is open source, while a read-only subset of the .NET Framework is open source.

While .NET Core is unique and has significant differences to the .NET Framework and other .NET implementations, it is straightforward to share code between these implementations, using either source or binary sharing techniques.

Comparison with Mono

Mono is the original cross-platform and open source .NET implementation, first shipping in 2004. It can be thought of as a community clone of the .NET Framework. The Mono project team relied on the open .NET standards (notably ECMA 335) published by Microsoft in order to provide a compatible implementation.

The major differences between .NET Core and Mono:

  • App-models -- Mono supports a subset of the .NET Framework app-models (for example, Windows Forms) and some additional ones (for example, Xamarin.iOS) through the Xamarin product. .NET Core doesn't support these.
  • APIs -- Mono supports a large subset of the .NET Framework APIs, using the same assembly names and factoring.
  • Platforms -- Mono supports many platforms and CPUs.
  • Open Source -- Mono and .NET Core both use the MIT license and are .NET Foundation projects.
  • Focus -- The primary focus of Mono in recent years is mobile platforms, while .NET Core is focused on cloud and desktop workloads.