- .NET Core Tutorial
- .NET Core - Home
- .NET Core - Overview
- .NET Core - Prerequisites
- .NET Core - Environment Setup
- .NET Core - Getting Started
- .NET Core - Numerics
- .NET Core - Garbage Collection
- .NET Core - Code Execution
- .NET Core - Modularity
- .NET Core - Project Files
- .NET Core - Package References
- Create UWP App with .NET Core
- .NET Core - MSBuild
- .NET Core - Metapackage
- Windows Runtime & Extension SDKs
- Create .NET Standard Library
- .NET Core - Portable Class Library
- Adding References to Library
- Sharing .NET Core Libraries
- Creating a Xamarin.Forms Project
- .NET Core - PCL Troubleshooting
- .NET Core - Create a Testing Project
- Running Tests in Visual Studio
- .NET Core - Testing Library
- Managed Extensibility Framework
- .NET Core - SDK
- .NET Core - MSBuild & project.json
- Restoring and Building & MSBuild
- .NET Core - Migrations
- .NET Core Useful Resources
- .NET Core - Quick Guide
- .NET Core - Useful Resources
- .NET Core - Discussion
.NET Core - Code Execution
In this chapter, we will understand 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.
Compiling your 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 your 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.
Running Code
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.
.NET Core Code Execution Process
Now let’s relate how code executes with .NET Core as compared to .NET Framework. In .NET Core there are many replacements of these components that are the part of the .NET Framework.
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 do 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.
To Continue Learning Please Login
Login with Google