.NET Framework Core Concepts

The .NET Framework is a software development platform, included with Windows operating systems, that supports the development and execution of a wide range of applications. It consists of a common language runtime (CLR) and a rich set of class libraries.

Common Language Runtime (CLR)

The CLR is the execution engine of the .NET Framework. It manages code execution, provides memory management (including garbage collection), handles security, and supports features like Just-In-Time (JIT) compilation. The CLR ensures that code written in different .NET languages can interoperate seamlessly.

Key CLR Features:

• Just-In-Time (JIT) Compilation: Compiles Intermediate Language (IL) code into native machine code at runtime.
• Garbage Collection (GC): Automatically manages memory allocation and deallocation, preventing memory leaks.
• Type Safety: Enforces strict type checking to prevent common programming errors.
• Exception Handling: Provides a structured mechanism for handling runtime errors.
• Security: Offers a robust security model to protect applications and user data.

Base Class Library (BCL)

The Base Class Library (often referred to as the Framework Class Library or FCL) is a comprehensive collection of reusable types, classes, and interfaces that developers can use to build applications. These libraries provide functionality for a wide range of tasks, from basic input/output operations to advanced networking and data manipulation.

Common BCL Namespaces:

• System: Fundamental types and base classes.
• System.Collections: Interfaces and classes that define collections of objects.
• System.IO: Classes for reading and writing files and streams.
• System.Net: Classes for network programming.
• System.Text: Classes for string manipulation and encoding.
• System.Threading: Classes for managing threads and concurrency.
• System.Xml: Classes for working with XML documents.

Managed Code and Intermediate Language (IL)

Code written in any .NET-compliant language (like C#, VB.NET, F#) is first compiled into an Intermediate Language (IL) or Microsoft Intermediate Language (MSIL). This IL code is then compiled into native machine code by the CLR just before execution. This process is known as managed code because its execution is managed by the CLR.

// Example of C# code
        using System;

        public class HelloWorld
        {
            public static void Main(string[] args)
            {
                Console.WriteLine("Hello, .NET Framework!");
            }
        }
        

Assemblies

Assemblies are the fundamental unit of deployment, versioning, and security in the .NET Framework. An assembly is a collection of one or more types and resources that are built to work together and form a logical unit of functionality. They are typically contained in executable files (.exe) or dynamic-link libraries (.dll).

Common Type System (CTS)

The CTS defines a set of common types that can be used across all .NET-compliant languages. This ensures that data types are compatible and interchangeable between different languages, facilitating interoperability.

Common Language Specification (CLS)

The CLS is a subset of the CTS that specifies a set of rules that languages must follow to ensure interoperability. If a language adheres to the CLS, code written in that language can interact with code written in any other CLS-compliant language.

Application Domains (AppDomains)

AppDomains provide an isolation mechanism for running code. Each AppDomain has its own security policy, exception handling, and resource management. This isolation helps to prevent applications from interfering with each other or with the CLR itself.