Immutable After Creation

Want immutable objects but like object initializers? Init-only setters (C# 9) allow setting properties during initialization only. Read-only after construction.

The Old Dilemma

// Option 1: Mutable properties (not safe)
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

var person = new Person { Name = "Alice", Age = 30 };
person.Age = 31;  //  Works, but object is mutable

// Option 2: Read-only with constructor (verbose)
public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

var person = new Person("Alice", 30);  // Can't use object initializer 

// Option 3: Private setter (still allows mutation in class)
public class Person
{
    public string Name { get; private set; }
    public int Age { get; private set; }
}

// All have tradeoffs!

Init-Only Setters Solution

//  Best of both worlds!
public class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

// Can use object initializer
var person = new Person 
{ 
    Name = "Alice", 
    Age = 30 
};

// But can't modify after construction
person.Age = 31;  //  Compile error: Init-only property can only be set in initializer

// Perfect for immutable objects!

public class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
    public DateTime CreatedAt { get; init; }

    public Person()
    {
        CreatedAt = DateTime.UtcNow;  //  Can set in constructor
    }
}

var person = new Person 
{ 
    Name = "Alice",
    Age = 30
};

Console.WriteLine(person.CreatedAt);  // Set automatically in constructor
// But CreatedAt can also be overridden in initializer if needed

Validation with Init

public class Email
{
    private string _value;

    public string Value
    {
        get => _value;
        init
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Email cannot be empty");
            
            if (!value.Contains('@'))
                throw new ArgumentException("Invalid email format");
            
            _value = value;
        }
    }
}

var email = new Email { Value = "alice@example.com" };  //  Valid
var invalid = new Email { Value = "not-an-email" };      //  Throws exception

// After creation, immutable
// email.Value = "new@example.com";  //  Compile error

Required Members (C# 11)

// Combine init with required
public class User
{
    public required string Email { get; init; }
    public required string Name { get; init; }
    public string? PhoneNumber { get; init; }  // Optional
}

//  Must set required properties
var user = new User 
{ 
    Email = "alice@example.com",
    Name = "Alice"
};

//  Compile error: Required member 'Email' must be set
var invalid = new User { Name = "Alice" };

// Perfect for API request/response DTOs
public class CreateUserRequest
{
    public required string Email { get; init; }
    public required string Password { get; init; }
    public required string Name { get; init; }
    public string? PhoneNumber { get; init; }
}

public class UserResponse
{
    public required int Id { get; init; }
    public required string Email { get; init; }
    public required string Name { get; init; }
    public required DateTime CreatedAt { get; init; }
}

// Controller
[HttpPost("users")]
public async Task CreateUser(CreateUserRequest request)
{
    var user = await _userService.CreateAsync(request);
    
    return new UserResponse
    {
        Id = user.Id,
        Email = user.Email,
        Name = user.Name,
        CreatedAt = user.CreatedAt
    };
}

// Response is immutable - thread-safe!

With Record Types

// Records have init by default
public record Person(string Name, int Age);

// Same as:
public record Person
{
    public string Name { get; init; }
    public int Age { get; init; }
    
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

// Use with expressions for non-destructive mutation
var person1 = new Person("Alice", 30);
var person2 = person1 with { Age = 31 };

// person1 unchanged, person2 has new age

// Configuration object
public class DatabaseConfig
{
    public required string ConnectionString { get; init; }
    public required string DatabaseName { get; init; }
    public int MaxPoolSize { get; init; } = 100;
    public int CommandTimeout { get; init; } = 30;
    public bool EnableRetry { get; init; } = true;
}

// Usage
var config = new DatabaseConfig
{
    ConnectionString = "Server=localhost;Database=mydb",
    DatabaseName = "mydb",
    MaxPoolSize = 200
};

// Immutable after creation - safe to pass around
await InitializeDatabaseAsync(config);

// Can't accidentally change config
// config.MaxPoolSize = 300;  //  Compile error

// Value object
public class Money
{
    public required decimal Amount { get; init; }
    public required string Currency { get; init; }

    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException("Currency mismatch");
        
        return new Money 
        { 
            Amount = Amount + other.Amount,
            Currency = Currency
        };
    }
}

var price1 = new Money { Amount = 100m, Currency = "USD" };
var price2 = new Money { Amount = 50m, Currency = "USD" };
var total = price1.Add(price2);

// All Money objects immutable - safe!

“Converted all configuration classes to init-only properties. Thread-safety bugs disappeared. Code cleaner with object initializers. Required keyword catches missing configs at compile-time.”

Lambda-Style Everything

Simple methods with { return x; }? Verbose. Expression-bodied members use => for methods, properties, constructors. One line replaces five.

Expression-Bodied Methods

//  Traditional method syntax
public string GetFullName()
{
    return $"{FirstName} {LastName}";
}

//  Expression-bodied method
public string GetFullName() => $"{FirstName} {LastName}";

// More examples
public int Add(int a, int b) => a + b;

public bool IsAdult() => Age >= 18;

public void PrintMessage() => Console.WriteLine("Hello");

public async Task GetUserAsync(int id) => await _repository.GetByIdAsync(id);

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }

    //  Traditional read-only property
    public string FullName
    {
        get
        {
            return $"{FirstName} {LastName}";
        }
    }

    //  Expression-bodied property
    public string FullName => $"{FirstName} {LastName}";

    // More examples
    public int Age => (int)((DateTime.Now - BirthDate).TotalDays / 365.25);
    
    public bool IsAdult => Age >= 18;
    
    public string Initials => $"{FirstName[0]}{LastName[0]}";
}

// Expression-bodied getter and setter (C# 7+)
private string _name;

public string Name
{
    get => _name;
    set => _name = value?.Trim() ?? throw new ArgumentNullException();
}

Expression-Bodied Constructors

public class Point
{
    public int X { get; }
    public int Y { get; }

    //  Traditional constructor
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    //  Expression-bodied constructor
    public Point(int x, int y) => (X, Y) = (x, y);
}

// More examples
public class Logger
{
    private readonly ILoggerFactory _factory;

    public Logger(ILoggerFactory factory) => _factory = factory ?? throw new ArgumentNullException(nameof(factory));
}

Expression-Bodied Finalizers & Indexers

// Expression-bodied finalizer
~MyClass() => Console.WriteLine("Finalizing");

// Expression-bodied indexer
public class Collection
{
    private readonly T[] _items;

    public Collection(T[] items) => _items = items;

    //  Traditional indexer
    public T this[int index]
    {
        get { return _items[index]; }
        set { _items[index] = value; }
    }

    //  Expression-bodied indexer
    public T this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public decimal Cost { get; set; }
    public int Stock { get; set; }

    // Expression-bodied properties
    public decimal Margin => Price - Cost;
    public decimal MarginPercent => (Margin / Price) * 100;
    public bool InStock => Stock > 0;
    public bool LowStock => Stock < 10 && Stock > 0;

    // Expression-bodied methods
    public decimal CalculateRevenue(int quantity) => Price * quantity;
    
    public decimal CalculateProfit(int quantity) => Margin * quantity;
    
    public bool CanFulfillOrder(int quantity) => Stock >= quantity;
    
    public void Restock(int amount) => Stock += amount;
    
    public void Sell(int quantity) => Stock -= quantity;

    // ToString
    public override string ToString() => $"Product: {Name} (${Price:F2})";
}

// Usage
var product = new Product 
{ 
    Name = "Widget", 
    Price = 100m, 
    Cost = 60m, 
    Stock = 50 
};

Console.WriteLine(product.Margin);         // 40
Console.WriteLine(product.MarginPercent);  // 40
Console.WriteLine(product.LowStock);       // false
Console.WriteLine(product.CalculateProfit(10));  // 400

//  Before: 30 lines
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public double Divide(int a, int b)
    {
        return (double)a / b;
    }

    public bool IsEven(int number)
    {
        return number % 2 == 0;
    }

    public int Square(int number)
    {
        return number * number;
    }
}

//  After: 10 lines
public class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;
    public int Multiply(int a, int b) => a * b;
    public double Divide(int a, int b) => (double)a / b;
    public bool IsEven(int number) => number % 2 == 0;
    public int Square(int number) => number * number;
}

// 67% less code, same functionality!

“Refactored utility classes to expression-bodied members. Code reduced 40%. Readability improved. Team adopted it everywhere. Now standard in our style guide.”

No More NullReferenceException

NullReferenceException killing your app? Can’t tell if variable can be null? Nullable reference types (C# 8+) make nullability explicit. Compiler warns about potential null errors.

The Null Problem

// Before nullable reference types
public class UserService
{
    public string GetUserName(int userId)
    {
        var user = _repository.GetById(userId);  // Could return null!
        return user.Name;  //  NullReferenceException if user is null
    }
}

// No compiler warning!
// Crashes at runtime
// "The billion dollar mistake" - Tony Hoare

Enable Nullable Reference Types

  
    net8.0
    enable  
  



#nullable enable  // At top of .cs file

// After enabling nullable reference types
public class UserService
{
    // Non-nullable: Must never be null
    public string GetUserName(int userId)
    {
        User? user = _repository.GetById(userId);  // User? = nullable
        return user.Name;  //  Compiler warning: Possible null reference
    }
    
    // Fixed version
    public string GetUserName(int userId)
    {
        User? user = _repository.GetById(userId);
        
        if (user == null)
        {
            throw new UserNotFoundException(userId);
        }
        
        return user.Name;  //  No warning - null checked
    }
    
    // Or return nullable
    public string? GetUserName(int userId)
    {
        User? user = _repository.GetById(userId);
        return user?.Name;  //  Returns null if user is null
    }
}

// Non-nullable reference type (default)
string name = "Alice";
name = null;  //  Warning: Cannot assign null

// Nullable reference type (explicit ?)
string? name = null;  //  OK
name = "Alice";      //  OK

// Non-nullable in method signatures
public void ProcessUser(User user)  // user cannot be null
{
    Console.WriteLine(user.Name);  //  No null check needed
}

// Nullable in method signatures
public void ProcessUser(User? user)  // user might be null
{
    if (user != null)
    {
        Console.WriteLine(user.Name);  //  Null checked
    }
}

// Return types
public User GetUser(int id)      // Never returns null
public User? FindUser(int id)    // Might return null

Null-Handling Patterns

User? user = FindUser(123);

// 1. Null check
if (user != null)
{
    Console.WriteLine(user.Name);
}

// 2. Null-conditional operator
Console.WriteLine(user?.Name);  // Returns null if user is null

// 3. Null-coalescing operator
string name = user?.Name ?? "Unknown";

// 4. Throw if null
User nonNullUser = user ?? throw new ArgumentNullException(nameof(user));

// 5. Pattern matching
if (user is { Name: var name })
{
    Console.WriteLine(name);  // user is not null here
}

// 6. Null-forgiving operator (! - use sparingly!)
Console.WriteLine(user!.Name);  // Tell compiler: "I know it's not null"
// Use only when you're 100% sure

Constructor and Property Initialization

public class User
{
    //  Warning: Non-nullable property must be initialized
    public string Name { get; set; }
    
    //  Fixed: Initialize in constructor
    public User(string name)
    {
        Name = name;
    }
}

// Or use required (C# 11)
public class User
{
    public required string Name { get; set; }
    public string? Email { get; set; }  // Optional, can be null
}

var user = new User { Name = "Alice" };  //  OK
var user2 = new User { Email = "test@example.com" };  //  Error: Name required

// Or default value
public class User
{
    public string Name { get; set; } = string.Empty;
    public List Orders { get; set; } = new();
}

// Null-forgiving operator !
string GetName(User? user)
{
    // You KNOW user is not null (e.g., validated earlier)
    return user!.Name;  // Suppresses warning
}

// Pragma directive (suppress for block)
#pragma warning disable CS8600  // Converting null literal
string? name = null;
#pragma warning restore CS8600

// Attribute (for methods that ensure non-null)
public static bool TryGetUser(int id, [NotNullWhen(true)] out User? user)
{
    user = FindUser(id);
    return user != null;
}

if (TryGetUser(123, out var user))
{
    Console.WriteLine(user.Name);  //  Compiler knows user is not null
}

#nullable enable

public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly IEmailService _emailService;

    public OrderService(IOrderRepository repository, IEmailService emailService)
    {
        _repository = repository;
        _emailService = emailService;
    }

    // Clear contract: Never returns null
    public Order GetOrder(int id)
    {
        Order? order = _repository.FindById(id);
        
        if (order == null)
        {
            throw new OrderNotFoundException($"Order {id} not found");
        }
        
        return order;  //  Guaranteed non-null
    }

    // Clear contract: Might return null
    public Order? FindOrder(int id)
    {
        return _repository.FindById(id);  //  Nullable return
    }

    public async Task ProcessOrder(Order order, string? promoCode)
    {
        // order is non-nullable - no need to check
        order.Status = OrderStatus.Processing;

        // promoCode is nullable - must check
        if (promoCode != null)
        {
            ApplyPromoCode(order, promoCode);
        }

        await _repository.SaveAsync(order);
        
        // Email might be null, handle gracefully
        await _emailService.SendConfirmationAsync(order.CustomerEmail ?? "no-reply@store.com");
    }
}

“Enabled nullable reference types on legacy codebase. Compiler found 147 potential null bugs. Fixed them all. NullReferenceException crashes dropped 95%. Best decision for code quality.”

Value Objects Made Easy

DTOs with 50 lines of boilerplate? Equals(), GetHashCode(), ToString()? Record types (C# 9+) are immutable, value-based, with auto-generated methods. One line replaces 50.

Traditional Class vs Record

//  Traditional class - Lots of boilerplate
public class PersonClass
{
    public string Name { get; init; }
    public int Age { get; init; }
    
    public PersonClass(string name, int age)
    {
        Name = name;
        Age = age;
    }
    
    // Manual Equals
    public override bool Equals(object? obj)
    {
        if (obj is not PersonClass other) return false;
        return Name == other.Name && Age == other.Age;
    }
    
    // Manual GetHashCode
    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }
    
    // Manual ToString
    public override string ToString()
    {
        return $"PersonClass {{ Name = {Name}, Age = {Age} }}";
    }
    
    // Manual copy with changes
    public PersonClass WithAge(int newAge)
    {
        return new PersonClass(Name, newAge);
    }
}

// 40+ lines for simple data object!

//  Record - One line!
public record Person(string Name, int Age);

// That's it! Auto-generates:
// - Constructor
// - Properties (init-only)
// - Equals() and GetHashCode() (value-based)
// - ToString()
// - Deconstruct()
// - With expressions

public record Person(string Name, int Age);

// Value-based equality
var person1 = new Person("Alice", 30);
var person2 = new Person("Alice", 30);

Console.WriteLine(person1 == person2);  // True! (value equality)
// With classes: False (reference equality)

// Auto ToString()
Console.WriteLine(person1);  // Person { Name = Alice, Age = 30 }

// With expressions (non-destructive mutation)
var person3 = person1 with { Age = 31 };
Console.WriteLine(person3);  // Person { Name = Alice, Age = 31 }
// person1 unchanged (immutable)

// Deconstruction
var (name, age) = person1;
Console.WriteLine($"{name} is {age}");  // Alice is 30

// Pattern matching
var message = person1 switch
{
    { Age: < 18 } => "Minor",
    { Age: >= 18 and < 65 } => "Adult",
    _ => "Senior"
};

Record vs Record Struct vs Class

// Record (reference type, immutable by default)
public record Person(string Name, int Age);

// Record struct (value type, C# 10+)
public record struct Point(int X, int Y);

// Class (reference type, mutable)
public class PersonClass
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// When to use what?
// Record: DTOs, value objects, immutable data
// Record struct: Small data (< 16 bytes), high-performance scenarios
// Class: Entities with behavior, mutable state

Advanced Record Features

// Additional properties and methods
public record Person(string Name, int Age)
{
    // Computed property
    public string DisplayName => $"{Name} ({Age})";
    
    // Validation
    public Person
    {
        if (Age < 0) throw new ArgumentException("Age cannot be negative");
    }
    
    // Additional methods
    public bool IsAdult() => Age >= 18;
}

// Inheritance (records can inherit from records)
public record Employee(string Name, int Age, string Department) 
    : Person(Name, Age);

var emp = new Employee("Bob", 25, "IT");
Console.WriteLine(emp);  
// Employee { Name = Bob, Age = 25, Department = IT }

// With expression works with derived records
var emp2 = emp with { Department = "HR" };

// API Request/Response DTOs
public record CreateUserRequest(
    string Email,
    string Name,
    string Password
);

public record UserResponse(
    int Id,
    string Email,
    string Name,
    DateTime CreatedAt
);

// API Controller
[HttpPost("users")]
public async Task CreateUser(CreateUserRequest request)
{
    var user = await _userService.CreateAsync(request);
    return new UserResponse(
        user.Id,
        user.Email,
        user.Name,
        user.CreatedAt
    );
}

// Clean, immutable, perfect for data transfer

Positional vs Nominal Records

// Positional record (concise)
public record Person(string Name, int Age);

// Nominal record (traditional property syntax)
public record Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

// Mix both
public record Person(string Name, int Age)
{
    public string Email { get; init; } = string.Empty;
    public DateTime CreatedAt { get; init; } = DateTime.UtcNow;
}

var person = new Person("Alice", 30)
{
    Email = "alice@example.com"
};

// Domain value objects
public record Money(decimal Amount, string Currency)
{
    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException("Currency mismatch");
        return this with { Amount = Amount + other.Amount };
    }
}

public record Address(
    string Street,
    string City,
    string State,
    string ZipCode,
    string Country
);

public record CustomerDto(
    int Id,
    string Name,
    Address Address,
    Money Balance
);

// Usage
var addr = new Address("123 Main St", "NYC", "NY", "10001", "USA");
var balance = new Money(1000m, "USD");
var customer = new CustomerDto(1, "Alice", addr, balance);

// Update address
var updated = customer with 
{ 
    Address = customer.Address with { City = "Boston" }
};

// Value equality
var addr2 = new Address("123 Main St", "NYC", "NY", "10001", "USA");
Console.WriteLine(addr == addr2);  // True!

"Converted all DTOs from classes to records. Deleted 2000+ lines of boilerplate. Bugs related to mutable state disappeared. API responses now immutable, thread-safe. Should've used records from day one."

Zero-Allocation String Operations

Substring creates new string. Array slicing copies memory. Span<T> provides zero-copy views. Massive performance gains.

The Problem with Substring

//  Traditional: Allocates new strings
string data = "2024-03-19T10:30:00";
string year = data.Substring(0, 4);      // Allocates "2024"
string month = data.Substring(5, 2);     // Allocates "03"
string day = data.Substring(8, 2);       // Allocates "19"

// Process 1 million dates: 3 million allocations!
// Garbage collector works overtime

//  Span: Zero allocations
ReadOnlySpan data = "2024-03-19T10:30:00";
ReadOnlySpan year = data.Slice(0, 4);   // No allocation
ReadOnlySpan month = data.Slice(5, 2);  // No allocation
ReadOnlySpan day = data.Slice(8, 2);    // No allocation

int yearNum = int.Parse(year);   // Parses directly from span

// Stack-allocated array (no heap allocation!)
Span numbers = stackalloc int[100];
numbers[0] = 42;

// View into existing array (no copy!)
int[] array = new int[100];
Span slice = array.AsSpan(10, 50);  // Elements 10-59
slice[0] = 100;  // Modifies original array

// String as ReadOnlySpan (immutable)
ReadOnlySpan text = "Hello, World!";
ReadOnlySpan hello = text.Slice(0, 5);

// Can't do this (compile error):
// Span span = "Hello";  // Strings are immutable

Real-World: CSV Parsing

//  Traditional: Many allocations
public List ParseCSV(string csv)
{
    var people = new List();
    var lines = csv.Split('\n');  // Allocates array of strings
    
    foreach (var line in lines)
    {
        var parts = line.Split(',');  // Allocates array per line
        people.Add(new Person 
        { 
            Name = parts[0],  // Already allocated
            Age = int.Parse(parts[1]) 
        });
    }
    return people;
}

//  Span: Minimal allocations
public List ParseCSVFast(ReadOnlySpan csv)
{
    var people = new List();
    
    while (csv.Length > 0)
    {
        int newline = csv.IndexOf('\n');
        var line = newline >= 0 ? csv.Slice(0, newline) : csv;
        csv = newline >= 0 ? csv.Slice(newline + 1) : default;
        
        int comma = line.IndexOf(',');
        var name = line.Slice(0, comma);
        var age = line.Slice(comma + 1);
        
        people.Add(new Person 
        { 
            Name = name.ToString(),  // Only allocation here
            Age = int.Parse(age) 
        });
    }
    return people;
}

// Benchmark: 10x faster, 90% less memory

stackalloc for Temp Buffers

//  Allocates array on heap
byte[] buffer = new byte[256];
ReadData(buffer);

//  Stack-allocated (no GC pressure)
Span buffer = stackalloc byte[256];
ReadData(buffer);

// Warning: Don't stackalloc large arrays!
// Stack is limited (typically 1MB)
// Use for small buffers only (< 1KB)

// Safe pattern
Span buffer = size <= 1024 
    ? stackalloc byte[size] 
    : new byte[size];

// Span can't be used in async methods (stack-based)
// Use Memory instead

public async Task ProcessAsync(Memory data)
{
    // Can hold across await
    await Task.Delay(100);
    
    // Convert to Span when needed
    Span span = data.Span;
    span[0] = 42;
}

// ReadOnlyMemory for immutable
public async Task CountAsync(ReadOnlyMemory text)
{
    await Task.Delay(100);
    return text.Span.Count('a');
}

"Log parser was allocating 500MB/second. Rewrote with Span<char>. Allocations down to 5MB/second. GC pauses gone. Throughput tripled. Span is game-changing for high-performance .NET."

Async Done Right

Async/await is powerful but tricky. Common mistakes cause deadlocks, performance issues, bugs. Learn to do it right.

Mistake 1: Async Void

//  BAD: Async void (only for event handlers!)
public async void ProcessData()
{
    await DoWorkAsync();
}
// Problems:
// - Can't await it
// - Exceptions crash app
// - No way to know when it completes

//  GOOD: Async Task
public async Task ProcessDataAsync()
{
    await DoWorkAsync();
}
// Can await, catch exceptions, compose operations

// Exception: Event handlers MUST be async void
private async void Button_Click(object sender, EventArgs e)
{
    try
    {
        await ProcessDataAsync();
    }
    catch (Exception ex)
    {
        // Handle exception - can't let it bubble up
        Logger.LogError(ex);
    }
}

Mistake 2: Blocking on Async (Deadlock)

//  BAD: Deadlock in UI or ASP.NET (pre-Core)
public void ProcessData()
{
    var result = GetDataAsync().Result;  // DEADLOCK!
    // Or
    GetDataAsync().Wait();  // DEADLOCK!
}

async Task GetDataAsync()
{
    await Task.Delay(1000);
    return "data";
}

// Why deadlock?
// 1. .Result blocks current thread
// 2. await tries to resume on same thread
// 3. Thread is blocked waiting for await
// 4. Deadlock!

//  GOOD: Async all the way
public async Task ProcessDataAsync()
{
    var result = await GetDataAsync();
}

// Or in console app / ASP.NET Core (no sync context)
public void Main()
{
    var result = GetDataAsync().GetAwaiter().GetResult();  // OK in console
}

//  In library code: Captures context unnecessarily
public async Task GetDataAsync()
{
    await httpClient.GetAsync(url);  // Resumes on original context
    return data;
}

//  GOOD: Library code should use ConfigureAwait(false)
public async Task GetDataAsync()
{
    await httpClient.GetAsync(url).ConfigureAwait(false);
    return data;
}

// Rule of thumb:
// - UI code: Don't use ConfigureAwait (need UI thread)
// - Library code: Always ConfigureAwait(false) (performance)
// - ASP.NET Core: Doesn't matter (no sync context)

Mistake 4: Fire and Forget

//  BAD: Exceptions swallowed
public void DoWork()
{
    _ = ProcessDataAsync();  // Fire and forget - exception lost!
}

//  GOOD: Await or explicitly handle
public async Task DoWorkAsync()
{
    await ProcessDataAsync();
}

// Or if truly fire-and-forget, handle exceptions
public void DoWork()
{
    _ = ProcessDataSafelyAsync();
}

private async Task ProcessDataSafelyAsync()
{
    try
    {
        await ProcessDataAsync();
    }
    catch (Exception ex)
    {
        Logger.LogError(ex);
    }
}

Parallel Async Operations

//  BAD: Sequential (6 seconds total)
var user = await GetUserAsync();      // 2 seconds
var orders = await GetOrdersAsync();  // 2 seconds
var products = await GetProductsAsync();  // 2 seconds

//  GOOD: Parallel (2 seconds total)
var userTask = GetUserAsync();
var ordersTask = GetOrdersAsync();
var productsTask = GetProductsAsync();

await Task.WhenAll(userTask, ordersTask, productsTask);

var user = await userTask;
var orders = await ordersTask;
var products = await productsTask;

// Or even better
var (user, orders, products) = await (
    GetUserAsync(),
    GetOrdersAsync(),
    GetProductsAsync()
);

// Always accept CancellationToken
public async Task GetDataAsync(CancellationToken ct = default)
{
    // Pass to async operations
    var response = await httpClient.GetAsync(url, ct);
    
    // Check periodically in loops
    foreach (var item in items)
    {
        ct.ThrowIfCancellationRequested();
        await ProcessAsync(item, ct);
    }
    
    return data;
}

// Usage with timeout
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var data = await GetDataAsync(cts.Token);

//  Capturing loop variable
foreach (var item in items)
{
    tasks.Add(Task.Run(() => Process(item)));  // Captures 'item'!
}

//  Copy to local variable
foreach (var item in items)
{
    var local = item;
    tasks.Add(Task.Run(() => Process(local)));
}

//  Async lambda in LINQ (doesn't await!)
items.Select(async item => await ProcessAsync(item));

//  Use Task.WhenAll
var tasks = items.Select(item => ProcessAsync(item));
await Task.WhenAll(tasks);

“App froze randomly. Found .Result blocking async code. Changed to async all the way. No more freezes. Then made parallel calls with Task.WhenAll. API response time: 5s → 1s. Async is powerful when done right.”

LINQ Done Right

LINQ is powerful but easy to misuse. Common mistakes make queries 100x slower. Learn to write fast LINQ.

Mistake 1: Multiple Enumerations

//  BAD: Query executed 3 times!
var query = users.Where(u => u.Age > 18);  // Not executed yet (deferred)

var count = query.Count();      // Executes query
var first = query.First();      // Executes query again
var list = query.ToList();      // Executes query again!

// If users is IQueryable (EF Core), 3 database queries!

//  GOOD: Materialize once
var activeUsers = users.Where(u => u.Age > 18).ToList();

var count = activeUsers.Count;  // In-memory
var first = activeUsers.First();  // In-memory

Mistake 2: Count() vs Any()

//  BAD: Counts all items just to check if > 0
if (users.Count() > 0)
{
    // Process
}

//  GOOD: Stops at first item
if (users.Any())
{
    // Process
}

// Database query comparison:
// Count(): SELECT COUNT(*) FROM Users  (scans entire table)
// Any(): SELECT TOP 1 FROM Users       (stops after 1 row)

//  BAD: Two operations
var user = users.Where(u => u.Id == 123).FirstOrDefault();

//  GOOD: Single operation with predicate
var user = users.FirstOrDefault(u => u.Id == 123);

// Database query:
// Where + First: Generates complex query
// FirstOrDefault(predicate): SELECT TOP 1 ... WHERE Id = 123

Mistake 4: Calling ToList() Too Early

//  BAD: Loads all users into memory, then filters
var activeUsers = context.Users
    .ToList()  // Loads ALL users from database
    .Where(u => u.IsActive)
    .Take(10);

//  GOOD: Filter in database, load only needed
var activeUsers = context.Users
    .Where(u => u.IsActive)
    .Take(10)
    .ToList();  // Only loads 10 users

// Database query:
// Bad: SELECT * FROM Users (gets 1M rows)
// Good: SELECT TOP 10 * FROM Users WHERE IsActive = 1

Mistake 5: String Operations in Queries

//  BAD: Can't translate to SQL, loads all users
var users = context.Users
    .Where(u => u.Name.ToUpper() == searchTerm.ToUpper())
    .ToList();

//  GOOD: Use Contains for case-insensitive search
var users = context.Users
    .Where(u => EF.Functions.Like(u.Name, $"%{searchTerm}%"))
    .ToList();

// Or for exact match (case-insensitive)
var users = context.Users
    .Where(u => u.Name.ToLower() == searchTerm.ToLower())
    .ToList();

//  BAD: 1 query for users + N queries for orders
var users = context.Users.ToList();
foreach (var user in users)  // 100 users
{
    var orders = context.Orders
        .Where(o => o.UserId == user.Id)
        .ToList();  // Query executed 100 times!
}
// Total: 101 database queries

//  GOOD: Use Include (eager loading)
var users = context.Users
    .Include(u => u.Orders)
    .ToList();
// Total: 1 database query with JOIN

Best Practices

Optimized Query Example

//  BEST: All optimizations applied
var recentOrders = context.Orders
    .AsNoTracking()  // Read-only, faster
    .Where(o => o.CreatedAt > DateTime.Now.AddDays(-30))  // Filter in DB
    .Include(o => o.User)  // Eager load related data
    .Select(o => new OrderDto  // Project to DTO
    {
        Id = o.Id,
        UserName = o.User.Name,
        Total = o.Total,
        Date = o.CreatedAt
    })
    .Take(100)  // Limit results
    .ToList();  // Materialize once

// Single efficient database query
// No N+1 problem
// Only needed columns selected
// No change tracking overhead

// See generated SQL (EF Core)
var query = context.Users.Where(u => u.IsActive);
var sql = query.ToQueryString();
Console.WriteLine(sql);

// Log all queries
// appsettings.json
{
  "Logging": {
    "LogLevel": {
      "Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  }
}

“Dashboard was loading in 8 seconds. Found Count() instead of Any(), N+1 queries, early ToList(). Fixed all LINQ mistakes. Now loads in 0.3 seconds. 27x faster with zero infrastructure changes.”

Switch on Steroids

Type casting everywhere? Nested if-else chains? Pattern matching makes type checks and complex conditions elegant.

Type Pattern (is)

//  Old way: Type check + cast
if (obj is string)
{
    string s = (string)obj;
    Console.WriteLine(s.ToUpper());
}

//  Pattern matching: Check and declare in one
if (obj is string s)
{
    Console.WriteLine(s.ToUpper());
}

// Works with null check too
if (obj is not null)
{
    // obj is definitely not null here
}

Switch Expressions

string GetDiscount(Customer customer)
{
    switch (customer.Type)
    {
        case CustomerType.Regular:
            return "5%";
        case CustomerType.Premium:
            return "10%";
        case CustomerType.VIP:
            return "20%";
        default:
            return "0%";
    }
}

string GetDiscount(Customer customer) => customer.Type switch
{
    CustomerType.Regular => "5%",
    CustomerType.Premium => "10%",
    CustomerType.VIP => "20%",
    _ => "0%"
};

// Concise, expression-based, returns value directly

Property Patterns

decimal CalculateShipping(Order order) => order switch
{
    // Match on properties
    { Total: > 100 } => 0,                    // Free shipping
    { Country: "US", Total: > 50 } => 5,      // US discount
    { Country: "US" } => 10,                  // US standard
    { IsPriority: true } => 25,               // Priority
    _ => 15                                   // Default
};

// Nested property patterns
string GetRisk(User user) => user switch
{
    { Age: < 18 } => "Minor",
    { Orders: { Count: > 100 }, AccountAge: > 365 } => "Trusted",
    { Orders: { Count: 0 }, AccountAge: < 7 } => "New",
    _ => "Regular"
};

Relational Patterns

string GetTemperatureDescription(int temp) => temp switch
{
    < 0 => "Freezing",
    >= 0 and < 10 => "Cold",
    >= 10 and < 20 => "Cool",
    >= 20 and < 30 => "Warm",
    >= 30 => "Hot"
};

// Or patterns
bool IsWeekend(DayOfWeek day) => day is DayOfWeek.Saturday or DayOfWeek.Sunday;

// Not pattern
bool IsWeekday(DayOfWeek day) => day is not (DayOfWeek.Saturday or DayOfWeek.Sunday);

Type Patterns in Switch

string Describe(object obj) => obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    DateTime dt => $"Date: {dt:yyyy-MM-dd}",
    int[] arr => $"Array with {arr.Length} elements",
    null => "Null",
    _ => "Unknown type"
};

// With property patterns
decimal CalculateArea(Shape shape) => shape switch
{
    Circle { Radius: var r } => Math.PI * r * r,
    Rectangle { Width: var w, Height: var h } => w * h,
    Square { Side: var s } => s * s,
    _ => 0
};

string Analyze(int[] numbers) => numbers switch
{
    [] => "Empty",
    [var single] => $"Single: {single}",
    [var first, var second] => $"Pair: {first}, {second}",
    [var first, .., var last] => $"Multiple: {first}...{last}",
    [1, 2, 3] => "Exactly 1, 2, 3",
    [var x, > 10, ..] => $"Starts with {x}, second > 10"
};

// Example usage
Analyze(new[] { 5 });           // "Single: 5"
Analyze(new[] { 1, 2 });        // "Pair: 1, 2"
Analyze(new[] { 1, 2, 3, 4 });  // "Multiple: 1...4"

// HTTP status code handling
string GetMessage(int statusCode) => statusCode switch
{
    200 => "OK",
    >= 200 and < 300 => "Success",
    404 => "Not Found",
    >= 400 and < 500 => "Client Error",
    >= 500 => "Server Error",
    _ => "Unknown"
};

// Validation with patterns
bool IsValidEmail(string? email) => email switch
{
    null or "" => false,
    { Length: > 100 } => false,
    var e when e.Contains('@') && e.Contains('.') => true,
    _ => false
};

“Refactored payment processor with pattern matching. 200 lines of if-else became 50 lines of switch expressions. Logic clear at a glance. New payment types? Add one line. Code reviews take 5 minutes now.”

Slice Arrays Like Python

Array.Copy() for slicing? Verbose. Index (^) and Range (..) operators make it elegant.

Index from End (^)

var numbers = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// Old way: Last element
var last = numbers[numbers.Length - 1];

// New way: ^1 means "1 from end"
var last = numbers[^1];  // 9

// Second from end
var secondLast = numbers[^2];  // 8

// Third from end
var third = numbers[^3];  // 7

Range Slicing (..)

var numbers = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// First 3 elements
var first3 = numbers[0..3];  // { 0, 1, 2 }

// Skip first 3, get rest
var rest = numbers[3..];  // { 3, 4, 5, 6, 7, 8, 9 }

// Last 3 elements
var last3 = numbers[^3..];  // { 7, 8, 9 }

// Everything except last 2
var allButLast2 = numbers[..^2];  // { 0, 1, 2, 3, 4, 5, 6, 7 }

// Middle elements (skip first 2 and last 2)
var middle = numbers[2..^2];  // { 2, 3, 4, 5, 6, 7 }

// All elements (copy)
var copy = numbers[..];

// String slicing
string text = "Hello, World!";
var hello = text[..5];  // "Hello"
var world = text[7..^1];  // "World"

// List slicing
var items = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var firstHalf = items[..5];  // { 1, 2, 3, 4, 5 }

// Pagination
int page = 2;
int pageSize = 3;
var pageItems = items[(page * pageSize)..((page + 1) * pageSize)];

// Remove header and footer
var lines = File.ReadAllLines("data.txt");
var dataOnly = lines[1..^1];  // Skip first and last line

“CSV parsing code was full of substring calculations. Switched to ranges. Code is 50% shorter, infinitely more readable. No more off-by-one errors.”

Write Less, Express More

Simple properties and methods don’t need full syntax. Expression bodies (=>) make code concise.

Before: Verbose Syntax

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    // Verbose property
    public string FullName
    {
        get { return $"{FirstName} {LastName}"; }
    }
    
    // Verbose method
    public string GetGreeting()
    {
        return $"Hello, {FirstName}!";
    }
    
    // Verbose readonly property
    public bool IsValid
    {
        get { return !string.IsNullOrEmpty(FirstName); }
    }
}

After: Expression Bodies

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    // Expression-bodied property
    public string FullName => $"{FirstName} {LastName}";
    
    // Expression-bodied method
    public string GetGreeting() => $"Hello, {FirstName}!";
    
    // Expression-bodied readonly property
    public bool IsValid => !string.IsNullOrEmpty(FirstName);
    
    // Works with getters and setters
    private string _email;
    public string Email
    {
        get => _email;
        set => _email = value?.ToLower();
    }
    
    // Constructors too!
    public User(string first, string last) => (FirstName, LastName) = (first, last);
}

public class Example
{
    // Properties
    public string Name => "Example";
    
    // Methods
    public int Add(int a, int b) => a + b;
    
    // Operators
    public static Example operator +(Example a, Example b) => new Example();
    
    // Indexers
    public string this[int index] => items[index];
    
    // Finalizers
    ~Example() => Console.WriteLine("Destroyed");
    
    // Events (add/remove)
    private EventHandler _changed;
    public event EventHandler Changed
    {
        add => _changed += value;
        remove => _changed -= value;
    }
}

“DTOs went from 200 lines to 80 lines. Same functionality. Expression bodies eliminated so much boilerplate. Code reviews focus on logic, not syntax.”