.NET CORE – Execution Architecture
The execution process of .NET Core and compare it with the .NET Framework. The managed execution process includes the following steps.
- Choosing a compiler
- Compiling your code to MSIL
- Compiling MSIL to native code
- Running code
Choosing a Compiler
- It is a multi-language execution environment, the runtime supports a wide variety of data types and language features.
- To obtain the benefits provided by the common language runtime, you must use one or more language compilers that target the runtime.
- In .NET Core now we have a new series of compilers, like we have Roslyn for C# and VB.
- You can also make use of the new F# 4.1 compiler if you want to use F# with .NET Core.
- Actually these tools are different and we can use Roslyn with .NET Framework as well if we are using C# 6 or later, because C# compiler can only support up to C# 5.
- In .NET Core, we don’t have a framework class libraries (FCL), so a different set of libraries are used and we now have CoreFx.
- CoreFx is the reimplementation of the class libraries for .NET Core.
- We also have a new run time with .NET Core known as CoreCLR and leverages a JIT Compiler.
- Now the question is why we have the reimplementation of all these components that we already have in .NET framework.
- So the answer is the same as why Microsoft implemented .NET Core
Compiling code to MSIL
- Compiling translates your source code into Microsoft Intermediate Language (MSIL) and generates the required metadata.
- Metadata describes the types in your code, including the definition of each type, the signatures of each type’s members, the members that code references, and other data that the runtime uses at execution time.
- The runtime locates and extracts the metadata from the file as well as from framework class libraries (FCL) as needed during execution.
Compiling MSIL to Native Code
- At execution time, a just-in-time (JIT) compiler translates the MSIL into native code.
- During this compilation, code must pass a verification process that examines the MSIL and metadata to find out whether the code can be determined to be type safe.
- The common language runtime provides the infrastructure that enables the execution to take place and services that can be used during execution.
- During execution, managed code receives services such as garbage collection, security, interoperability with unmanaged code, cross-language debugging support, and enhanced deployment and versioning support.
Run-time configuration options for compilation
- Configures whether the just-in-time (JIT) compiler uses tiered compilation. Tiered compilation transitions methods through two tiers:
- The first tier generates code more quickly (quick JIT) or loads pre-compiled code.
- The second tier generates optimized code in the background (“optimizing JIT”).
- In .NET Core 3.0 and later, tiered compilation is enabled by default.
- In .NET Core 2.1 and 2.2, tiered compilation is disabled by default.