C# 14 is almost here, and it’s packed with new features that promise to make your code cleaner, safer, and more expressive. After testing it out, I’ve picked my five favorite features—though I’m not entirely sold on one of them. Let’s dive in.

1. Null-Conditional Assignment

In previous versions like C# 13, developers had to manually check for null before assigning values to properties. For example:

if (channel != null)
channel.Subscribers = 1000;

That’s perfectly fine—but it’s verbose.

With C# 14, we now have null-conditional assignment, which simplifies this logic dramatically. You can write:

channel?.Subscribers = 1000;

This single line safely assigns the value only if channel is not null. Clean, safe, and elegant.

2. The field Keyword for Backing Fields

When working with properties, you’ve probably used private backing fields before:

private int _subscribers;
public int Subscribers
{
get => _subscribers;
set => _subscribers = value;
}

In C# 14, you can now use the field keyword, eliminating the need for an explicit private variable. For example:

public int Subscribers
{
get => field;
set
{
if (value < 1000)
throw new Exception("Not enough subscribers!");
field = value;
}
}

This makes your code more compact while retaining full control over getter/setter logic.

3. User-Defined Compound Operators

This one’s really fun. C# 14 introduces user-defined compound operators, allowing you to overload operators like ++ or + for your custom classes.

For example:

public static Channel operator +(Channel c)
{
c.Subscribers++;
c.Members++;
return c;
}

Now, you can simply write:

channel++;

And both Subscribers and Members will increment automatically. It’s clean, expressive, and surprisingly intuitive once you try it.

4. The New extension Keyword

Extension methods have long been a staple in C#, but their syntax has felt a little dated. Traditionally, you’d define them like this:

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

Now, with C# 14, you can use the new extension keyword directly when defining an extension type:

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

It works exactly the same but uses modernized syntax. Personally, I’m a bit on the fence about this one—it adds variety, but also slightly forks the language’s syntax style.

5. Improved nameof for Open Generics

The nameof operator now supports open generic types, which wasn’t possible before.

In C# 13, the following would fail:

nameof(Channel<>);

But now, in C# 14, this works perfectly fine and returns "Channel". It’s a small change, but handy for code generation, reflection, and diagnostics.

Final Thoughts

C# 14 brings a refreshing mix of quality-of-life improvements and syntactic sugar. The null-conditional assignment and user-defined compound operators are clear winners for everyday developers, while the field keyword modernizes property definitions.

I’m still skeptical about the new extension keyword—it might complicate things for teams mixing old and new syntax—but overall, C# 14 feels like another solid step forward for the language.