.NET 11 includes changes to C# syntax (some would say going a bit too far), ASP.NET Core request handling, and the machinery behind async methods. The eleven examples below show how those changes can change and improve code written for .NET 10.

I’ve even created a lovely sample project on GitHub that has a `net10-old` and a `net11-new` directory for each feature. The older project shows the approach available in .NET 10; the newer one demonstrates the .NET 11addition. You can directly run the samples below from the GitHub solution!

C# 15

1. Collection expression arguments

In the first example we use our list of YouTube subscribers as a demo.

A collection expression can now start with with(...) to pass arguments to the underlying constructor or factory. Capacity and comparer choices can sit inside the initializer. C# collection expression documentation.

Here the list reserves room for twice the initial subscriber count. The set treats differently capitalized greetings as equal. In .NET 10, constructing the list and adding its contents are separate operations.

.NET 10

string[] names = ["Gary", "Barry", "Nigel"]; 

List<string> subscribers = new(capacity: names.Length * 2);
subscribers.AddRange(names);

Console.WriteLine($"YouTube subscribers: {string.Join(", ", subscribers)}; capacity: {subscribers.Capacity}");

.NET 11

string[] names = ["Gary", "Barry", "Nigel"];

List<string> subscribers = [with(capacity: names.Length * 2), .. names];

Console.WriteLine($"YouTube subscribers: {string.Join(", ", subscribers)}; capacity: {subscribers.Capacity}");

The C# 15 version supplies the list capacity and set comparer through with(...). Both programs print:

YouTube subscribers: Gary, Barry, Nigel; capacity: 6

C# is starting to look like another programming language and whilst useful I think this new stuff needs to be toned down. Being able to combine those initial values with constructor arguments is useful but let’s stop yeah.

2. Union types

Finally, union types - which we had to wait for AI to “end coding for good” to actually get. Previously switch statements would get warnings without fallback default arms as the types couldn’t be exhaustive.

C# 15 can declare the case set explicitly with public union Result(Success, Failure);. Case types convert implicitly into the union, and switch expressions receive exhaustiveness checking. C# union type documentation.

.NET 10

Result result = new Success("Thanks for subscribing on YouTube!");
Console.WriteLine(Describe(result));

static string Describe(Result result) => result switch
{
    Success(var message) => message,
    Failure(var code) => $"Error {code}",
    _ => throw new ArgumentOutOfRangeException(nameof(result))
};

// C# 14: an inheritance hierarchy approximates a fixed set of cases.
// The compiler cannot prove these are all possible subclasses.
public abstract record Result;
public sealed record Success(string Message) : Result;
public sealed record Failure(int ErrorCode) : Result;

.NET 11

Result result = new Success("Thanks for subscribing on YouTube!");
Console.WriteLine(Describe(result));

static string Describe(Result result) => result switch
{
    Success(var message) => message,
    Failure(var code) => $"Error {code}"
};

public record Success(string Message);
public record Failure(int ErrorCode);

// C# 15: a value can be exactly one of the declared case types.
public union Result(Success, Failure);

Both programs print Thanks for subscribing on YouTube!. The .NET 11 switch covers the two declared case types without a fallback. Remove either arm and the compiler warns that the switch is incomplete.

The two records in the union version don’t inherit from a common result class. The union itself defines their relationship. This is useful when an API needs to return one of several outcomes without forcing those outcomes into an inheritance hierarchy.

3. Closed class hierarchies

A similar example next - we cannot be certain of all types that could inherit from a class without a closed hierarchy.

When the cases already share a base class, closed makes the set of direct descendants known to the compiler. A closed class is implicitly abstract, and only its declaring assembly can add direct descendants. The closed modifier reference.

This gate has a closed state and an open state carrying a percentage. The .NET 10 switch needs a fallback because an ordinary abstract base record doesn’t restrict its direct descendants to this assembly.

.NET 10

GateState state = new Open(75);
Console.WriteLine(Describe(state));

static string Describe(GateState state) => state switch
{
    Closed => "closed",
    Open(var percent) => $"{percent}% open",
    _ => throw new ArgumentOutOfRangeException(nameof(state))
};

// C# 14: direct subclasses cannot be restricted to this assembly.
public abstract record class GateState;
public sealed record class Closed : GateState;
public sealed record class Open(float Percent) : GateState;

.NET 11

GateState state = new Open(75);
Console.WriteLine(Describe(state));

static string Describe(GateState state) => state switch
{
    Closed => "closed",
    Open(var percent) => $"{percent}% open"
};

// C# 15: only this assembly can declare direct descendants of GateState.
public closed record class GateState;
public sealed record class Closed : GateState;
public sealed record class Open(float Percent) : GateState;

Both versions print 75% open. Marking GateState as closed lets the compiler check that the switch handles both direct descendants.

The restriction applies to direct inheritance. A descendant can still allow further inheritance unless it is also sealed or closed. Here both descendants are sealed, which keeps the whole hierarchy fixed.

4. Extension indexers

Something for the enterprise archtiect to add to helpers.dll next. I’d probably just write ElementAt but if you wanted to reduce this further in your program only, you could already in C# 14 add an “At” extention method.

C# 15 goes further and allows an extension block to declare an indexer on its receiver. That gives calling code bracket syntax for a type that doesn’t declare that indexer itself. The block needs a named receiver because the indexer operates on an instance. Extension member documentation.

.NET 10

IEnumerable<int> numbers = Enumerable.Range(1, 4);
Console.WriteLine($"Third: {numbers.At(2)}");

public static class SequenceExtensions
{
    public static int At(this IEnumerable<int> sequence, int index)
        => sequence.ElementAt(index);
}

.NET 11

IEnumerable<int> numbers = Enumerable.Range(1, 4);
Console.WriteLine($"Third: {numbers[2]}");

public static class SequenceIndexer
{
    extension(IEnumerable<int> sequence)
    {
        public int this[int index] => sequence.ElementAt(index);
    }
}

Both programs print Third: 3. The call changes from numbers.At(2) to numbers[2].

5. Labeled break and continue

The little booleans used only to escape an outer loop are syntactic noise I’d happily throw in the bin.

A plain break inside a nested loop exits the inner loop. If an event should stop the outer loop too, older code often stores a flag and checks it after the inner loop finishes.

C# 15 lets break and continue name their enclosing loop. A labeled break can also target an enclosing switch. Place the label directly on the construct it identifies. C# jump statement reference.

In this itinerary, a closed bridge skips the rest of the current day. Finding the goal ends the entire trip.

I’ve also called the label “barry” for funsies.

.NET 10

string[][] dailyRoutes =
[
    ["North", "West"],
    ["South", "Bridge closed", "East"],
    ["Central", "Goal", "Harbor"],
    ["Unused"]
];

bool stopAllDays = false;
for (int day = 0; day < dailyRoutes.Length; day++)
{
    Console.WriteLine($"Day {day + 1}:");
    bool skipRestOfDay = false;

    foreach (string route in dailyRoutes[day])
    {
        if (route == "Bridge closed")
        {
            Console.WriteLine("  Bridge closed; next day.");
            skipRestOfDay = true;
            break;
        }

        if (route == "Goal")
        {
            Console.WriteLine("  Goal found; stop all days.");
            stopAllDays = true;
            break;
        }

        Console.WriteLine($"  Visit {route}.");
    }

    if (stopAllDays)
        break;

    if (skipRestOfDay)
        continue;

    Console.WriteLine("  Day completed.");
}

.NET 11

string[][] dailyRoutes =
[
    ["North", "West"],
    ["South", "Bridge closed", "East"],
    ["Central", "Goal", "Harbor"],
    ["Unused"]
];

barry: for (int day = 0; day < dailyRoutes.Length; day++)
{
    Console.WriteLine($"Day {day + 1}:");

    foreach (string route in dailyRoutes[day])
    {
        if (route == "Bridge closed")
        {
            Console.WriteLine("  Bridge closed; next day.");
            continue barry;
        }

        if (route == "Goal")
        {
            Console.WriteLine("  Goal found; stop all days.");
            break barry;
        }

        Console.WriteLine($"  Visit {route}.");
    }

    Console.WriteLine("  Day completed.");
}

The .NET 10 version needs skipRestOfDay and stopAllDays. The C# 15 version names the outer loop barry and jumps directly to that loop with continue barry; or break barry;.

Both programs produce:

Day 1:
  Visit North.
  Visit West.
  Day completed.
Day 2:
  Visit South.
  Bridge closed; next day.
Day 3:
  Visit Central.
  Goal found; stop all days.

The jump states which loop it controls, so the outer-loop flag checks disappear. Bargain.

6. Extended layout support

We’re deep in native interop territory in this one for gigabrains. If you’re matching a C-style union in a native library, repeating a field offset for every member adds noise. Declaring the union layout lets the runtime handle that shared-storage arrangement.

Native interop sometimes requires two fields to occupy the same bytes. The older explicit-layout approach specifies an offset for every field. C# 15 recognizes [ExtendedLayout] and emits metadata that the .NET 11 runtime uses to lay out the type. Microsoft’s extended layout release note.

Selecting ExtendedLayoutKind.CUnion gives the following integer and float fields shared storage.

.NET 10

using System.Reflection;
using System.Runtime.InteropServices;

// The old explicit-layout approach requires an offset for every union field.
IntFloatBits bits = new() { AsInt = 0x3F800000 };
Console.WriteLine($"Integer bits: 0x{bits.AsInt:X8}");
Console.WriteLine($"Same bits as float: {bits.AsFloat:F1}");
Console.WriteLine($"Metadata layout: {typeof(IntFloatBits).Attributes & TypeAttributes.LayoutMask}");

[StructLayout(LayoutKind.Explicit)]
public struct IntFloatBits
{
    [FieldOffset(0)] public int AsInt;
    [FieldOffset(0)] public float AsFloat;
}

.NET 11

using System.Reflection;
using System.Runtime.InteropServices;

// C# 15 emits extended-layout metadata from the new .NET 11 attribute.
IntFloatBits bits = new() { AsInt = 0x3F800000 };
Console.WriteLine($"Integer bits: 0x{bits.AsInt:X8}");
Console.WriteLine($"Same bits as float: {bits.AsFloat:F1}");
Console.WriteLine($"Metadata layout: {typeof(IntFloatBits).Attributes & TypeAttributes.LayoutMask}");

[ExtendedLayout(ExtendedLayoutKind.CUnion)]
public struct IntFloatBits
{
    public int AsInt;
    public float AsFloat;
}

Both programs write the integer bit pattern 0x3F800000 and read the same bits through AsFloat as 1.0. The final line reports ExplicitLayout in .NET 10 and ExtendedLayout in .NET 11.

This is an interop representation where code must know which field contains a valid value. The type-safe union in feature 2 models a choice between cases; this C-style union overlays raw storage. Use the layout that matches the native ABI you need to call.

ASP.NET Core 11

7. ShortCircuit on MVC controllers and actions

MVC is still my favorite and I’m over the moon Microsoft are still improving it.

A controller serving a dynamic robots.txt is a useful reason to keep the routing behavior beside the action. The response below is constant so we can concentrate on which middleware runs.

ASP.NET Core already supports the .ShortCircuit() mapping convention. .NET 11 adds [ShortCircuit], allowing an MVC controller or action to declare the behavior beside its route metadata. Routing executes the endpoint immediately and skips middleware later in the pipeline. ASP.NET Core short-circuit release notes.

The endpoint below serves robots.txt. Middleware after UseRouting adds a diagnostic header when it runs. The .NET 10 version applies the convention while mapping a controller route; the .NET 11 version places the attribute on the controller.

.NET 10

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

var app = builder.Build();
app.UseRouting();
app.Use(async (context, next) =>
{
    context.Response.Headers["X-Later-Middleware-Ran"] = "yes";
    await next(context);
});

// In .NET 10 the short-circuit convention must be attached when mapping
// endpoints. Conventional routing is used to target this MVC action.
app.MapControllerRoute(
    name: "robots",
    pattern: "robots.txt",
    defaults: new { controller = "Robots", action = "Get" })
    .ShortCircuit();

app.Run();

public sealed class RobotsController : ControllerBase
{
    public IActionResult Get() => Content("User-agent: *\nDisallow:", "text/plain");
}

.NET 11

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

var app = builder.Build();
app.UseRouting();
app.Use(async (context, next) =>
{
    context.Response.Headers["X-Later-Middleware-Ran"] = "yes";
    await next(context);
});

app.MapControllers();
app.Run();

[ApiController]
[Route("robots.txt")]
[ShortCircuit]
public sealed class RobotsController : ControllerBase
{
    [HttpGet]
    public IActionResult Get() => Content("User-agent: *\nDisallow:", "text/plain");
}

With both web apps running, inspect the responses:

curl.exe -i http://localhost:5010/robots.txt
curl.exe -i http://localhost:5011/robots.txt

Both return 200 with the robots text. Neither response contains X-Later-Middleware-Ran, because routing executed the endpoint before that middleware.

Only apply short-circuiting when the endpoint can produce its response without later middleware running. If you need Authentication and CORS this can be screwed up big time so be careful.

8. Async validation for Minimal APIs

The Minimal API crowd gets something too. An email lookup can swallow a small registration handler once you add the database call and the invalid-response branch. Moving that rule onto the request model leaves the handler focused on accepting the registration.

Checking whether an email is already registered may require database I/O. In .NET 10, the handler below awaits that query and constructs its own validation response.

Minimal API validation in .NET 11 can await AsyncValidationAttribute and IAsyncValidatableObject rules before the handler executes. Register AddValidation(), then put the rule on the request model. ASP.NET Core asynchronous validation documentation.

.NET 10

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IUserStore, DemoUserStore>();

var app = builder.Build();

// .NET 10: the handler itself must call the async rule and translate an
// invalid result into a response. Each endpoint would repeat this wiring.
app.MapPost("/registrations", async (Registration request, IUserStore users, CancellationToken cancellationToken) =>
{
    if (string.IsNullOrWhiteSpace(request.Email))
        return Results.ValidationProblem(new Dictionary<string, string[]> { ["Email"] = ["Email is required."] });

    if (await users.EmailExistsAsync(request.Email, cancellationToken))
        return Results.ValidationProblem(new Dictionary<string, string[]> { ["Email"] = ["Email is already registered."] });

    return Results.Ok(new { message = "Registered", request.Email });
});

app.Run();

public sealed record Registration(string Email);

public interface IUserStore
{
    Task<bool> EmailExistsAsync(string email, CancellationToken cancellationToken);
}

public sealed class DemoUserStore : IUserStore
{
    public async Task<bool> EmailExistsAsync(string email, CancellationToken cancellationToken)
    {
        await Task.Delay(50, cancellationToken); // Simulates asynchronous database I/O.
        return string.Equals(email, "taken@example.com", StringComparison.OrdinalIgnoreCase);
    }
}

.NET 11

using System.ComponentModel.DataAnnotations;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IUserStore, DemoUserStore>();
builder.Services.AddValidation();

var app = builder.Build();

// .NET 11 validates the request before this handler runs, awaiting the
// attribute's asynchronous rule and returning a validation problem on failure.
app.MapPost("/registrations", (Registration request) =>
    Results.Ok(new { message = "Registered", request.Email }));

app.Run();

public sealed record Registration([property: Required, UniqueEmail] string Email);

public sealed class UniqueEmailAttribute : AsyncValidationAttribute
{
    protected override ValidationResult? IsValid(object? value, ValidationContext context) =>
        throw new InvalidOperationException("This attribute requires asynchronous validation.");

    protected override async Task<ValidationResult?> IsValidAsync(
        object? value, ValidationContext context, CancellationToken cancellationToken)
    {
        var users = context.GetRequiredService<IUserStore>();
        if (value is string email && await users.EmailExistsAsync(email, cancellationToken))
            return new ValidationResult("Email is already registered.");

        return ValidationResult.Success;
    }
}

public interface IUserStore
{
    Task<bool> EmailExistsAsync(string email, CancellationToken cancellationToken);
}

public sealed class DemoUserStore : IUserStore
{
    public async Task<bool> EmailExistsAsync(string email, CancellationToken cancellationToken)
    {
        await Task.Delay(50, cancellationToken); // Simulates asynchronous database I/O.
        return string.Equals(email, "taken@example.com", StringComparison.OrdinalIgnoreCase);
    }
}

The new handler processes successful registrations; UniqueEmailAttribute owns the asynchronous check. Its synchronous IsValid throws because this rule requires async validation. It doesn’t block a thread by waiting synchronously for the query.

The attribute gets the registered user store through the validation context using a bit of a bleak service locator anti-pattern. The asynchronous rule runs after the request is bound and before the handler executes, so a rejected email never reaches the registration handler.

9. Built-in Zstandard HTTP compression

ASP.NET Core 11 adds Zstandard, or zstd, to the default response compression and request decompression providers. The middleware registrations stay the same. You can configure zstd quality through ZstandardCompressionProviderOptions. Microsoft’s Zstandard HTTP release note.

The following apps return a text payload and echo request bodies. The .NET 10 built-in providers don’t support zstd, while the .NET 11 providers do.

.NET 10

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddResponseCompression();
builder.Services.AddRequestDecompression();

var app = builder.Build();
app.UseResponseCompression();
app.UseRequestDecompression();

// The .NET 10 built-in providers support Brotli and Gzip etc
app.MapGet("/payload", () => Results.Text(
    string.Concat(Enumerable.Repeat("ASP.NET Core compression example. ", 100)),
    "text/plain"));

app.MapPost("/echo", async (HttpRequest request) =>
{
    using var reader = new StreamReader(request.Body);
    return Results.Text(await reader.ReadToEndAsync(), "text/plain");
});

app.Run();

.NET 11

using System.IO.Compression;
using Microsoft.AspNetCore.ResponseCompression;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddResponseCompression();
builder.Services.AddRequestDecompression();
builder.Services.Configure<ZstandardCompressionProviderOptions>(options =>
{
    options.CompressionOptions = new ZstandardCompressionOptions { Quality = 6 };
});

var app = builder.Build();
app.UseResponseCompression();
app.UseRequestDecompression();

// ASP.NET Core 11 includes zstd among its default response compression and
// request decompression providers. No custom provider registration is needed.
app.MapGet("/payload", () => Results.Text(
    string.Concat(Enumerable.Repeat("ASP.NET Core compression example. ", 100)),
    "text/plain"));

app.MapPost("/echo", async (HttpRequest request) =>
{
    using var reader = new StreamReader(request.Body);
    return Results.Text(await reader.ReadToEndAsync(), "text/plain");
});

app.Run();

Ask each server for zstd and inspect only the response headers:

curl.exe -s -D - -o NUL -H 'Accept-Encoding: zstd' http://localhost:5010/payload
curl.exe -s -D - -o NUL -H 'Accept-Encoding: zstd' http://localhost:5011/payload

Both responses are 200. The first has no Content-Encoding header; the second contains Content-Encoding: zstd. The client must advertise support for the encoding or .NET 11 ignores it.

10. Dynamic output-cache policies

I can see this being helpful when cache rules need to change while an app keeps running. The provider gets a policy name and can resolve it against current settings. That gives us a place to load or change the rule at runtime, rather than fixing this program’s duration at startup.

A named output-cache policy in .NET 10 can be configured at startup with AddPolicy. The first program caches a public catalog response for 30 seconds.

.NET 11 adds IOutputCachePolicyProvider. The middleware asks the provider to resolve a named policy, letting that provider consult configuration that can change while the app runs. Microsoft’s output-cache provider release note.

The second program includes the entire provider and policy implementation. It keeps the duration in memory and exposes an endpoint to change it.

.NET 10

using Microsoft.AspNetCore.OutputCaching;

var builder = WebApplication.CreateBuilder(args);

// In .NET 10, the named policy is defined when the application starts.
builder.Services.AddOutputCache(options =>
    options.AddPolicy("catalog", policy =>
        policy.Expire(TimeSpan.FromSeconds(30))));

var app = builder.Build();
app.UseOutputCache();

var generationCount = 0;
app.MapGet("/catalog", () => new
{
    Generation = Interlocked.Increment(ref generationCount),
    GeneratedAt = DateTimeOffset.UtcNow,
    YouTubeSubscriberReminder = "Enjoying the demo? Subscribe for more .NET examples!"
}).CacheOutput("catalog");

app.Run();

.NET 11

using Microsoft.AspNetCore.OutputCaching;
using Microsoft.Extensions.DependencyInjection.Extensions;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<CacheDurationStore>();
builder.Services.AddOutputCache();

// The .NET 11 provider resolves the named policy when it is requested.
builder.Services.Replace(
    ServiceDescriptor.Singleton<IOutputCachePolicyProvider, DynamicCachePolicyProvider>());

var app = builder.Build();
app.UseOutputCache();

var generationCount = 0;
app.MapGet("/catalog", (CacheDurationStore store) => new
{
    Generation = Interlocked.Increment(ref generationCount),
    GeneratedAt = DateTimeOffset.UtcNow,
    CacheSeconds = store.Seconds,
    YouTubeSubscriberReminder = "Enjoying the demo? Subscribe for more .NET examples!"
}).CacheOutput("catalog");

app.MapPost("/cache-seconds/{seconds:int}", async (
    int seconds, CacheDurationStore store, IOutputCacheStore cache) =>
{
    if (seconds is < 1 or > 120)
    {
        return Results.BadRequest("Choose a duration from 1 to 120 seconds.");
    }

    store.Seconds = seconds;
    await cache.EvictByTagAsync("catalog", CancellationToken.None);
    return Results.Ok(new { CacheSeconds = seconds });
});

app.Run();

sealed class CacheDurationStore
{
    private int _seconds = 30;

    public int Seconds
    {
        get => Volatile.Read(ref _seconds);
        set => Volatile.Write(ref _seconds, value);
    }
}

sealed class DynamicCachePolicyProvider(CacheDurationStore store) : IOutputCachePolicyProvider
{
    public IReadOnlyList<IOutputCachePolicy> GetBasePolicies() => [];

    public ValueTask<IOutputCachePolicy?> GetPolicyAsync(string policyName)
    {
        if (policyName != "catalog")
        {
            return ValueTask.FromResult<IOutputCachePolicy?>(null);
        }

        IOutputCachePolicy policy = new DynamicDurationPolicy(store.Seconds);

        return ValueTask.FromResult<IOutputCachePolicy?>(policy);
    }
}

sealed class DynamicDurationPolicy(int seconds) : IOutputCachePolicy
{
    public ValueTask CacheRequestAsync(OutputCacheContext context, CancellationToken cancellationToken)
    {
        context.EnableOutputCaching = true;
        context.AllowCacheLookup = true;
        context.AllowCacheStorage = true;
        context.AllowLocking = true;
        context.Tags.Add("catalog");
        context.ResponseExpirationTimeSpan = TimeSpan.FromSeconds(seconds);
        return ValueTask.CompletedTask;
    }

    public ValueTask ServeFromCacheAsync(OutputCacheContext context, CancellationToken cancellationToken)
        => ValueTask.CompletedTask;

    public ValueTask ServeResponseAsync(OutputCacheContext context, CancellationToken cancellationToken)
    {
        context.ResponseExpirationTimeSpan = TimeSpan.FromSeconds(seconds);
        return ValueTask.CompletedTask;
    }
}

The provider creates DynamicDurationPolicy from the current duration. The policy enables lookup and storage, sets the expiration, and tags the cached response as catalog.

Run these requests against the .NET 11 app:

Invoke-RestMethod http://localhost:5011/catalog
Invoke-RestMethod http://localhost:5011/catalog
Invoke-RestMethod -Method Post http://localhost:5011/cache-seconds/5
Invoke-RestMethod http://localhost:5011/catalog

The first two GETs have the same Generation while the response is cached. The POST updates the duration and evicts the tagged entry. The next GET generates a fresh response and reports CacheSeconds as 5.

Changing the duration doesn’t remove an existing entry by itself. The explicit eviction makes the update visible immediately. This program caches one public response; tenant-specific responses need cache keys that distinguish their contents.

.NET 11 runtime

11. Runtime-native async

Runtime Async V2 moves suspension and resumption into the runtime. Application code still uses async and await, but the execution method changes. One visible effect is the live stack trace where application methods appear more directly without the compiler-generated async infrastructure between them. Microsoft’s Runtime Async documentation.

These programs call OuterAsync, then MiddleAsync, then InnerAsync, which prints a live StackTrace.

.NET 10

using System.Diagnostics;

await OuterAsync();

static async Task OuterAsync()
{
    await Task.CompletedTask;
    await MiddleAsync();
}

static async Task MiddleAsync()
{
    await Task.CompletedTask;
    await InnerAsync();
}

static async Task InnerAsync()
{
    await Task.CompletedTask;
    Console.WriteLine("Live stack with compiler-generated async:");
    Console.WriteLine(new StackTrace(fNeedFileInfo: true));
}

.NET 11

using System.Diagnostics;

await OuterAsync();

static async Task OuterAsync()
{
    await Task.CompletedTask;
    await MiddleAsync();
}

static async Task MiddleAsync()
{
    await Task.CompletedTask;
    await InnerAsync();
}

static async Task InnerAsync()
{
    await Task.CompletedTask;
    Console.WriteLine("Live stack with runtime-native async:");
    Console.WriteLine(new StackTrace(fNeedFileInfo: true));
}

Runtime async remains an opt-in preview feature. For the .NET 11 program, use this complete project file:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net11.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <Features>$(Features);runtime-async=on</Features>
  </PropertyGroup>
</Project>

Run each console app in Debug configuration:

dotnet run --project Demo10 -c Debug
dotnet run --project Demo11 -c Debug

The .NET 10 trace includes infrastructure frames such as AsyncMethodBuilderCore.Start. With runtime async enabled, the application call chain appears more directly. Build settings and JIT optimizations affect the number of frames, so compare the method chain.

A net11.0 project doesn’t also need EnablePreviewFeatures for this opt-in. Exception stack traces already receive cleanup; the code inspects a live stack to show the diagnostic change.

This should basically be a free speedup for any async heavy apps.

Closing thoughts

I think it’s time to slow down on the new syntax in C# 16. .NET 12 needs to compete with Rust etc for the attention of the AI pilled vibe coders, even within Microsoft. Fix AoT and make it competitive with Rust and Go.

1. Null-Conditional Assignment (?=)

We've all written this boilerplate code a thousand times. You have a nullable object, and you only want to assign a value to one of its properties if the object itself isn't null.

In C# 13, you had to perform an explicit null check.

public class Channel
{
    public int Subscribers { get; set; }
    public int Members { get; set; }
}

// ---

Channel? myChannel = null; // or new Channel();

// We have to check for null before assigning
if (myChannel is not null)
{
    myChannel.Subscribers = 1000;
}

After: C# 14

With the new null-conditional assignment operator (?=), you can do this in a single, safe, and readable line.

Channel? myChannel = null;

// This will only assign 1000 if myChannel is not null
myChannel?.Subscribers = 1000;

It's a small change, but a very welcome one!

2. The field Keyword for Semi-Auto-Properties

Auto-properties are great, but as soon as you need to add logic to your getter or setter (like validation), you have to convert it to a full property with an explicit private backing field.

Before: C# 13

This required creating a separate field (_subscribers) just to add a check in the setter.

public class Channel
{
    private int _subscribers;
    public int Subscribers
    {
        get => _subscribers;
        set
        {
            if (value < 1000)
            {
                throw new ArgumentException("Not enough subs!");
            }
            _subscribers = value;
        }
    }
}

After: C# 14

The new field keyword gives you access to the implicit, compiler-generated backing field of an auto-property. This means you can add logic without the boilerplate!

public class Channel
{
    public int Subscribers
    {
        get => field; // 'field' refers to the implicit backing field
        set
        {
            if (value < 1000)
            {
                throw new ArgumentException("Not enough subs!");
            }
            field = value; // Assign to the implicit backing field
        }
    }
}

This keeps the code much cleaner and more concise.

3. User-Defined Compound Operators

This one is really cool. Have you ever wanted to define what a compound operator like ++ or += does for your own custom type? Now you can!

Imagine we want the ++ operator to increment both the Subscribers and Members properties of our Channel class at the same time.

Before: C# 13

You'd have to increment each property manually.

var myChannel = new Channel();
myChannel.Subscribers++;
myChannel.Members++;

After: C# 14

You can now overload the compound operator directly in your class definition.

public class Channel
{
    public int Subscribers { get; set; }
    public int Members { get; set; }

    public void operator ++()
    {
        Subscribers++;
        Members++;
    }

    public void operator +=(int amount)
    {
        Subscribers += amount;
        Members += amount;
    }
}

// ---

var myChannel = new Channel();
myChannel++; // This now increments both Subscribers and Members!

Console.WriteLine($"Subs: {myChannel.Subscribers}, Members: {myChannel.Members}");
// Output: Subs: 1, Members: 1

Not sure where I’d use this but hey ho!

4. The extension Keyword

Extension methods have always required a public static class and public static methods using the this keyword. C# 14 introduces a new, more explicit syntax.

Before: C# 13

The classic syntax we all know.

public static class ChannelExtensions
{
    public static void PrintDetails(this Channel c)
    {
        Console.WriteLine($"Subs: {c.Subscribers}, Members: {c.Members}");
    }
}

After: C# 14

You can now use the extension keyword to create an "extension type." The syntax is cleaner and makes the intent clearer.

public extension ChannelExtensions
{
    public void PrintDetails(this Channel c)
    {
        Console.WriteLine($"Subs: {c.Subscribers}, Members: {c.Members}");
    }
}

Personally, I'm not totally sold on this one yet, as it just creates another way to do the same thing. You can now use extension methods to add Properties, but still…

5. nameof Improvements for Generics

The nameof operator is a handy tool for getting the string name of a variable, type, or member. However, it had a limitation with generic types.

Before: C# 13

nameof worked on a constructed generic type, but not on an "unbound" or open generic type.

C#

public class Channel<T> { }
public class YouTube { }

// This worked fine
Console.WriteLine(nameof(Channel<YouTube>)); // Output: Channel

// This caused a compile error
// Console.WriteLine(nameof(Channel<>));

After: C# 14

This limitation has been removed. You can now use nameof directly on an unbound generic type.

C#

// Now this works perfectly!
Console.WriteLine(nameof(Channel<>)); // Output: Channel

This is a nice little fix for those edge cases where you need the name of the generic type definition itself.

My thoughts on C# 14

Actually they’ve been quite restrained this year. No crazy new ways to instantiate lists or classes that conceptually forks C#. I do get alot of comments on my channel saying that C# is getting too complicated, so glad they have shown restraint. Well done chaps!

Let's look at the full state of WPF today.

Alive and Well in the Enterprise and “boring” stuff

First things first: Microsoft is still actively working on WPF. It was made part of the open-source .NET Foundation and continues to receive meaningful updates. In .NET 8, we got hardware acceleration for RDP and a new folder dialog. For .NET 9, Microsoft is adding a Fluent theme to make WPF apps look more like modern Windows 11 applications, a feature many thought was reserved for newer frameworks. The official roadmap even shows plans for .NET 10. This isn't just life support; it's active development. This predictability is precisely what enterprises value, which is why you'll find WPF powering critical line-of-business applications on oil rigs, in maritime shipping, and across the manufacturing industry—the so-called "dark matter developers" who don't always show up in surveys but build the backbone of industry.

• What's new for WPF in .NET 8 - Microsoft Dev Blogs

• WPF Roadmap 2024 - GitHub

• Windows Presentation Foundation - Microsoft Docs

Third parties make bank on WPF

WPF’s longevity isn’t just thanks to Microsoft. I’d wager that third parties make more money from WPF than MS does themselves and are incentivized to keep it that way.

A massive ecosystem of vendors and open-source projects keeps it vibrant. Companies like Telerik and DevExpress continue to sell and support extensive component libraries, investing thousands to ensure developers can build complex, feature-rich applications quickly. At the same time, the open-source community is keeping things fresh. Before MS added the Fluent theme to WPF, popular projects like MahApps.Metro give WPF apps a modern Windows look and feel like Windows 10 rather than the classic WebForms inspired take, while Material Design in XAML allows you to build a Windows app that looks like an Android app. This combination of corporate and community support is a self perpetuating machine.

• WPF vs. .NET MAUI: How to Choose in 2024 - Telerik

• WPF UI Controls - DevExpress

• Material Design in XAML Toolkit - GitHub

• MahApps.Metro - GitHub

The Geographic Divide and the Ghost of WinUI

So if it's not dead, where is it hiding? I think the debate is still a thing because because WPF's popularity is highly regional. In the United States, the average salary for a WPF developer is a chonky $130,000, suggesting strong demand. But cross the pond to the UK, and the number of job postings mentioning WPF is vanishingly small. In Japan, they're practically non-existent outside of niche finance roles. Surprisingly, Google Trends data shows a huge resurgence of interest in China and South Korea. Meanwhile, Microsoft's intended successor, WinUI, has seen development activity fall off a cliff since late 2021, with its GitHub commit history looking like a ghost town compared to the flurry of activity around .NET MAUI, Avalonia, and even WPF itself.

I miss WinUI btw. Seriously. WinUI 2.x was fast, compiled native and created apps indistinguishable from the Windows 10 and Windows 11 shells. In my view if you cannot create the native Settings app pixel for pixel perfect then its not a “native” app toolkit.

• The Future of WPF: Is WPF Dead? - SciChart

• microsoft-ui-xaml (WinUI) Repository - GitHub

The Spirit Lives On: Avalonia and OpenSilver

While WPF remains a Windows-only affair, its XAML-based spirit is finding new life in cross-platform frameworks. Avalonia proudly calls itself the open-source WPF successor and even offers a product, XPF, designed to take your existing WPF applications and run them on macOS and Linux in minutes. It’s what Microsoft tried—and failed—to do with "WPF Everywhere" back in 2006, a project that morphed into the ill-fated Silverlight. And just like WPF, Silverlight's spirit has been resurrected by the community in the form of OpenSilver, which is picking up where Microsoft left off. For developers who honed their XAML skills on WPF, these frameworks offer an exciting path forward without abandoning their expertise.

• OpenSilver - A modern, open-source reimplementation of Silverlight

• Xamarin.Forms Platform Support - Microsoft Docs (Historical)

The Verdict

So, is WPF dead? No. But it has probably flatlined.

Its spirit, however, has broken free from its Windows-only confines and lives on in modern, cross-platform frameworks. The transferrable design patterns, XAML, MVVM etc are reusable across Uno and Avalonia today, even as .NET MAUI sails off into the sunset.

View this post in mega cringe video form:

Onto this week’s news:

JetBrains releases ReSharper for VS Code

For veteran developers, the news might bring a wave of nostalgia. ReSharper was, for many, an indispensable part of the C# development experience. The cry of "Please, a ReSharper license!" from a new team member was expected.

I’ve given it a go and you need to disable Microsoft's own C# and C# Dev Kit extensions, as ReSharper apparently prefers to take full command of the C# experience. This in itself signals the potential for a fascinating dynamic in the VS Code tooling space.

Once installed and your solution is loaded (perhaps after the classic ReSharper cache processing warms up, a sight familiar to Visual Studio users), the experience aims to be classic ReSharper. The "ReSharper Solution Explorer" makes an appearance, which basically mirrors the C# Dev Kit Solution Explorer. I had great success with the iconic "Initialize field from constructor" shortcut, a beloved time-saver, and it works just as well as it did in VS.

This move by JetBrains is particularly interesting given Microsoft's recent efforts to monetize the C# experience in VS Code through the C# Dev Kit, which is tied into Visual Studio subscriptions. I do think this will get somehow squashed by MS, there was a reason JetBrains announced in 2021 that they weren’t going to bother.

Relevant Links:

• JetBrains ReSharper in VS Code Public Preview Announcement https://blog.jetbrains.com/dotnet/2025/05/19/resharper-comes-to-microsoft-visual-studio-code/

• ReSharper on the Visual Studio Code Marketplace: https://marketplace.visualstudio.com/items?itemName=JetBrains.ReSharper-VSCode

SQL Server 2025 gets decent JSON support

I’ll ignore the AI stuff for this update.

Fascinating to me is the new sp_invoke_external_rest_endpoint stored procedure. This has serious potential. For years, reaching out to external web services from within SQL Server has been a clunky affair, often requiring complex CLR assemblies or other workarounds. Now, developers will be able to directly call secure HTTPS REST endpoints (supporting GET, POST, PUT, etc.) from stored procedures, triggers, or functions, and directly process the response. Imagine enriching your data in real-time by calling an external API, or triggering a workflow in another system based on a database event – all natively within SQL Server. Scary.

Complementing this external connectivity is a long-awaited enhancement to JSON support. SQL Server has had rudimentary JSON capabilities for a while – parsing with OPENJSON and formatting with FOR JSON – but it always felt like a bolt-on rather than a first-class citizen. Developers often looked to databases like PostgreSQL for more robust native JSON handling. With SQL Server 2025, that changes. The introduction of a native JSON data type aims to bring SQL Server to feature parity with competitors, allowing for more efficient storage, indexing, and querying of JSON documents directly within the relational database.

When you combine these two features – the ability to call a REST API and get a JSON response, and then store and manipulate that JSON natively – the possibilities are quite exciting, and perhaps a little "scary" in terms of the complex logic that might now reside in the database tier.

The "AI-ready" stuff extends to integrated vector database querying capabilities and other GenAI model integrations and obviously they added GitHub Copilot to the beloved SQL Server Management Studio.

Relevant Links:

• Official SQL Server 2025 Public Preview Blog: https://cloudblogs.microsoft.com/sqlserver/2025/05/19/announcing-sql-server-2025-public-preview/

• SQL Server 2025 Public Preview Discussion on Reddit: https://www.reddit.com/r/SQLServer/comments/1kqfecc/announcing_the_public_preview_of_sql_server_2025/

Windows Update Gets an Update

In a spell of wishful thinking, MS looks like they’ll try to cajole the 1000s of disparate update mechanisms on Windows to all hook into Windows Update.

This sounds like a nightmare to me but you can read more about it on “Introducing a Unified Future for App Updates on Windows” at their blog: https://techcommunity.microsoft.com/blog/windows-itpro-blog/introducing-a-unified-future-for-app-updates-on-windows/4416354

Thanks for reading and continuing to subscribe. For a video version of this post, check out:

Azure AI Foundry Local

One significant announcement is Azure Foundry Local. Think of it as a mini-version of Ollama, allowing you to run AI models locally. It's designed to work seamlessly with Azure AI Foundry and even includes an SDK for C# (though it's not yet on NuGet). This means you can integrate AI capabilities directly into your C# and .NET applications, running models on your local machine, even with full Mac GPU support. Imagine asking a question like, "Is .NET and C# cool and popular?" and getting an AI-powered "Yes!" from your local setup just to help alleviate your anxiety.

It provides a fully OpenAI Chat Completion API compatible local endpoint when you run it, so you can actually point existing apps (assuming you can change the model name) at it and get started.

The docs are here: https://learn.microsoft.com/en-gb/azure/ai-foundry/foundry-local/get-started

.NET Aspire rolls on to 9.3

No Blazor, MVC, Razor Pages or any other content really - just .NET Aspire.

In a sign of insane irony, they’ve actually embedded GitHub Copilot into the Aspire Dashboard, which loops through the C# Dev Kit and the GitHub Copilot extension in VS Code.

I know the KPIs at MS are brutal but this is really quite something.

Azure App Service: Faster, Cheaper, Better!

Now for something positive! Azure App Service is easily my favourite service on Azure that just keeps getting better. Microsoft announced a new service plan that promises significant improvements:

• 24% cost savings on Windows for better cost-performance.

• Faster temporary storage.

• A wider range of CPU and RAM options, from modest setups to massive 256GB configurations.

• Finally, high availability with only two availability zones. This means you no longer need three nodes on your web tier to achieve a 99.99% SLA, potentially cutting a third off your App Service bills.

Most projects, and I do mean like over 90% of them, should be running on Azure App Service in my opinion. It really is that good.

Thank you for continuing to subscribe to the newsletter. If you’d like this post in slightly ironic video form, check out the below:

VS Code 1.100 sees GitHub Copilot get absorbed totally

In a masterclass of product reclassification, VS Code is now being referred to as an “AI Editor”.

Tracing the history here is fascinating. In June 2023, v1.80 release notes still referred to the GitHub Copilot as a separate extension:

But by v1.100, updates to the AI chat function is now indistinguishable from core functionality:

My view is that this is purely a response to Cursor and Windsurf. The GitHub Copilot extension is not open source, and now VS Code bundles a huge closed source extension along with it. VS Code is no longer “open source” by any definition.

Layoffs hit MAUI, TypeScript teams

Just in time for Microsoft Build next week, Microsoft has decided to lay off engineers across the firm, including “folks” in their TypeScript and .NET Android and MAUI teams. I believe the .NET MAUI team has been totally gutted.

This poor chap has been at Microsoft for 18 years and worked on the TypeScript compiler being rewritten in Go:

I guess the beatings will continue until morale improves.

.NET 10 Preview 4

Two main new features I like in this are new async methods for Zip folder creation, plus Minimal APIs get another boost with validation for Record types.

You can now do the following:

using System.IO.Compression;

await ZipFile.CreateFromDirectoryAsync("photos", "we-have-to-go-back-async.zip");

Whereas you were stuck with non-async versions in .NET 8.

As always, I do appreciate you continuing to subscribe. For a more visual version of this post, check out the YouTube version below:

Onto the Microsoft developer content…

.NET Conf “Focus on Modernisation”

CSharp “Jeff” Fritz hosted a special .NET Conf this week aimed at showing the latest techniques and tools available to upgrade the considerable estate of legacy .NET apps out there. Even Scott Hanselman dug out his Baby Smash app for an update!

A central tool highlighted was the .NET Upgrade Assistant, available as a Visual Studio extension and a CLI tool, designed to analyze projects, identify potential issues, and aid in the upgrade process for various project types like WPF, WinForms, and older ASP.NET MVC apps. The Upgrade Assistant isn’t new - its been around for donkeys years - but they have now added Github Copilot to it to provide AI generated agent-like upgrade step generation.

I remain skeptical about AI being help to help much here considering the lack of publicly available training data for this process - upgrades from .NET Framework to the latest .NET versions are the equivalent of open heart surgery and to do correctly is one of the hardest things a .NET Developer can do. It requires over a decade of archeological knowledge about .NET versions and their upgrade paths - where is this training data coming from? CodeProject blog posts?

One wild demo was the ability to embed Blazor components in a classic WebForms app. I highly suggest you watch the video as it really was a tour de force of proper .NET boomer content:

Azure releases its own MCP server

Previously this functionality was limited to Copilot within Azure itself, but to score internet points the Azure team have released a new MCP server that allows local agents, either Copilot in Agent mode, Claude, Cursor or other MCP clients to access information about your Azure infrastructure.

What’s more impressive is that it is built in .NET 9 and C#! Yes! No JavaScript or Go cop-outs here. What is wild is the way they’ve wrapped npx and the node package manager around calling different .NET binaries for each platform. I think its time that .NET had an npx equivalent.

They have been good and for now restricted the operations to read-only. But this is only a short leap away from the MCP server being able to do tasks like creating resources and then its just another short leap away from deleting them. The team know they are on the edge of something pretty crazy here, so have added one of the best worded disclaimers I’ve ever seen:

MCP as a phenomenon is very novel and cutting-edge. As with all new technology standards, consider doing a security review to ensure any systems that integrate with MCP servers follow all regulations and standards your system is expected to adhere to. This includes not only the Azure MCP Server, but any MCP client/agent that you choose to implement down to the model provider.

Basically trying to pass on any blame if something goes wrong.

One amazing example of Microsoft left hand not talking to the right hand is that the MCP server they’ve built isn’t currently compatible with their own Semantic Kernel framework due to the function names having hyphens instead of underscores, which means they’ve only tested it using the VSCode/Github Copilot MCP client and not their own .NET agents framework. Classic.

Azure MCP: https://github.com/Azure/azure-mcp

Days since Microsoft open source drama: 0

The author of popular Kubernetes open source project Spegel saw parts of their project copied by the Azure team to a project called Peerd. Spegel is an OSS project released under the MIT license, so so what I hear you cry? Well the MIT license requires the copyrights of the author to remain in the source code and to be distributed with the software - the dev teams at Microsoft removed the LICENSE file from the “fork”, replacing it with their own, violating the license and therefore technically the copyright.

The blog post explains that MS “interviewed” the author before the “fork”, doing a brain dump from the author (probably recorded into OneNote and summarised by Copilot). A similar technique to the WinGet / AppGet clone drama.

The Hacker News outrage has been brutal and in my opinion justified. I also put the word “fork” in quotes because in reality it looks like the project was copy and pasted, which isn’t technically a “fork”. This Hacker News sleuth figured it out.

Based on the commit history of Peerd essentially being a single person, I think that someone thought this was a slam dunk project for a promotion. Well, they’ve just set MS’s trust with the open source community back several years instead.

The post: https://philiplaine.com/posts/getting-forked-by-microsoft/
The Github meltdown: https://github.com/Azure/peerd/issues/109
The damage control PR reply: https://news.ycombinator.com/item?id=43755745

Thanks for reading as always! For a video version of this post, be sure to check out:

This week has seen a couple of interesting emissions from the MS teams. I’ve read about them so you don’t have to. Thanks for remaining a newsletter subscriber as I try out this new format - let me know if it works for you.

.NET 10 Preview 3 lands

Microsoft just dropped the third preview of .NET 10, the latest sneak peek at the next Long-Term Support (LTS) version due later this year. LTS releases are very important as they are quite short lived (3 years) and every .NET 8 app will have only a year to update to .NET 10 before support stops, creating a bunch of activity. They’ve been busy…

Highlights:

• C# 14: Just what we’ve always wanted (!) - extension methods, which let you add static methods, instance properties, and static properties to existing types like Ruby Monkey Patching from 2014. There's also a cleaner way to handle nulls with null-conditional assignment.

• ASP.NET Core & Blazor: Blazor is still going (yeah), with some improvements to manage state. Blazor WebAssembly apps now get default HttpClient response streaming for better memory usage with large responses and support for fingerprinted static assets for better caching. Plus, built-in support for Server-Sent Events (SSE) is here for real-time updates - could this finally be the end of SignalR?

• .NET MAUI is still alive: MAUI devs will lament the loss of ListView, Cell and TableView as they are being deprecated. On the plus side, you get fullscreen video playback in Android WebViews and an easier way to check if location services are enabled with Geolocation.IsEnabled.

Helpful Links:

• .NET Blog Announcement: https://devblogs.microsoft.com/dotnet/dotnet-10-preview-3/

• InfoQ Article: https://www.infoq.com/news/2025/04/dotnet-10-preview3/

• .NET 10 Release Notes (GitHub): https://github.com/dotnet/core/tree/main/release-notes/10.0

• .NET Downloads: https://dotnet.microsoft.com/download/dotnet/10.0

Semantic Kernel adds MCP and Google's A2A for Python users

Microsoft's Semantic Kernel for Python just got a major upgrade, adding support for two important interoperability protocols: the Model Context Protocol (MCP) and Google's Agent-to-Agent (A2A) protocol - bringing it up to parity with the C# and .NET versions, which saw MCP capability added in March.

I’m normally super salty about this stuff, but seeing it come through first for .NET has been great, likely because they are using it for Copilot under the hood.

What does this mean?

• MCP: SK can now act as both an MCP host/client and an MCP server. Think of MCP like a "USB for AI" – it standardizes how AI apps connect to external tools and data. As a host, your SK agent can easily use tools exposed by any MCP server (like those for GitHub, Slack, or custom systems). As a server, you can share your SK functions, prompts, or even entire agents with other MCP clients, like Anthropic's Claude Desktop or potentially IDEs. This makes building complex, modular AI systems much easier if that is your kind of thing.

• A2A Integration: SK now also integrates with Google's A2A protocol , which is designed for communication between different AI agents. The example MS have provided shows a “travel manager” agent delegating tasks (like currency conversion or activity planning) to specialized sub-agents using A2A for discovery and routing.

Sources:

• SK MCP Blog Post (Python): https://devblogs.microsoft.com/semantic-kernel/semantic-kernel-adds-model-context-protocol-mcp-support-for-python/

• SK A2A Blog Post (Python): https://devblogs.microsoft.com/semantic-kernel/integrating-semantic-kernel-python-with-googles-a2a-protocol/

• MCP Official Documentation: https://modelcontextprotocol.io/introduction

• Google A2A Repository (with SK sample): https://github.com/google/A2A

• SK Python MCP Samples: https://github.com/microsoft/semantic-kernel/tree/main/python/samples/concepts/mcp/

• SK Python MCP Demos: https://github.com/microsoft/semantic-kernel/tree/main/python/samples/demos/mcp_server/

Copilot can now help with Azure SQL

Microsoft have added a load of new Copilot functionality to the Azure Portal, to basically save you a Google search or two.

You can now prompt it to help you…

• Troubleshoot SQL Errors: Get help diagnosing common SQL errors (like 10928, 18456, 40613) with explanations and suggested fixes.

• Optimize Performance: Identify potential bottlenecks like storage or I/O limits and get recommendations.

• Simplify Configuration: Get guidance on choosing service tiers or constructing connection strings.

• Manage Security: Get assistance with Transparent Data Encryption (TDE) issues or data replication problems.

Now originally they planned to allow you to use Copilot to directly write database queries in the Query editor within the Azure Portal, but it looks like they’ve decided to push this back and keep it exclusive to a future SSMS release. Seemed pretty useful.

More info:

• Azure SQL Blog Announcement: https://techcommunity.microsoft.com/blog/azuresqlblog/announcing-general-availability-of-azure-sql-database-capabilities-for-microsoft/4403518

• Microsoft Copilot in Azure Overview: https://learn.microsoft.com/en-us/azure/copilot/overview

• Copilot in Azure with Azure SQL DB: https://aka.ms/sqlcopilot

• FAQ: https://aka.ms/sqlcopilot-faq

• Copilot in SSMS Session (SQL Conf 2025): https://learn.microsoft.com/en-us/shows/azure-developers-sql-conf-2025/a-developers-guide-to-using-copilot-in-ssms

Here is a video version of this post:

If there is anything you’d like to see me cover next week, send me a DM on Twitter/X at @edandersen. Cheers.