whats new in C# 14.0

Intro

Recently Microsoft released C# 14.0 with lot of new features . More over , re-structuring existing features to make it more easy to understand and more readable.

Listin down the new features in C# 14.0

Field-backed Properties

Field-backed properties allows direct access to the field without declaring an explicit field. its directly access hidden compiled backend field of an auto implemented property usint the new contextual keyword field

In Early version of C# , we have to write lot of code to create properties.

private string _message;
public string Message
{
    get => _message;
    set => _message = value ?? throw new ArgumentNullException(nameof(value));
}

How Field-backed Properties Work in C# 14

• The field keyword is only available inside the get/set/accessor methods of an auto-implemented property. • You can write logic in accessors while enjoying the brevity of auto-properties.

public string Message
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

Extension Members

Extension members allow you to add members to existing types without modifying the type’s source code. This feature is particularly useful when you want to add functionality to types that you don’t have control over, such as third-party libraries or built-in types.

public static class StringExtensions
{
    public static int WordCount(this string str)
        => str.Split(new char[] { ' ', '\t', '\n', '\r' },
                                 StringSplitOptions.RemoveEmptyEntries).Length;
}

You can then use the extension method as if it were a member of the type.

string text = "Hello, World!";
int count = text.WordCount();

Extension members are a powerful feature that can help you write more maintainable and reusable code.

Now , In C# 14 , changed the way to define extension members.

public static class StringExtensions
{
  Extension(string str)
  {
    public int WordCount() => str.Split(new char[] { ' ', '\t', '\n', '\r' },
                                StringSplitOptions.RemoveEmptyEntries).Length;
  }
}

You can then use the extension method as if it were a member of the type.

string text = "Hello, World!";
int count = text.WordCount();

What is the difference Existing Implementations?

• its not maintain all member as a static member. means we allow non-static members inside extension members.
• Beginner friendly way to define extension members.
• its not use this Keyword if it mentioned inside extension .
• if all member are consumed same type then we can have a single grouped extension member.

Example-1

Here, I have showed some extention method existing approach for string type.

public static class StringExtensions
{
    public static int WordCount(this string str) =>
         str.Split([' ', '.', '?'], StringSplitOptions.RemoveEmptyEntries).Length;

    public static string Reverse(this string str)
        => new string(str.ToCharArray().Reverse().ToArray());

    public static bool IsNumeric(this string str)
        =>str.All(char.IsDigit);
}

What if I need to have integer type extension members? will have another class to define extension members for integer type, like below

public static class IntExtensions
{
    public static bool IsEven(this int number)
        => number % 2 == 0;

    public static bool IsOdd(this int number)
        => number % 2 != 0;
}

In new Implementation , we can group all extension members for same type. like below

public static class NewExtension
{
    extension(string str)
    {
        public int NewWordCount()
            =>  str.Split([' ', '.', '?'], StringSplitOptions.RemoveEmptyEntries).Length;

        public string NewReverse()
            => new string(str.ToCharArray().Reverse().ToArray());

        public bool NewIsNumeric()
            => str.All(char.IsDigit);

    }

    extension(int number)
    {
        public bool NewIsEven() => number % 2 == 0;

        public bool NewIsOdd() => number % 2 != 0;
    }
}

You can then use the extension method as if it were a member of the type and thers is no changes in calling/implementation.

   var Name = "My New Extensions";
   Console.WriteLine("This one From word Count Traditional way: "+ Name.WordCount());
   Console.WriteLine("This one From word Count Traditional way: "+ Name.Reverse());
   Console.WriteLine("This one From word Count New way: "+Name.NewIsNumeric());

Null-Conditional Assignment

Null-conditional assignment is a feature that allows you to assign a value to a property or field only if the target object is not null. This feature is particularly useful when you want to avoid null reference exceptions.

public class Person
{
    public string? Name { get; set; }
    public int Age { get; set; }
}

Person person = null;
person?.Name = "John"; // This will not throw a null reference exception
person?.Age = 30; // This will not throw a null reference exception

User-defined Compound Assignment Operators

User-defined compound assignment operators allow you to define custom behavior for compound assignment operators, such as +=, -=, *=, /=, and %=.

In C# 13, we can write like this

 public class UserdefineOperators
{

    public int Value;

    public static UserdefineOperators operator +(UserdefineOperators left, int delta)
    {
        // Option 1: mutate and return same instance
        left.Value += delta;
        return left;

        // Option 2 (more functional): return a new instance
        // return new Counter { Value = left.Value + delta };
    }
}

 static void Main()
 {
    var c = new UserdefineOperators { Value = 10 };
    c += 5;
    Console.WriteLine(c.Value.ToString());
 }

In C#14, we have write above code as like below,

public class UserdefineOperators14
{
    public int Value;

    public void operator +=(int delta)
    {
        Value += delta; // in-place mutation
    }

}

 static void Main()
 {
    var c = new UserdefineOperators { Value = 10 };
    c += 5;
    Console.WriteLine(c.Value.ToString());
 }

What are new changes in C# 14,you can define a dedicated compound assignment operator that:

Partial Constructors or Events

C# 13 support partial implementation in properties and indexers. it doesn’t support partials consutrutors/events. Construtors / Events must live entirely in one declaration as per signature.

Partial constructors allow you to define multiple constructors for a type, each with different parameters. This feature is particularly useful when you want to avoid null reference exceptions. it can be implemented in class/struct.

 public partial class Order
{
    partial Order(int id, string customer);
}

public partial class Order
{
    partial Order(int id, string customer)
    {
        Id = id;
        Customer = customer;
    }
}

A new approach has been introduced in C# 14

public partial class Foo
{
    public partial event EventHandler? SomethingHappened;
}

public partial class Foo
{
    public partial event EventHandler? SomethingHappened
    {
        add
        {
            // custom logic (e.g., weak subscription, logging)
        }
        remove
        {
            // matching remove logic
        }
    }
}

Modifier Support on Lambda Params

C# 14 introduces support for parameter modifiers on simple (implicitly typed) lambda parameters, allowing cleaner syntax without explicit types. This applies when types can be inferred from the delegate or target context.

Supported Modifiers

These modifiers work on lambda parameters without requiring type declarations:

Example :

 TryParse<int> parse14 = (text, out result) => int.TryParse(text, out result);

 delegate void Doubler(ref int number);

Doubler double14 = (ref number) => number *= 2;

Implicit Span Conversions

C# 14 introduces implicit span conversions for more natural use of  Span < T > and ReadOnlySpan < T > types, eliminating the need for explicit  .AsSpan()  calls in many scenarios. These conversions enhance performance in memory-intensive code while maintaining safety.

Nameof Supports Unbound Generics

starting with C# 14, the nameof operator now supports unbound generic types. This means you can directly use nameof on a generic type definition (like List < > or Dictionary < , > quote ) without needing to supply placeholder type arguments.

Example:

 // C# 13
 var name = nameof(List<>); // ❌ Not allowed before C# 14

 var name = nameof(List<int>); // ✅ Worked, but misleading

//C# 14
 var name = nameof(List<>); // ✅ Allowed in C# 14
 var dictName = nameof(Dictionary<,>); // ✅ Works too

Primary Constructors for Classes

to be added soon …

Ref Fields and Scoped Modifiers

In C# 14, you can now use ref fields and apply modifiers like ref, in, out, scoped, and ref readonly directly on lambda parameters without explicitly declaring their types. This reduces boilerplate and improves performance-oriented code readability

Ref Fields in C# 14

 public ref struct Buffer
{
    private ref int _value;

    public Buffer(ref int value)
    {
        _value = ref value;
    }

    public ref int GetValue() => ref _value;
}

Here, _value is a ref field, meaning it points directly to the referenced memory location.

Scoped Modifiers in C# 14

Example:

Span<int> numbers = stackalloc int[] { 1, 2, 3 };

Func<scoped Span<int>, int> sum = (scoped nums) =>
{
    int total = 0;
    foreach (var n in nums) total += n;
    return total;
};

Console.WriteLine(sum(numbers)); // Output: 6

[Top]