What's New in .NET 9: Key Features Every Backend Developer Should Know

dotnet add package Microsoft.AspNetCore.OpenApi

// Program.cs
builder.Services.AddOpenApi();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();          // serves /openapi/v1.json
    app.UseSwaggerUI(options =>
        options.SwaggerEndpoint("/openapi/v1.json", "v1"));
}

app.MapGet("/orders/{id}", async (Guid id, AppDbContext db) =>
{
    var order = await db.Orders.FindAsync(id);
    return order is null ? Results.NotFound() : Results.Ok(order);
})
.WithName("GetOrder")
.WithDescription("Get an order by ID")
.WithTags("Orders")
.Produces<Order>()
.Produces(404);

builder.Services.AddOpenApi(options =>
{
    options.AddDocumentTransformer((document, context, ct) =>
    {
        document.Info.Title   = "OrderFlow API";
        document.Info.Version = "v1";
        document.Info.Contact = new() { Email = "api@orderflow.com" };
        return Task.CompletedTask;
    });
});

dotnet add package Microsoft.Extensions.Caching.Hybrid

// Registration
builder.Services.AddHybridCache(options =>
{
    options.DefaultEntryOptions = new HybridCacheEntryOptions
    {
        Expiration         = TimeSpan.FromMinutes(5),
        LocalCacheExpiration = TimeSpan.FromMinutes(1)  // L1 expires sooner
    };
});

// Optional: back with Redis for L2
builder.Services.AddStackExchangeRedisCache(opt =>
    opt.Configuration = builder.Configuration.GetConnectionString("Redis"));

// Usage
public class ProductService
{
    private readonly HybridCache _cache;
    private readonly AppDbContext _db;

    public async Task<Product?> GetProductAsync(int id, CancellationToken ct)
    {
        return await _cache.GetOrCreateAsync(
            $"product:{id}",
            async token => await _db.Products.FindAsync(id, token),
            cancellationToken: ct);
    }

    public async Task InvalidateAsync(int id)
    {
        await _cache.RemoveAsync($"product:{id}");
    }
}

// Before .NET 9 — you had to use WhenAny in a loop
var tasks = new[] { FetchAAsync(), FetchBAsync(), FetchCAsync() };
while (tasks.Length > 0)
{
    var completed = await Task.WhenAny(tasks);
    ProcessResult(await completed);
    tasks = tasks.Where(t => t != completed).ToArray();
}

// .NET 9 — clean and readable
await foreach (var task in Task.WhenEach(FetchAAsync(), FetchBAsync(), FetchCAsync()))
{
    ProcessResult(await task);
}

// Count elements by key — without materialising a full GroupBy
var countByStatus = orders.CountBy(o => o.Status);
// Returns IEnumerable<KeyValuePair<string, int>>

foreach (var (status, count) in countByStatus)
    Console.WriteLine($"{status}: {count}");

// Aggregate by key without GroupBy + Select
var totalByCustomer = orders.AggregateBy(
    keySelector: o => o.CustomerId,
    seed: 0m,
    func: (total, order) => total + order.Amount);

// Get element with its index without a counter variable
foreach (var (index, order) in orders.Index())
    Console.WriteLine($"{index}: {order.Id}");

// Before
int[] array  = new int[] { 1, 2, 3 };
List<int> list = new List<int> { 1, 2, 3 };

// C# 12 collection expressions (also in .NET 8)
int[] array = [1, 2, 3];
List<int> list = [1, 2, 3];
Span<int> span = [1, 2, 3];

// Spread operator
int[] first  = [1, 2, 3];
int[] second = [4, 5, 6];
int[] all    = [..first, ..second, 7]; // [1,2,3,4,5,6,7]

// Works with custom collections too
ImmutableArray<string> names = ["Alice", "Bob", "Charlie"];

// Now accepts span, list, or array directly
public void Log(params ReadOnlySpan<string> messages) { }
public void Process(params IEnumerable<int> ids) { }

// Call with a list without .ToArray()
var ids = new List<int> { 1, 2, 3 };
Process(ids);  // works in .NET 9

// This generates efficient binding code at compile time
app.MapGet("/orders/{id}", async (Guid id, AppDbContext db, CancellationToken ct) =>
    await db.Orders.FindAsync(id, ct) is { } order
        ? Results.Ok(order)
        : Results.NotFound());

app.MapGet("/orders/{id}", async Task<Results<Ok<Order>, NotFound>> (Guid id, AppDbContext db) =>
{
    var order = await db.Orders.FindAsync(id);
    return order is null ? TypedResults.NotFound() : TypedResults.Ok(order);
});

<!-- .csproj -->
<PublishAot>true</PublishAot>

dotnet publish -r linux-x64 -c Release
# Output: ~15MB self-contained native binary
# Start time: <50ms (vs 200ms+ for JIT)

// Access a private field with no overhead (replaces reflection for testing/AOT)
[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_balance")]
extern static ref decimal GetBalance(BankAccount account);

var account = new BankAccount();
ref decimal balance = ref GetBalance(account);
balance = 1000; // direct access, no reflection

// Register multiple implementations with a key
builder.Services.AddKeyedScoped<INotificationSender, EmailSender>("email");
builder.Services.AddKeyedScoped<INotificationSender, SmsSender>("sms");
builder.Services.AddKeyedScoped<INotificationSender, PushSender>("push");

// Resolve by key
public class NotificationService([FromKeyedServices("email")] INotificationSender email,
                                  [FromKeyedServices("sms")]   INotificationSender sms)
{
    // use specific implementations
}

<!-- .csproj — update TargetFramework -->
<TargetFramework>net9.0</TargetFramework>

# Update NuGet packages to 9.x
dotnet outdated --upgrade