C# & .NET

Architectural Evolution: From Windows Framework to High-Performance Cloud Engine

Unveiled in 2000 under lead architect Anders Hejlsberg, C# was engineered to deliver the rapid productivity of high-level languages alongside the deterministic structural power of C++. Over two decades, under language leads Anders Hejlsberg and Mads Torgersen, C# and .NET transformed from a Windows-bound corporate framework into an open-source, top-tier cloud runtime competing head-to-head with Go, Rust, and Java.

Installation & .NET SDK Setup

To develop C# applications, install the official cross-platform .NET SDK (Software Development Kit). The SDK includes the Roslyn C# compiler, the CLR runtime execution engine, and the dotnet Command-Line Interface (CLI).

# 1. Verify installed .NET SDK version
dotnet --info

# 2. Create a new Console Application
dotnet new console -o UndrstandingApp

# 3. Change directory and run the application
cd UndrstandingApp
dotnet run

Anatomy of a C# Program: using, namespace, and class

Every C# application is constructed from fundamental building blocks: using directives to import standard libraries, namespace declarations to logically group types, and class blueprints containing methods, fields, and constructors.

// Program.cs (Top-Level Statements)
// Roslyn auto-wraps namespace & Main()

using System;

Console.WriteLine("Hello, Undrstanding!");
GreetUser("Developer");

// Local function declaration
void GreetUser(string name)
{
    Console.WriteLine($"Welcome, {name}!");
}

using System; // 1. Import

namespace UndrstandingApp; // 2. Scope

public class Program // 3. Class
{
    public static void Main(string[] args) // 4. Entry
    {
        Console.WriteLine("Hello, World!");
        GreetUser("Developer");
    }

    static void GreetUser(string name) =>
        Console.WriteLine($"Welcome, {name}!");
}

Variable Declarations, Data Types & Constants

C# is a strongly-typed language. You can declare variables explicitly with data types or implicitly using the var keyword (where the compiler infers the exact type at compile time).

// Explicit Variable Declarations
int age = 25;
double score = 98.5;
decimal price = 19.99m; // High precision decimal for financial data
bool isActive = true;
string platformName = "Undrstanding";

// Implicit Typing with 'var' (Type inferred as string at compile time)
var userEmail = "student@undrstanding.com";

// Compile-Time Constant vs Readonly Field
const double Pi = 3.14159265;
readonly DateTime ServerStartTime = DateTime.UtcNow;

Console.WriteLine($"User: {userEmail} | Score: {score}");
Console.WriteLine($"Price: ${price} | Active: {isActive}");

Conditionals, Pattern Matching & Iteration Loops

Modern C# moves beyond basic if/else statements with expressive pattern matching and concise switch expressions. Iteration with foreach leverages compiler duck-typing to enumerate collections, arrays, and spans with zero heap allocation.

// 1. Pattern Matching with Relational & Logical Combinators
static string CategorizeStatus(int code) => code switch
{
    >= 200 and < 300 => "2xx: Success",
    >= 400 and < 500 => "4xx: Client Error",
    >= 500 and < 600 => "5xx: Server Error",
    _                  => "Unknown Status Code"
};

// 2. Duck-typed iteration with 'foreach' over collection
string[] services = ["AuthService", "OrderGateway", "PaymentWorker"];

foreach (var svc in services)
{
    Console.WriteLine($"Starting node: {svc}");
}

Console.WriteLine($"HTTP 204: {CategorizeStatus(204)}");
Console.WriteLine($"HTTP 503: {CategorizeStatus(503)}");

The Common Language Runtime (CLR) & Execution Engine

C# source code compiles into Common Intermediate Language (CIL/MSIL) bytecode rather than raw machine instructions. At execution time, the CLR's Just-In-Time (JIT) compiler translates bytecode into optimized native CPU instructions while managing type safety and automatic memory reclamation.

Value Types, Reference Types, Records & Null Safety

C# cleanly segregates memory into Value Types (allocated in-place on the stack or enclosing struct) and Reference Types (managed heap allocation). Modern C# enhances this foundation with immutable records, high-performance record structs, and compile-time Nullable Reference Types.

// 1. Immutable Record Class with Value-Based Equality
public record UserAccount(string Id, string Email, string Role);

// 2. Zero-Allocation Stack-Allocated Record Struct
public readonly record struct GeoPoint(double Lat, double Lng);

var u1 = new UserAccount("usr_1", "numan@example.com", "Student");

// Non-destructive mutation creating a new copy with modified property
var u2 = u1 with { Role = "Lead Engineer" };

// 3. Nullable Reference Types with Flow Analysis
string? rawInput = null;
string safeName = rawInput?.Trim() ?? "Guest Developer";

Console.WriteLine($"User: {u2.Email} [{u2.Role}]");
Console.WriteLine($"Value Equality (u1 == u2): {u1 == u2}");
Console.WriteLine($"Safe User: {safeName}");

Span<T>, Memory<T> & Zero-Allocation Slicing

Span<T> is a stack-only ref struct representing a contiguous region of arbitrary memory (managed heap arrays, stack memory via stackalloc, or native unmanaged pointers) without allocation overhead.

// Zero-Allocation String Slicing with ReadOnlySpan<char>
string rawHeader = "Authorization: Bearer eyJhbGciOiJIUzI1Ni...";
ReadOnlySpan<char> span = rawHeader.AsSpan();

// Slice without allocating a new string object
ReadOnlySpan<char> token = span.Slice(15, 6);
Console.WriteLine($"Sliced Token: {token.ToString()}");
Console.WriteLine($"Span Length: {token.Length} chars");

Generics, Variance & Event Architecture

Generics in .NET are fully reified by the CLR, meaning value type specialization produces dedicated machine code with zero boxing overhead. Generic variance allows controlled subtyping polymorphism across interfaces and delegates.

// Generic Repository Interface with Type Constraints & Covariance
public interface IReadOnlyRepository<out TEntity, in TId> 
    where TEntity : class
    where TId : notnull
{
    Task<TEntity?> GetByIdAsync(TId id, CancellationToken ct = default);
}

// Strongly-Typed Event Handler Delegate
public class DataEngine
{
    public event Action<string>? OnProcessed;

    public void Execute()
    {
        OnProcessed?.Invoke("Data pipeline processing finished successfully.");
    }
}

var engine = new DataEngine();
engine.OnProcessed += msg => Console.WriteLine($"[EVENT] {msg}");
engine.Execute();

LINQ Architecture: IEnumerable vs IQueryable & Expression Trees

Language Integrated Query (LINQ) unifies data access under declarative functional syntax. The critical architectural distinction lies in the underlying execution contract: IEnumerable<T> executes in-memory via delegates, whereas IQueryable<T> captures code as an Expression Tree (AST) that remote database providers compile into optimized SQL.

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Query defined (Deferred Execution - Not processed yet)
var query = numbers
    .Where(n => n % 2 == 0)
    .Select(n => n * 10);

numbers.Add(6); // Mutate list after query definition

// Execution triggered HERE during enumeration
foreach (var item in query)
{
    Console.WriteLine(item);
}

Async State Machines & Thread Pool Context

public async Task<string> DownloadPayloadAsync(string url, CancellationToken ct)
{
    using var client = new HttpClient();
    
    // Non-blocking asynchronous network request avoiding context capture
    Console.WriteLine($"[ASYNC] Dispatching request to {url}...");
    var response = await client.GetAsync(url, ct).ConfigureAwait(false);
    return await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
}

ASP.NET Core Architecture, Middleware Pipeline & DI Lifetimes

ASP.NET Core is a high-throughput, cloud-native web framework built on the high-performance Kestrel web server. Every incoming HTTP connection traverses a composable bidirectional middleware pipeline before resolving endpoints, utilizing the built-in Inversion-of-Control (IoC) Service Provider.

// Modern ASP.NET Core Minimal API with DI Injection
var builder = WebApplication.CreateBuilder(args);

// Register Services into IoC Container
builder.Services.AddSingleton<ICacheService, MemoryCacheService>();
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddTransient<ITransactionValidator, TransactionValidator>();

var app = builder.Build();

// Minimal API Route Endpoint with Automatic DI Parameter Binding
app.MapGet("/api/orders/{id:long}", async (long id, IOrderRepository repo, CancellationToken ct) =>
{
    var order = await repo.GetOrderAsync(id, ct);
    return order is not null ? Results.Ok(order) : Results.NotFound();
});

app.Run();

Data Access: ADO.NET & Entity Framework Core (EF Core)

Data persistence in .NET rests upon a dual-tier architectural hierarchy: raw, low-overhead socket streaming with ADO.NET (System.Data.Common), and rich, strongly-typed domain mapping with Entity Framework Core (EF Core). Mastering high-performance .NET applications requires understanding how these tiers interact, when to bypass abstraction layers, and how to avoid costly relational pitfalls.

// Production-Grade High-Performance ADO.NET Streaming Pattern
using System.Data;
using Microsoft.Data.SqlClient;

public async Task<List<CustomerDto>> GetActiveCustomersAsync(string country, CancellationToken ct)
{
    var results = new List<CustomerDto>();
    const string sql = @"SELECT CustomerId, CompanyName, CreditLimit, RegisteredUtc 
                           FROM dbo.Customers 
                           WHERE Country = @Country AND IsActive = 1;";

    // 1. Retrieve pooled connection (Recycled TCP socket)
    await using var conn = new SqlConnection(connectionString);
    await conn.OpenAsync(ct);

    // 2. Parameterized command prevents SQL injection & leverages plan cache
    await using var cmd = new SqlCommand(sql, conn);
    cmd.Parameters.Add("@Country", SqlDbType.NVarChar, 50).Value = country;

    // 3. Stream data via forward-only cursor (near-zero allocation)
    await using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SequentialAccess, ct);
    
    // 4. Cache ordinals to eliminate string hashing per-row in hot loop
    int idOrd    = reader.GetOrdinal("CustomerId");
    int nameOrd  = reader.GetOrdinal("CompanyName");
    int credOrd  = reader.GetOrdinal("CreditLimit");
    int dateOrd  = reader.GetOrdinal("RegisteredUtc");

    while (await reader.ReadAsync(ct))
    {
        results.Add(new CustomerDto(
            Id: reader.GetInt64(idOrd),
            Name: reader.GetString(nameOrd),
            CreditLimit: reader.GetDecimal(credOrd),
            RegisteredUtc: reader.GetDateTime(dateOrd)
        ));
    }

    return results;
}

// Modern EF Core 8+ Architecture: Fluent API, Split Queries & Bulk Operations
using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    public DbSet<Order> Orders => Set<Order>();
    public DbSet<OrderItem> OrderItems => Set<OrderItem>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Fluent API Configuration: Keys, Indexes & Concurrency Tokens
        modelBuilder.Entity<Order>(b =>
        {
            b.HasKey(o => o.Id);
            b.Property(o => o.OrderNumber).IsRequired().HasMaxLength(32);
            b.HasIndex(o => o.OrderNumber).IsUnique();
            b.Property(o => o.TotalAmount).HasPrecision(18, 2);

            // Global Query Filter: Soft Delete pattern applied transparently
            b.HasQueryFilter(o => !o.IsDeleted);

            b.HasMany(o => o.Items)
             .WithOne(i => i.Order)
             .HasForeignKey(i => i.OrderId)
             .OnDelete(DeleteBehavior.Cascade);
        });
    }
}

// Service Layer demonstrating High-Performance EF Core Patterns
public class OrderService(AppDbContext db)
{
    // 1. High-Performance Read: AsNoTracking + AsSplitQuery avoids Cartesian blowup
    public async Task<List<OrderDto>> GetCustomerOrdersAsync(long customerId, CancellationToken ct)
    {
        return await db.Orders
            .AsNoTracking()
            .AsSplitQuery()
            .Where(o => o.CustomerId == customerId)
            .Select(o => new OrderDto(
                o.Id, 
                o.OrderNumber, 
                o.TotalAmount, 
                o.Items.Select(i => new ItemDto(i.ProductName, i.Quantity, i.UnitPrice)).ToList()
            ))
            .ToListAsync(ct);
    }

    // 2. High-Performance Bulk Update (EF Core 7+): Bypasses Change Tracker completely
    public async Task<int> ArchiveOldOrdersAsync(DateTime cutoffDate, CancellationToken ct)
    {
        return await db.Orders
            .Where(o => o.CreatedAtUtc < cutoffDate && o.Status == OrderStatus.Completed)
            .ExecuteUpdateAsync(setters => setters
                .SetProperty(o => o.Status, OrderStatus.Archived)
                .SetProperty(o => o.LastUpdatedUtc, DateTime.UtcNow), 
                ct);
    }
}

SELECT [o].[Id], [o].[OrderNumber], [o].[TotalAmount], [o].[CreatedAt] FROM [Orders] AS [o] WHERE [o].[Status] = @__status_0;

C# & .NET Architecture Glossary

Knowledge Check (12 Assessment Questions)

Verify your understanding of C# syntax, SDK installation, CLR runtime mechanics, Span memory slicing, LINQ, ASP.NET Core, ADO.NET, and EF Core architecture. Pass all 12 questions to earn your certificate.