← Back to blog

Oct 22, 2026 · 10 min read

C# 14 and .NET 10: Extension Members, Field-Backed Properties, and What Actually Changed

C# 14 ships with .NET 10, and the headline feature is extension members — but there's a lot more that makes everyday C# cleaner. Here's a practical tour.

.NETC#Backend

C# 14 ships with .NET 10, and it's a release focused on reducing everyday friction. The headline feature is extension members, which finally brings extension properties and static extensions to C#. But there's a lot more that makes the language cleaner without changing how you think.

Extension members: the headline feature

C# has had extension methods since C# 3. They let you add methods to a type you don't own. C# 14 extends this to properties, static members, and operators.

"Extension members are the headline feature of C# 14. The new syntax is fully compatible with existing extension methods. Extension members enables extension properties, extension operators, and static extension members." — Microsoft .NET Blog

The new syntax uses an extension block:

public static class EnumerableExtensions
{
    // Instance extension property
    extension<TSource>(IEnumerable<TSource> source)
    {
        public bool IsEmpty => !source.Any();

        public IEnumerable<TSource> Where(Func<TSource, bool> predicate)
            => source.Where(predicate);
    }

    // Static extension members
    extension<TSource>(IEnumerable<TSource>)
    {
        public static IEnumerable<TSource> Combine(
            IEnumerable<TSource> first,
            IEnumerable<TSource> second)
            => first.Concat(second);

        public static IEnumerable<TSource> Identity
            => Enumerable.Empty<TSource>();
    }
}

Now you can write strings.IsEmpty as a property instead of !strings.Any(). It reads like a built-in member of the type.

Extension operators (added in Preview 7) let you define operators as extensions:

public static class VectorOperators
{
    extension<TElement>(TElement[] source) where TElement : INumber<TElement>
    {
        public static TElement[] operator *(TElement[] vector, TElement scalar)
            => vector.Select(x => x * scalar).ToArray();

        public static bool operator ==(TElement[] left, TElement[] right)
            => left.SequenceEqual(right);

        public static bool operator !=(TElement[] left, TElement[] right)
            => !left.SequenceEqual(right);
    }
}

The key compatibility note: extension blocks are source and binary compatible with existing extension methods. You can migrate one method at a time. Dependent assemblies don't need to be recompiled.

Field-backed properties

This is one of those small features that removes a lot of boilerplate. In C# 13, if you wanted to add validation to an auto-property, you had to write the full property with a backing field:

// Before: full backing field
private string _name = "";
public string Name
{
    get => _name;
    set => _name = string.IsNullOrWhiteSpace(value) ? "" : value;
}

In C# 14, the field contextual keyword lets you access the compiler-generated backing field directly:

// After: field-backed property
public string Name { get; set => field = string.IsNullOrWhiteSpace(value) ? "" : value; }

You get the brevity of an auto-property with the flexibility of a custom setter.

Null-conditional assignment

The ?. operator now works for assignment:

// Before
if (customer != null)
{
    customer.LastOrderDate = DateTime.Now;
}

// After
customer?.LastOrderDate = DateTime.Now;

Small change, but it removes a common conditional block and makes the intent clearer.

nameof supports unbound generic types

// Before: had to provide a type argument
var name = nameof(List<int>);

// After: can use unbound generic type
var name = nameof(List<>);  // Returns "List"

This is useful in reflection-heavy code and source generators where you want to reference a type by name without specifying type arguments.

Lambda parameter modifiers

You can now use ref, in, out, and params on lambda parameters without specifying the parameter type:

delegate void Mutator(ref int x);
Mutator increment = (ref x) => x++;

This makes lambdas more consistent with named methods.

Partial events and constructors

C# 13 added partial properties. C# 14 adds partial events and partial instance constructors. This is primarily for source generators, which can now generate parts of events and constructors alongside the user-written parts.

public partial class ViewModel
{
    public partial ViewModel();  // Generated code provides the other part

    public partial event EventHandler? Changed;  // Generated code provides the other part
}

User-defined compound assignment operators

You can now define +=, -=, ++, and -- as extension operators:

extension<TElement>(TElement[] source) where TElement : INumber<TElement>
{
    public void operator +=(TElement value)
    {
        for (int i = 0; i < source.Length; i++)
            source[i] += value;
    }
}

Should you upgrade?

If you're on .NET 9 / C# 13, the upgrade to .NET 10 / C# 14 is low-risk. The language changes are additive — nothing is removed, and the new features are opt-in. The extension member syntax is optional; your existing extension methods continue to work unchanged.

The field-backed property feature alone is worth the upgrade for most codebases. It removes one of the most common sources of boilerplate in C#.

"C# 14 ships with .NET 10. The highlight is new extension members, but there's a lot more features that make your life as a developer more productive." — Bill Wagner, Microsoft

The bigger picture

C# has been on a multi-year trajectory of removing friction without changing the language's character. Extension members are the most visible example, but the pattern is consistent: take something that required boilerplate (full backing fields, conditional null checks, explicit type arguments in lambdas) and make it implicit.

If you've been waiting for a release to upgrade to, .NET 10 / C# 14 is a good one. The features are practical, the compatibility story is strong, and the tooling support is already there.

Need help applying this?

Schedule call →