C#

Modern C# development with .NET 8+, async patterns, and Entity Framework.

When to Use

• Enterprise Web Backends & Microservices: Building high-throughput ASP.NET Core web APIs and gRPC microservices on modern .NET 8/9.
• Cross-Platform Mobile & Desktop (MAUI): Compiling native iOS, Android, macOS, and Windows applications from a single C# codebase.
• Cloud-Native AWS & Azure Infrastructure: Deploying scalable serverless functions, containerized workers, and event-driven apps.
• Game Development with Unity / Godot: Developing gameplay logic, physics, and state machines in leading game engines.

Quick Start

public record User(string Id, string Name, string Email);

public class UserService
{
    public async Task<User?> GetUserAsync(string id)
    {
        return await _repository.FindByIdAsync(id);
    }
}

Core Concepts

Records & Pattern Matching (C# 12/13)

Immutable data structures with value equality and expressive switch expressions:

// Positional Record with built-in value equality
public record Order(string Id, decimal Amount, string Status);

public static class OrderClassifier
{
    public static string Evaluate(Order order) => order switch
    {
        { Status: "PAID", Amount: > 1000 } => "High-Value Order",
        { Status: "PAID" }                 => "Standard Order",
        { Status: "CANCELLED" }            => "Void Order",
        _                                  => "Pending Review"
    };
}

Memory Optimization with Span<T> and ReadOnlySpan<T>

Allocates and slices continuous memory buffers on the stack without heap GC allocations:

public static bool TryParseYear(ReadOnlySpan<char> dateSpan, out int year)
{
    // Slice without allocating new sub-strings
    ReadOnlySpan<char> yearSpan = dateSpan.Slice(0, 4);
    return int.TryParse(yearSpan, out year);
}

Async / Await with ValueTask

Efficient asynchronous programming minimizing task object allocations on hot paths:

public async ValueTask<UserProfile> GetUserProfileAsync(string userId)
{
    if (_cache.TryGetValue(userId, out var cached))
        return cached; // Synchronous return allocates zero task objects

    return await _repository.FetchFromDatabaseAsync(userId);
}

Common Patterns

Declarative Data Transformations with LINQ

Problem: Imperative nested loops and mutation when filtering, projecting, and sorting collections.

Solution:

// Query syntax
var adults = from user in users
             where user.Age >= 18
             orderby user.Name
             select user;

// Method syntax (preferred)
var result = users
    .Where(u => u.IsActive)
    .OrderBy(u => u.Name)
    .Select(u => new UserDto(u.Id, u.Name))
    .ToList();

// Grouping
var byCountry = users
    .GroupBy(u => u.Country)
    .ToDictionary(g => g.Key, g => g.ToList());

Pattern Matching

Problem: Verbose cascading conditional checks and manual type casting leading to runtime type errors.

Solution:

string GetStatus(object obj) => obj switch
{
    User { IsActive: true } => "Active user",
    User { IsActive: false } => "Inactive user",
    null => "No data",
    _ => "Unknown"
};

// List patterns
if (numbers is [var first, _, var last])
{
    Console.WriteLine($"First: {first}, Last: {last}");
}

Best Practices

Do:

• Enable Nullable Reference Types (<Nullable>enable</Nullable>): Catch null reference exceptions at compile time across the codebase.
• Use Dependency Injection & Options Pattern: Inject strongly-typed configurations via IOptions<T> and constructor injection.
• Use ValueTask<T> on Frequently Cached Code Paths: Reduce GC allocations by returning ValueTask when operations often complete synchronously.
• Leverage Native AOT Compilation: Compile .NET applications to native machine code (PublishAot=true) for sub-10ms startup and tiny memory footprints.

Don't:

• Block async code with .Result or .Wait(): Synchronous blocking on asynchronous tasks causes immediate thread pool deadlocks.
• Use mutable shared singletons without thread safety: Use ConcurrentDictionary or proper synchronization primitives.
• Instantiate HttpClient per request: Use IHttpClientFactory to prevent socket exhaustion.

Troubleshooting

References

• Microsoft .NET Docs
• C# Programming Guide