Newsletter Archive

using System.Runtime.CompilerServices;

public static class Guard
{
    public static void NotNull<T>(
        T? value,
        [CallerArgumentExpression(nameof(value))] string? expression = null)
        where T : class
    {
        if (value is null)
            throw new ArgumentNullException(expression, $"'{expression}' must not be null.");
    }

    public static void MustBePositive(
        int value,
        [CallerArgumentExpression(nameof(value))] string? expression = null)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(expression,
                $"'{expression}' must be positive, but was {value}.");
    }
}

var order = GetOrder();
Guard.NotNull(order.Customer);
// Throws: "'order.Customer' must not be null."

Guard.MustBePositive(order.LineItems.Count - discountItems);
// Throws: "'order.LineItems.Count - discountItems' must be positive, but was -2."

public static class Require
{
    public static void That(
        bool condition,
        [CallerArgumentExpression(nameof(condition))] string? expression = null)
    {
        if (!condition)
            throw new InvalidOperationException(
                $"Precondition failed: {expression}");
    }
}

Require.That(user.Age >= 18);
// Throws: "Precondition failed: user.Age >= 18"

Require.That(startDate < endDate);
// Throws: "Precondition failed: startDate < endDate"

Require.That(retryCount <= maxRetries);
// Throws: "Precondition failed: retryCount <= maxRetries"

StartingAsync  →  StartAsync  →  StartedAsync
                                      ↓
                            (app is running)
                                      ↓
StoppingAsync  →  StopAsync  →  StoppedAsync

public class OrderProcessingService(
    IServiceScopeFactory scopeFactory,
    Channel<Order> orderChannel,
    ILogger<OrderProcessingService> logger) : IHostedLifecycleService
{
    private Task? _processingTask;
    private CancellationTokenSource? _cts;

    // Called BEFORE the host marks itself as started
    public Task StartingAsync(CancellationToken ct)
    {
        logger.LogInformation("Preparing order processor...");
        return Task.CompletedTask;
    }

    public Task StartAsync(CancellationToken ct)
    {
        _cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
        _processingTask = ProcessOrdersAsync(_cts.Token);
        return Task.CompletedTask;
    }

    // Called AFTER the host is fully started (Kestrel is listening, etc.)
    public async Task StartedAsync(CancellationToken ct)
    {
        logger.LogInformation("Host is ready. Warming the product cache...");

        using var scope = scopeFactory.CreateScope();
        var cache = scope.ServiceProvider.GetRequiredService<IProductCache>();
        await cache.WarmAsync(ct);

        logger.LogInformation("Cache warmed. Ready to process orders.");
    }

    // Called BEFORE StopAsync — signal your work to wind down
    public Task StoppingAsync(CancellationToken ct)
    {
        logger.LogInformation("Shutdown signal received. Completing channel...");
        orderChannel.Writer.Complete();
        return Task.CompletedTask;
    }

    public async Task StopAsync(CancellationToken ct)
    {
        if (_processingTask is not null)
        {
            _cts?.Cancel();
            await _processingTask;
        }
    }

    // Called AFTER StopAsync — final cleanup
    public Task StoppedAsync(CancellationToken ct)
    {
        logger.LogInformation("Order processor fully stopped. All items flushed.");
        _cts?.Dispose();
        return Task.CompletedTask;
    }

    private async Task ProcessOrdersAsync(CancellationToken ct)
    {
        await foreach (var order in orderChannel.Reader.ReadAllAsync(ct))
        {
            await ProcessOrderAsync(order);
        }
    }

    private Task ProcessOrderAsync(Order order)
    {
        logger.LogInformation("Processed order {Id}", order.Id);
        return Task.CompletedTask;
    }
}

builder.Services.AddHostedService<OrderProcessingService>();

using System.Runtime.CompilerServices;

// The class under test — you don't control this
public class ConnectionPool
{
    private readonly List<Connection> _connections = [];
    private int _activeCount;

    public void Acquire() { /* ... */ _activeCount++; }
    public void Release() { /* ... */ _activeCount--; }
}

// In your test project — zero-cost accessor
public partial class ConnectionPoolTests
{
    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_activeCount")]
    private static extern ref int GetActiveCount(ConnectionPool pool);

    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_connections")]
    private static extern ref List<Connection> GetConnections(ConnectionPool pool);

    [Fact]
    public void Acquire_IncrementsActiveCount()
    {
        var pool = new ConnectionPool();

        pool.Acquire();
        pool.Acquire();

        Assert.Equal(2, GetActiveCount(pool));
    }

    [Fact]
    public void Release_DecrementsActiveCount()
    {
        var pool = new ConnectionPool();
        pool.Acquire();

        pool.Release();

        Assert.Equal(0, GetActiveCount(pool));
    }
}

public class EmailService
{
    private string SanitizeAddress(string email)
        => email.Trim().ToLowerInvariant();
}

// Test accessor
[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "SanitizeAddress")]
private static extern string CallSanitize(EmailService service, string email);

[Fact]
public void SanitizeAddress_TrimsAndLowercases()
{
    var service = new EmailService();

    var result = CallSanitize(service, "  [email protected]  ");

    Assert.Equal("[email protected]", result);
}

public class RateLimiter
{
    private static int _globalRequestCount;
}

[UnsafeAccessor(UnsafeAccessorKind.StaticField, Name = "_globalRequestCount")]
private static extern ref int GetGlobalCount(RateLimiter? _);

[Fact]
public void Test_GlobalCount()
{
    // Pass null for static accessors — the instance isn't used
    ref int count = ref GetGlobalCount(null);
    Assert.Equal(0, count);
}