Extension members is my favorite feature in C# 14. They represent a modern evolution of extension methods that have been part of C# since version 3.0.

This new syntax makes it easier to add not just methods, but also properties to existing types and static members.

In this post, we will explore:

• How the extension keyword differs from traditional extension methods
• Creating instance extension properties
• Adding static extension members to types
• Working with generics and type constraints
• Real-world examples for using extension members
• Best practices for organizing extension code

Let's dive in!

C# developers have used extension methods since C# 3.0 to add functionality to types without modifying their source code.

In the traditional approach, you create a static class with static methods.

Before C# 14, you created extensions by writing static methods with a this parameter:

csharp
1public static class StringExtensions
2{
3    public static bool IsNullOrEmpty(this string value)
4    {
5        return string.IsNullOrEmpty(value);
6    }
7    
8    public static string Truncate(this string value, int maxLength)
9    {
10        if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
11        {
12            return value;
13        }
14            
15        return value.Substring(0, maxLength);
16    }
17}

C# 14 introduces the extension keyword, bringing a modern approach to extending types.

The new syntax separates the receiver (the type you're extending) from the members you're adding. Instead of putting this on each method parameter, you declare an extension block that specifies the receiver once:

csharp
1public static class StringExtensions
2{
3    extension(string value)
4    {
5        public bool IsNullOrEmpty()
6        {
7            return string.IsNullOrEmpty(value);
8        }
9        
10        public string Truncate(int maxLength)
11        {
12            if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
13            {
14                return value;
15            }
16                
17            return value.Substring(0, maxLength);
18        }
19    }
20}

The extension block takes the receiver as a parameter. Inside the block, you write your methods and properties just like they were actual members of the type. The value parameter is available to all members within the block.

Both old and new syntax compile to identical code, so they work the same way. The new syntax is optional and designed to work alongside the traditional this parameter approach.

The new extension supports extending:

• Methods
• Properties
• Static methods
• Static properties

Extension properties make your code more readable and expressive. Instead of calling methods, you can use properties that feel more natural.

For example, when working with collections, you frequently check if they're empty. Instead of writing !items.Any() everywhere, you can create an IsEmpty property:

csharp
1public static class CollectionExtensions
2{
3    extension<T>(IEnumerable<T> source)
4    {
5        public bool IsEmpty => !source.Any();
6
7        public bool HasItems => source.Any();
8
9        public int Count => source.Count();
10    }
11}
12
13public void ProcessOrders(IEnumerable<Order> orders)
14{
15    if (orders.IsEmpty)
16    {
17        Console.WriteLine("No orders to process");
18        return;
19    }
20
21    foreach (var order in orders)
22    {
23        // Process order
24    }
25}

Static extensions allow you to add factory methods or utility functions to a type, rather than to an instance. To create static extensions, use extension without naming the receiver parameter:

csharp
1public static class ProductExtensions
2{
3    extension(Product)
4    {
5        public static Product CreateDefault() =>
6            new Product
7            {
8                Name = "Unnamed Product",
9                Price = 0,
10                StockQuantity = 0,
11                Category = "Uncategorized",
12                CreatedDate = DateTime.UtcNow
13            };
14
15        public static bool IsValidPrice(decimal price) =>
16            price >= 0 && price <= 1000000;
17
18        public static string DefaultCategory => "General";
19    }
20}

You can call these static members directly on the type:

csharp
1var product = Product.CreateDefault();
2if (Product.IsValidPrice(999.99m))
3{
4    product.Price = 999.99m;
5}

Generic extensions let you write code that works with multiple types. This is useful when working with collections or interfaces.

Let's extend IEnumerable<T> to add filtering and transformation capabilities:

csharp
1public static class EnumerableExtensions
2{
3    extension<T>(IEnumerable<T> source)
4    {
5        public IEnumerable<T> WhereNotNull() =>
6            source.Where(item => item != null);
7        
8        public Dictionary<TKey, List<T>> GroupToDictionary<TKey>(
9            Func<T, TKey> keySelector) where TKey : notnull =>
10            source.GroupBy(keySelector)
11                  .ToDictionary(g => g.Key, g => g.ToList());
12    }
13}

Here we add a where TKey : notnull constraint to the GroupToDictionary method. This ensures that the key selector returns a non-nullable property.

Now you can chain these extensions with LINQ methods:

csharp
1var products = _productService.GetAll();
2
3var productsByCategory = products
4    .WhereNotNull()
5    .Where(p => p.IsAvailable)
6    .GroupToDictionary(p => p.Category);
7
8foreach (var category in productsByCategory)
9{
10    Console.WriteLine($"{category.Key}: {category.Value.Count} products");
11}

You can also add type constraints to ensure your extensions only work with specific types. Here's an extension that works only with numeric types:

csharp
1public static class NumericExtensions
2{
3    extension<T>(IEnumerable<T> source)
4        where T : INumber<T>
5    {
6        public T Sum()
7        {
8            var total = T.Zero;
9            foreach (var item in source)
10            {
11                total += item;
12            }
13            return total;
14        }
15        
16        public T Average()
17        {
18            var enumerable = source.ToList();
19
20            var sum = enumerable.Sum();
21            var count = T.CreateChecked(enumerable.Count);
22
23            return sum / count;
24        }
25        
26        public IEnumerable<T> GreaterThan(T threshold) =>
27            source.Where(x => x > threshold);
28    }
29}

This extension works with any numeric type that implements INumber<T>:

csharp
1var prices = new[] { 10.99m, 25.50m, 5.00m, 15.75m };
2var expensiveItems = prices.GreaterThan(15.00m);
3var averagePrice = prices.Average();

When building web APIs, you often need to extract information from HttpContext.

Instead of writing the same extraction code repeatedly, you can create extensions that make it cleaner:

csharp
1public static class ApiHttpContextExtensions
2{
3    extension(HttpContext context)
4    {
5        public string CorrelationId =>
6            context.Request.Headers["X-Correlation-ID"].FirstOrDefault()
7                ?? Guid.NewGuid().ToString();
8
9        public string ClientIp =>
10            context.Request.Headers["X-Forwarded-For"].FirstOrDefault()
11                ?? context.Connection.RemoteIpAddress?.ToString()
12                ?? "Unknown";
13
14        public bool IsApiRequest =>
15            context.Request.Path.StartsWithSegments("/api");
16
17        public string? GetBearerToken()
18        {
19            var authHeader = context.Request.Headers["Authorization"].FirstOrDefault();
20            if (authHeader?.StartsWith("Bearer ") == true)
21            {
22                return authHeader.Substring("Bearer ".Length).Trim();
23            }
24            return null;
25        }
26
27        public T? GetQueryParameter<T>(string key)
28        {
29            if (context.Request.Query.TryGetValue(key, out var value))
30            {
31                try
32                {
33                    return (T?)Convert.ChangeType(value.ToString(), typeof(T));
34                }
35                catch
36                {
37                    return default;
38                }
39            }
40            return default;
41        }
42
43        public void AddResponseHeader(string key, string value)
44        {
45            context.Response.Headers[key] = value;
46        }
47    }
48
49    extension(HttpContext)
50    {
51        public static bool IsValidPath(string path) =>
52            !string.IsNullOrWhiteSpace(path) && path.StartsWith("/");
53    }
54}

Now your middleware and controllers are much cleaner:

csharp
1public class RequestLoggingMiddleware(
2    RequestDelegate next,
3    ILogger<RequestLoggingMiddleware> logger)
4{
5    public async Task InvokeAsync(HttpContext context)
6    {
7        _logger.LogInformation(
8            "Request {Method} {Path} from {ClientIp} with CorrelationId {CorrelationId}",
9            context.Request.Method,
10            context.Request.Path,
11            context.ClientIp,
12            context.CorrelationId);
13        
14        context.AddResponseHeader("X-Correlation-ID", context.CorrelationId);
15        
16        await _next(context);
17    }
18}
19
20[ApiController]
21[Route("api/[controller]")]
22public class OrdersController : ControllerBase
23{
24    [HttpGet]
25    public IActionResult GetOrders(HttpContext httpContext)
26    {
27        var pageSize = httpContext.GetQueryParameter<int?>("pageSize") ?? 10;
28        var pageNumber = httpContext.GetQueryParameter<int?>("page") ?? 1;
29
30        var orders = orderService.GetPaged(pageNumber, pageSize);
31        return Ok(orders);
32    }
33}

The code is more readable because the extension properties hide the complexity of header extraction and provide sensible defaults.

When using the extension keyword, you can group multiple extension members that apply to the same type in a single extension block. This reduces repetition and keeps related code together.

You can have multiple extension blocks in one static class if you need different receivers or different generic type parameters:

csharp
1public static class CollectionExtensions
2{
3    extension<T>(IEnumerable<T> source)
4    {
5        public bool IsEmpty => !source.Any();
6
7        public bool HasItems => source.Any();
8
9        public int Count => source.Count();
10    }
11
12    extension(IEnumerable<string> source)
13    {
14        public string JoinWithComma() => string.Join(", ", source);
15        public IEnumerable<string> NonEmpty() => source.Where(s => !string.IsNullOrEmpty(s));
16    }
17
18    extension<T>(List<T> list)
19    {
20        public void AddIfNotExists(T item)
21        {
22            if (!list.Contains(item))
23            {
24                list.Add(item);
25            }
26        }
27    }
28}

You can also mix the traditional this parameter syntax with the new extension keyword syntax in the same class:

csharp
1public static class StringExtensions
2{
3    // Traditional syntax
4    public static bool IsEmail(this string value)
5    {
6        return value.Contains("@");
7    }
8    
9    // New syntax
10    extension(string value)
11    {
12        public bool IsUrl => 
13            Uri.TryCreate(value, UriKind.Absolute, out _);
14        
15        public string ToTitleCase() =>
16            CultureInfo.CurrentCulture.TextInfo.ToTitleCase(value.ToLower());
17    }
18}

Avoid creating a single, giant extension class with extensions for dozens of types. Group related extensions together:

csharp
1public static class ProductExtensions
2{
3    extension(Product product)
4    {
5        // Product-specific extensions
6    }
7}
8
9public static class ValidationExtensions
10{
11    extension(Order value)
12    {
13        // Validation logic
14    }
15    extension(OrderItem value)
16    {
17        // Validation logic
18    }
19}

The choice of organizing your extensions depends on your project needs. You might create separate static classes for each type you're extending, or you might group related extensions by functionality.

If you're creating an extension method that takes no parameters and returns a value, consider making it a property instead:

csharp
1extension(Order order)
2{
3    public decimal TotalPrice => 
4        order.Items.Sum(item => item.Price * item.Quantity);
5}

Extension properties should read like they're part of the original type. Avoid names that make it obvious they're extensions:

csharp
1// Good
2public bool IsEmpty => !source.Any();
3public string DisplayPrice => price.ToString("C");

Add XML code summary on big projects to help other developers understand what your extensions do:

csharp
1extension(Product product)
2{
3    /// <summary>
4    /// Gets whether the product is currently available for purchase.
5    /// </summary>
6    /// <remarks>
7    /// A product is available if its stock quantity is greater than zero.
8    /// </remarks>
9    public bool IsAvailable => product.StockQuantity > 0;
10}

The extension keyword in C# 14 is optional. Your existing extension methods continue to work without changes. However, when you need to add properties, static members or want cleaner syntax for grouping related extensions, the new approach provides a better developer experience.

As you work with C# 14 and .NET 10, experiment with extension properties in your projects. You'll find opportunities to replace methods with properties, making your code more intuitive and easier to use.

If you want to learn more about .NET 10 and C# 14 features, I recommend checking this article.

Hope you find this newsletter useful. See you next time.