.NETPro #26 | Special Edition: Extension Members — Past, Present, and Future
🌍 Unlock real-world .NET skills with experts guiding every step
Imagine augmenting any type in C#, strings, collections, even sealed classes, with methods, properties, operators, and more, all without touching the original code. That has been the magic of extension methods since 2007.
But C# 14, now live with .NET 10, supercharges the concept. Sleek extension blocks group related members logically. You can add extension properties like IsEmpty, static extensions, and even operators, and it all feels natural and cohesive.
And the best part? Early previews of C# 15 are already hinting at an even broader expansion, including constructors, indexers, and nested types. Extensions are evolving into an incredibly powerful way to build clean, expressive libraries.
In this issue, Mark J. Price traces this remarkable journey with examples and forward-looking insights that will spark ideas for your own code. Dive in and rediscover why extension members remain one of C#’s most compelling superpowers.
Before you jump in, check out these highlights from our last editions if you missed them:
➡️ Discover GitHub Copilot Testing for .NET in Visual Studio 2026
➡️ Explore the first preview release of .NET 11
➡️ Windows 11 Is Dropping .NET Framework 3.5
➡️ Understanding the Building Blocks for AI in .NET
➡️ Create standard and “observable” instruments with Andrew Lock
➡️ Build a recommendation engine with MongoDB Vector Search and .NET with Milan Jovanović
Cheers!
Adrija Mitra
Editor-in-Chief
🧑💻 Master Modern .NET Development with Mark J. Price
🔭 Extension Members — Past, Present, and Future
For nearly two decades, C# developers have relied on extension methods to add new behavior to types they do not own. That story began in 2007 with C# 3, continued with a major expansion in C# 14, and is now poised for even broader capabilities in the upcoming C# 15, expected in November 2026.
How It All Started: Extension Methods in C# 3
The concept of extension methods was introduced with C# 3 alongside LINQ and .NET 3.5 in 2007. Extension methods let you write a static method in a static class and, by marking the first parameter with this, call that method as if it were an instance method on the target type. This made patterns like LINQ both expressive and discoverable in editor tooling.
For example, you can extend the string type with an IsEmail extension method:
using System.Text.RegularExpressions;
public static class StringExtensions
{
private static readonly Regex EmailRegex = new(
@"^[^@\s]+@[^@\s]+\.[^@\s]+$",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
public static bool IsEmail(this string? value)
{
if (string.IsNullOrWhiteSpace(value))
return false;
return EmailRegex.IsMatch(value);
}
}You can then call IsEmail() on any string instance or variable, and the compiler will bind it as a static method under the hood:
bool ok1 = "mark@example.com".IsEmail(); // true
bool ok2 = "not-an-email".IsEmail(); // false
bool ok3 = "".IsEmail(); // falseNote that these extension methods are defined as static but are called as if they are instance methods.
This syntax for defining extension methods was the way to extend C# types for over fifteen years.
Expanding Extension Members with C# 14
That long-standing pattern had limitations. You could only create extension methods, and there was no easy way to group multiple related extensions neatly or to extend other kinds of members, such as properties or static members.
C# 14, shipped with .NET 10 in November 2025, expands this model. Instead of defining only one static method per extension, you now have extension blocks that let you define multiple extension members for a type in one place.
Inside an extension(Type) { ... } block, you can define instance extension methods, static extension methods, extension properties, and operators using a more natural, type-centric syntax. The classic this-parameter approach still works, so existing extensions continue to compile and run.
For example, you can group related extensions, such as a property and a method for the IEnumerable<T> type, like this:
public static class EnumerableExtensions
{
extension<T>(IEnumerable<T> seq)
{
public bool IsEmpty => !seq.Any(); // property
public IEnumerable<T> SkipFirst() => seq.Skip(1); // method
}
}This “extension everything” approach makes extension members feel as though they truly belong to the type you are augmenting. Beyond instance members, you gain support for static extension methods and even extension properties without resorting to awkward workarounds.
Looking Ahead: More Member Types in C# 15
While C# 14’s extension members give us static methods, properties, and operators, work in the language design community shows that the team is thinking even bigger for future releases, such as C# 15.
Proposals in the C# language repository discuss generalizing extension support to any member type, including constructors, indexers, and nested types, with extensibility baked into the syntax and semantics of the language. These proposals aim to let extension declarations add a broad range of member kinds to types you do not control.
With such proposals under discussion, we may see C# evolve into a language where adding rich, reusable, type-level behavior through extension declarations becomes commonplace without modifying the original class definition.
Summary of Extension Member Support
The following table summarizes extension member support over the past two decades of .NET:
Final Thoughts
C#’s evolution from simple extension methods in C# 3 to full extension member blocks in C# 14 reflects the language team’s efforts to balance long-standing idioms with expressive new capabilities. The ongoing proposals for C# 15 suggest that developers will have even finer-grained control over augmenting types without inheritance or source modification. For library authors and API designers, this means cleaner semantics, better discoverability, and fewer workarounds to express what was once hard or impossible.
References
Here are some useful links to learn more about extension members:
Extension members (C# Programming Guide): https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods
C# 14 - Exploring extension members - .NET Blog: https://devblogs.microsoft.com/dotnet/csharp-exploring-extension-members/
[Proposal]: extension methods, properties, and operators: https://github.com/dotnet/csharplang/issues/8697
📝 Spotted something worth calling out?
We’d love to hear about it—just drop us a quick note through this 1-minute survey. We’re all ears!
💌 Got something interesting to share or want your project featured? Just reply to this email and share your ideas.
And that’s a wrap 🎬
We’re glad you joined us for this edition of .NETPro!
If you have any thoughts, questions, or feedback on this edition, or if you’d like to share what you’d love to see next, feel free to take our 1-minute survey or hit Reply and drop us a note. We’d love to hear from you.
Thanks for following along! Until next time, keep learning and keep building.
Why does this always direct me to the USA amazon site instead of the UK amazon site.. all the links break when u switch to amazon UK from amazon us.....