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.