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.
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.