C# 14, .NET 10 & performance

#C# 10–14 and .NET 6–10 timeline

Separate language syntax from runtime and library features. C# 14 ships with the .NET 10 SDK; setting LangVersion alone cannot add missing runtime APIs.

.NET 10 is LTS, released November 2025 and supported through November 2028. .NET 8 and .NET 9 end support in November 2026; STS support became 24 months with .NET 9. Examples target net10.0 and C# 14.

#Records, required, init and primary constructors

A DTO needs explicit data without boilerplate; a service needs a dependency without a repetitive constructor. These tools reduce ceremony but do not replace validation or ownership design.

public record Price(decimal Amount, string Currency);           // (1)
public sealed class CreateProduct
{
    public required string Name { get; init; }                  // (2)
    public required decimal Price { get; init; }
}
public sealed class CouponService(TimeProvider clock)           // (3)
{
    public bool IsValid(DateTimeOffset expiry) => clock.GetUtcNow() < expiry;
}

// Statements below belong in a caller method.
var price = new Price(100m, "EGP");
var taxed = price with { Amount = 114m };                        // (4)
List<int> original = [10, 20];
int[] ids = [.. original, 30];                                  // (5)

Use a regular class when entity identity defines equality. required does not mean non-empty, and init on a List does not prevent Add. Validate input at runtime at API boundaries.

#Pattern matching: type, shape and value

Nested conditionals and casts obscure business rules. Patterns express conditions on data shape with an explicit case order; the first matching arm wins.

public record Parcel(decimal Total, string Country, decimal Weight);

static decimal Shipping(Parcel? order) => order switch
{
    null => throw new ArgumentNullException(nameof(order)),       // (1)
    { Total: >= 1000m } => 0m,                                  // (2)
    { Country: "EG", Weight: > 0m and <= 5m } => 50m,
    { Country: "SA" or "AE" } => 150m,
    _ => 300m                                                   // (3)
};

static string Describe(object? value) => value switch
{
    Price(> 0m, var currency) => currency,                       // (4)
    int[] [var first, .., var last] => $"{first}..{last}",        // (5)
    not null => "Other value",
    _ => "Missing"
};

static bool CanShip(string status, bool paid) =>
    (status, paid) is ("Ready", true);                           // (6)

Use explicit methods or strategies for large evolving rules or I/O. Avoid side effects in pattern-accessed getters, and validate weight separately from selecting a shipping fee.

#C# 14 extension properties and static extension members

Classic extension methods could not expose property syntax. Extension blocks group members for a type without modifying that type or adding state to it.

public static class ProductExtensions
{
    // Existing syntax still works.
    public static bool IsValidSku(this string sku) => sku.Length > 0;

    extension(string sku)                                  // (1)
    {
        public bool HasSkuText => !string.IsNullOrWhiteSpace(sku);
        public string NormalizeSku() => sku.Trim().ToUpperInvariant();
    }

    extension(string)                                      // (2)
    {
        public static string DefaultSku => "UNASSIGNED";
    }
}

// In a caller method with the extensions' namespace imported:
bool valid = " mug-01 ".HasSkuText;                         // (3)
string normalized = " mug-01 ".NormalizeSku();
string fallback = string.DefaultSku;                       // (4)

This is neither inheritance nor virtual dispatch and adds no instance fields. Real instance members take precedence. Reserve properties for clear, inexpensive calculations rather than hidden network calls. Extension members reference.

#C# 14 field, null-conditional assignment and nameof

Property validation used to need a manual backing field, and assigning through an optional object needed a null check. C# 14 shortens both without adding concurrency or complete validation guarantees.

public sealed class Product
{
    public string Sku
    {
        get;
        set => field = !string.IsNullOrWhiteSpace(value)    // (1)
            ? value.Trim().ToUpperInvariant()
            : throw new ArgumentException("SKU is required");
    } = "UNASSIGNED";
}

public sealed class Order { public string Status { get; set; } = "New"; }

// In a caller method:
Order? order = null;
order?.Status = CreateStatus();                            // (2)
string typeName = nameof(List<>);                          // (3) "List"

static string CreateStatus() => "Ready";

Manual backing fields, explicit null checks and nameof(List<int>) remain valid. Disambiguate an existing member named field with this.field or @field. Do not silently skip an assignment when a missing order should be an error.

#C# 14 lambda modifiers, partial members and compound assignment

Some features primarily serve libraries and generators. Understand their purpose and limits rather than rewriting application code for novelty.

public delegate bool TryRead(string text, out int result);
// In a caller method:
// TryRead parse = (text, out result) => int.TryParse(text, out result); // (1)

public partial class OrderNotice
{
    public partial OrderNotice(string id);                  // (2) definition
    public partial event EventHandler? Sent;
}
public partial class OrderNotice
{
    private readonly string _id;
    private EventHandler? _sent;
    public partial OrderNotice(string id) { _id = id; }     // implementation
    public partial event EventHandler? Sent                // (3)
    {
        add => _sent += value;
        remove => _sent -= value;
    }
    public void Send() => _sent?.Invoke(this, EventArgs.Empty);
}

public sealed class InvoiceTotal
{
    public decimal Amount { get; private set; }
    public void operator +=(decimal amount)                 // (4)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(amount);
        Amount += amount;
    }
}
// Caller: var total = new InvoiceTotal(); total += 25m;

Previously += relied on operator + followed by assignment. The new form may mutate an object shared through aliases; document that behavior and avoid it for an immutable value object. Generators are optional when both partial declarations are handwritten. Partial members and compound assignment reference.

#Old versus new: choices with reasons

Use the table to explain trade-offs rather than declaring old code wrong by age. Migrate when requirements, compatibility and cost justify it.

// Web project; packages: Microsoft.AspNetCore.OpenApi, Scalar.AspNetCore.
using Scalar.AspNetCore;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenApi();                          // (1)
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();                                  // (2)
    app.MapScalarApiReference();                        // (3)
}
app.MapGet("/products/{id:int}", (int id) => new { Id = id });
app.Run();

ASP.NET Core OpenAPI and Scalar integration.

#Span, Memory, stackalloc and ArrayPool

static int SumCsv(ReadOnlySpan<char> csv)
{
    int total = 0;
    foreach (Range range in csv.Split(','))                 // (1) .NET 9+
        total += int.Parse(csv[range]);
    return total;
}

static bool StartsWithValue<T>(ReadOnlySpan<T> values, T value)
    where T : IEquatable<T> =>
    !values.IsEmpty && values[0].Equals(value);

// In a caller method:
int[] ids = [10, 20];
bool starts = StartsWithValue(ids, 10);                      // (2) C# 14
Span<int> scratch = stackalloc int[32];                      // (3)
scratch.Clear();

static async Task CopyAsync(Stream source, Stream destination,
    CancellationToken ct)
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(16 * 1024); // (4)
    try
    {
        Memory<byte> memory = rented.AsMemory(0, 16 * 1024);
        int read;
        while ((read = await source.ReadAsync(memory, ct)) != 0)
            await destination.WriteAsync(memory[..read], ct); // (5)
    }
    finally { ArrayPool<byte>.Shared.Return(rented, clearArray: true); }
}

Span is a ref struct and cannot be a class field or remain live across await. From C# 13 it can be used in async method regions that do not cross suspension. Memory does not automatically own its lifetime, and a consumer must not retain a pooled buffer after Return. C# 14 span conversions.

#Measure first: BenchmarkDotNet and profiling

A slow endpoint may be waiting for SQL rather than needing Span. Start with traces to locate the stage, profile the hot path, then microbenchmark the relevant implementations.

// Console project; add the BenchmarkDotNet package.
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkRunner.Run<CsvBenchmarks>();                      // (1)

[MemoryDiagnoser]
public class CsvBenchmarks
{
    private const string Csv = "12,7,30,44,5,9,100";

    [Benchmark(Baseline = true)]
    public int Split() => Csv.Split(',').Sum(int.Parse);    // (2)

    [Benchmark]
    public int Span()
    {
        int total = 0;
        ReadOnlySpan<char> input = Csv;
        foreach (Range range in input.Split(','))
            total += int.Parse(input[range]);              // (3)
        return total;
    }
}

dotnet run -c Release

Test varied sizes and malformed input, and examine mean, variability and allocated bytes. A microbenchmark cannot establish p99 improvement under load. Use dotnet-counters for GC and thread-pool behavior, dotnet-trace for CPU analysis and load testing for application impact. BenchmarkDotNet documentation.

#Source generators and ValueTask: remove measured costs

Runtime reflection is useful, but repeated metadata discovery can sometimes move to the build. Source generators add C# during compilation. ValueTask addresses a different cost: Task allocation in operations that frequently finish synchronously.

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;

public record ProductDto(int Id, string Name);

[JsonSerializable(typeof(ProductDto))]                    // (1)
public partial class ProductJson : JsonSerializerContext { }

public static partial class ProductPatterns
{
    [GeneratedRegex("^[A-Z]{3}-[0-9]{4}$")]
    public static partial Regex Sku();                   // (2)
}

// In a caller method:
// string json = JsonSerializer.Serialize(
//     new ProductDto(1, "Mug"), ProductJson.Default.ProductDto);

public sealed class StockReader
{
    public ValueTask<int> ReadAsync(int? cached, CancellationToken ct) =>
        cached is int count                              // (3)
            ? ValueTask.FromResult(count)
            : new ValueTask<int>(LoadAsync(ct));

    private static async Task<int> LoadAsync(CancellationToken ct)
    {
        await Task.Delay(10, ct); // stand-in for an asynchronous data source
        return 0;
    }
}

Default to Task for async APIs. Consume a ValueTask once; if repeated awaits or composition are needed, convert it to a Task once and retain that Task. A generator does not make every dependency AOT-safe. Other examples include LoggerMessage and Mapperly; inspect generated code and diagnostics.

#Native AOT deployment trade-offs

For a CLI or short-lived service that repeatedly pays startup cost, Native AOT moves compilation to publishing. It does not automatically fix a database bottleneck.

dotnet publish -c Release -r linux-x64 -p:PublishAot=true

The command targets an OS and architecture and needs a suitable native toolchain. The executable has no JIT but still links GC and runtime services. Test the published artifact and resolve trimming and AOT warnings rather than suppressing them indiscriminately.

ReadyToRun reduces startup work while retaining JIT; JIT can exploit dynamic PGO at runtime. See topic 03: runtime. AOT is not guaranteed smaller or faster for every workload.

#File-based apps and Aspire: different jobs

A small invoice conversion tool may not need a solution. An API with Redis and a database needs coordinated dependencies locally. File-based apps simplify the former; Aspire coordinates the latter.

// app.cs; .NET 10 SDK. Package restore requires network access or a cache.
#:package Humanizer@2.14.1                                  // (1)
using Humanizer;
Console.WriteLine(TimeSpan.FromMinutes(90).Humanize());

dotnet run app.cs
# Use --file explicitly if the directory also contains a project.
dotnet run --file app.cs

// AppHost project with Aspire.Hosting.Redis and a reference to Store.Api.
var builder = DistributedApplication.CreateBuilder(args);
var cache = builder.AddRedis("cache");                      // (2)
builder.AddProject<Projects.Store_Api>("api")
    .WithReference(cache)                                  // (3)
    .WaitFor(cache);
builder.Build().Run();

When added to services, ServiceDefaults provides telemetry, health checks and resilience defaults; the dashboard collects logs, traces and metrics. Aspire, formerly .NET Aspire, supports local orchestration; production publishing needs a chosen target and separate configuration. Convert a growing tool into an ordinary project when modules and tests warrant it. File-based apps and Aspire overview.