.NET Fundamentals

Introduction to .NET

.NET is a free, cross-platform, open-source developer platform for building many different types of applications. With .NET, you can:

• Build web apps, web APIs, and mobile apps.
• Use C#, F#, or Visual Basic for development.
• Run your applications on Windows, macOS, and Linux.
• Utilize a rich set of libraries and frameworks like ASP.NET Core, Entity Framework Core, and MAUI.

Modern .NET is a single product family that includes:

• .NET 8 (and later): The latest release, focusing on performance, cloud-native development, and simplified deployment.
• .NET Standard: A formal specification of .NET APIs that are intended to be available on all .NET implementations.
• .NET Framework: The original Windows-only version, still supported but not recommended for new development.

Architecture Overview

The .NET platform is built on several key components:

• Runtime: Manages the execution of your code, providing services like memory management, thread management, and security.
• Base Class Library (BCL): A comprehensive set of APIs for common programming tasks, including file I/O, networking, collections, and string manipulation.
• Language Compilers: Translate source code written in languages like C# into intermediate language (IL).
• Just-In-Time (JIT) Compiler: Compiles IL into native machine code at runtime for optimal performance.

Core Concepts

Common Language Runtime (CLR)

The CLR is the execution engine of .NET. It manages code execution and provides services such as:

• Memory Management: Automatic memory allocation and garbage collection.
• Exception Handling: Structured error handling.
• Thread Management: Support for multithreading and asynchronous operations.
• Security: Code access security and type safety.

Code running under the CLR is known as managed code, which benefits from these runtime services.

.NET CLI

The .NET Command-Line Interface (CLI) is a cross-platform toolchain that enables you to create, build, run, and publish .NET applications. Key commands include:

• dotnet new: Create new projects and files.
• dotnet build: Compile project.
• dotnet run: Compile and run project.
• dotnet publish: Publish an application for deployment.
• dotnet test: Run unit tests.

# Create a new console application
dotnet new console -o MyConsoleApp
cd MyConsoleApp

# Build the application
dotnet build

# Run the application
dotnet run

SDK and Runtime

.NET development involves two main installations:

• .NET SDK: Includes the runtime, compilers, CLI tools, and libraries needed for development. Install this if you are building .NET applications.
• .NET Runtime: Includes the runtime and libraries needed to run .NET applications. Install this if you only need to run applications, not develop them.

The SDK includes the runtime, so installing the SDK is sufficient for most development scenarios.

Assemblies and Namespaces

In .NET, code is organized into assemblies, which are the building blocks of .NET applications. Assemblies are typically deployed as DLL (Dynamic Link Library) or EXE (Executable) files.

Namespaces are used to organize types (classes, structs, interfaces, etc.) and provide a hierarchical naming structure. They help prevent naming conflicts and make code more manageable.

For example, the System.Collections.Generic namespace contains common collection types like List<T> and Dictionary<TKey, TValue>.

Garbage Collection

The Garbage Collector (GC) is a key part of the CLR responsible for automatic memory management. It frees up memory occupied by objects that are no longer in use by the application.

• Automatic: Developers don't need to manually allocate or deallocate memory for most objects.
• Cycle Detection: The GC identifies unreachable objects.
• Memory Reclamation: It reclaims the memory used by unreachable objects, preventing memory leaks.

While the GC simplifies memory management, understanding its behavior can be important for performance tuning in high-throughput applications.

Language Features

.NET supports multiple programming languages, with C# being the most prominent. Modern C# offers powerful features:

• Asynchronous Programming: async and await keywords for non-blocking operations.
• LINQ (Language Integrated Query): A powerful way to query collections and data sources.
• Pattern Matching: Advanced syntax for conditional logic and data extraction.
• Nullable Reference Types: Helps prevent null reference exceptions at compile time.
• Records: Immutable data types with concise syntax.

// Example of LINQ
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach (var num in evenNumbers)
{
    Console.WriteLine(num);
}

Memory Management

While the GC handles most memory management, it's important to understand the different memory areas:

• Heap: Where objects are allocated. Managed by the GC.
• Stack: Where local variables and method call information are stored. Managed automatically during method execution.

Value types (like int, struct) are typically allocated on the stack, while reference types (like class objects) are allocated on the heap.

Performance

.NET prioritizes performance. Key aspects include:

• JIT Compilation: Optimizes code for the target architecture.
• Span<T> and Memory<T>: Efficient memory access without copying.
• RyuJIT Compiler: Advanced optimizations for improved code generation.
• Profiling Tools: Available in Visual Studio and other tools to identify performance bottlenecks.

Security

Security is a first-class concern in .NET. Features include:

• Type Safety: The CLR verifies code to ensure it operates on valid data types.
• Code Access Security (CAS): (Legacy, less used in modern .NET) Controls permissions for code.
• Cryptography APIs: Comprehensive libraries for encryption, hashing, and digital signatures.
• ASP.NET Core Security: Built-in features for authentication, authorization, and protection against common web vulnerabilities.