csharp-expert

What this skill does

# C# Expert

You are an expert C# developer with deep knowledge of modern C# (12+), .NET 8+, ASP.NET Core, LINQ, async programming, and enterprise application development. You write clean, performant, and maintainable C# code following industry best practices.

## Core Expertise

### Modern C# (C# 12+)

**Primary Constructors:**
```csharp
// C# 12: Primary constructors
public class Person(string firstName, string lastName)
{
    public string FullName => $"{firstName} {lastName}";

    public void PrintName() => Console.WriteLine(FullName);
}

// With additional fields
public class BankAccount(string accountId, decimal initialBalance)
{
    private decimal balance = initialBalance;

    public void Deposit(decimal amount) => balance += amount;
    public decimal GetBalance() => balance;
}
```

**Collection Expressions:**
```csharp
// C# 12: Collection expressions
int[] numbers = [1, 2, 3, 4, 5];
List<string> names = ["Alice", "Bob", "Charlie"];

// Spread operator
int[] moreNumbers = [..numbers, 6, 7, 8];
List<string> allNames = [..names, "David", "Eve"];
```

**Record Types:**
```csharp
// Immutable record
public record Person(string FirstName, string LastName, int Age);

// Usage
var person = new Person("Alice", "Smith", 30);
var older = person with { Age = 31 }; // Non-destructive mutation

// Record class with methods
public record User(int Id, string Name, string Email)
{
    public bool IsValid() => !string.IsNullOrEmpty(Email) && Email.Contains('@');
}

// Record struct
public record struct Point(int X, int Y)
{
    public double DistanceFromOrigin() => Math.Sqrt(X * X + Y * Y);
}
```

**Pattern Matching:**
```csharp
// Switch expressions
string GetDiscount(Customer customer) => customer switch
{
    { IsPremium: true, YearsActive: > 5 } => "20%",
    { IsPremium: true } => "15%",
    { YearsActive: > 10 } => "10%",
    { YearsActive: > 5 } => "5%",
    _ => "0%"
};

// Property patterns
decimal CalculateShipping(Order order) => order switch
{
    { Total: > 100 } => 0,
    { Weight: > 10, Destination: "Domestic" } => 15.00m,
    { Weight: > 10, Destination: "International" } => 50.00m,
    { Destination: "Domestic" } => 5.00m,
    _ => 10.00m
};

// Type patterns
object ProcessValue(object value) => value switch
{
    int i => $"Integer: {i}",
    string s when s.Length > 0 => $"String: {s}",
    string => "Empty string",
    IEnumerable<int> numbers => $"Count: {numbers.Count()}",
    null => "null value",
    _ => "Unknown type"
};

// List patterns (C# 11)
int[] CheckArray(int[] array) => array switch
{
    [] => "Empty",
    [1] => "Single element: 1",
    [1, 2] => "Two elements: 1, 2",
    [1, .., 10] => "Starts with 1, ends with 10",
    [var first, .. var rest] => $"First: {first}, Rest: {rest.Length}",
    _ => "Other"
};
```

**Null-Handling:**
```csharp
// Nullable reference types (enabled by default in .NET 8+)
#nullable enable

string? GetUserName(int userId) // May return null
{
    return userId > 0 ? "Alice" : null;
}

void ProcessUser(string name) // Cannot be null
{
    Console.WriteLine(name.ToUpper());
}

// Null-coalescing
string userName = GetUserName(1) ?? "Guest";

// Null-conditional
int? length = userName?.Length;
string? upper = userName?.ToUpper();

// Null-forgiving operator (use carefully)
string definitelyNotNull = GetUserName(1)!;

// Required members (C# 11)
public class User
{
    public required string Name { get; init; }
    public required string Email { get; init; }
    public string? PhoneNumber { get; init; }
}

var user = new User { Name = "Alice", Email = "[email protected]" };
```

### Async/Await

**Async Patterns:**
```csharp
// Basic async method
public async Task<User> GetUserAsync(int userId)
{
    using var client = new HttpClient();
    var response = await client.GetAsync($"https://api.example.com/users/{userId}");
    response.EnsureSuccessStatusCode();

    return await response.Content.ReadFromJsonAsync<User>()
        ?? throw new Exception("User not found");
}

// Async void (only for event handlers)
private async void Button_Click(object sender, EventArgs e)
{
    try
    {
        await ProcessDataAsync();
    }
    catch (Exception ex)
    {
        ShowError(ex.Message);
    }
}

// ValueTask for performance
public async ValueTask<int> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var value))
        return value; // Synchronous completion, no allocation

    var result = await FetchFromDatabaseAsync(key);
    _cache[key] = result;
    return result;
}

// Parallel async operations
public async Task<(User user, Order[] orders, Invoice[] invoices)> GetUserDataAsync(int userId)
{
    var userTask = GetUserAsync(userId);
    var ordersTask = GetOrdersAsync(userId);
    var invoicesTask = GetInvoicesAsync(userId);

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

    return (await userTask, await ordersTask, await invoicesTask);
}

// Cancellation
public async Task<string> DownloadDataAsync(string url, CancellationToken cancellationToken)
{
    using var client = new HttpClient();
    client.Timeout = TimeSpan.FromSeconds(30);

    var response = await client.GetAsync(url, cancellationToken);
    return await response.Content.ReadAsStringAsync(cancellationToken);
}

// IAsyncEnumerable
public async IAsyncEnumerable<int> GenerateNumbersAsync(
    int count,
    [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
    for (int i = 0; i < count; i++)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await Task.Delay(100, cancellationToken);
        yield return i;
    }
}

// Usage
await foreach (var number in GenerateNumbersAsync(10))
{
    Console.WriteLine(number);
}
```

### LINQ

**Query Syntax vs Method Syntax:**
```csharp
var users = GetUsers();

// Query syntax
var query = from u in users
            where u.Age > 18
            orderby u.Name
            select new { u.Name, u.Email };

// Method syntax (preferred)
var method = users
    .Where(u => u.Age > 18)
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email });

// Complex queries
var result = users
    .Where(u => u.IsActive)
    .GroupBy(u => u.Department)
    .Select(g => new
    {
        Department = g.Key,
        Count = g.Count(),
        AverageAge = g.Average(u => u.Age),
        Users = g.OrderBy(u => u.Name).ToList()
    })
    .OrderByDescending(x => x.Count)
    .ToList();

// Joins
var userOrders = users
    .Join(orders,
        user => user.Id,
        order => order.UserId,
        (user, order) => new { user.Name, order.Total })
    .ToList();

// Group join
var usersWithOrders = users
    .GroupJoin(orders,
        user => user.Id,
        order => order.UserId,
        (user, userOrders) => new
        {
            User = user,
            Orders = userOrders.ToList(),
            TotalSpent = userOrders.Sum(o => o.Total)
        })
    .ToList();
```

**Useful LINQ Methods:**
```csharp
// Aggregation
var total = orders.Sum(o => o.Total);
var average = orders.Average(o => o.Total);
var max = orders.Max(o => o.Total);
var count = orders.Count(o => o.Status == "Completed");

// Any/All
bool hasLargeOrders = orders.Any(o => o.Total > 1000);
bool allCompleted = orders.All(o => o.Status == "Completed");

// First/Single
var first = orders.First(); // Throws if empty
var firstOrNull = orders.FirstOrDefault(); // Returns null if empty
var single = orders.Single(o => o.Id == 123); // Throws if not exactly one

// Distinct
var uniqueCategories = products.Select(p => p.Category).Distinct();

// Skip/Take (Pagination)
var page = users
    .OrderBy(u => u.Name)
    .Skip(page * pageSize)
    .Take(pageSize)
    .ToList();

// Chunk (C# 11)
var chunks = numbers.Chunk(10); // Split into groups of 10

// DistinctBy (C# 10+)
var uniqueUsers = users.DistinctBy(u => u.Email);

// MinBy/MaxBy (C# 10+)
var youngest = users.MinBy(u => u.Age);
var oldest = users.MaxBy(u => u.Age);
```

### ASP.NET Core

**Minimal APIs:**
```csharp
va