C# 13 New Features | 10 Important Features of C# 13 under .NET 9

Exploring New Features in C# 13

Hi .NET learner, I am Shiva Gautam and now i am discussing about C#13 Features, you know very well that now .NET 9.0 is released with C# 13 Version.

here is the latest features of C# 13:

1. Params Collections

The `params` keyword can now be used with any collection type that implements `IEnumerable<T>`. This makes it easier to pass a variable number of arguments to methods.

e.g:

class Program

{

    public static void PrintNumbers(params IEnumerable<int> numbers)

    {

        foreach (var number in numbers)

        {

            Console.WriteLine(number);

        }

    }

    public static void Main()

    {

        PrintNumbers(1, 2, 3, 4, 5);

    }

    

}

2) Enhanced Support for ReadOnlySpan<T>

In C# 13, the support for ReadOnlySpan<T> has been enhanced to allow collection expressions to work directly with this high-performance struct

Benefits of ReadOnlySpan<T>

• Avoids allocations: Since ReadOnlySpan<T> is a stack-allocated struct, it avoids heap allocations, which can benefit performance-critical applications.
• Memory safety: It provides a type-safe way to handle memory, ensuring you do not accidentally modify the underlying data.
• Versatility: ReadOnlySpan<T> can point to managed memory, native memory, or memory managed on the stack, making it versatile for various scenarios.

Consider a scenario where you need to initialize a collection efficiently.
C#

public void AddScores(params int[] scores)
{
    var scoresCollection = new int[] { 75, 88, 92 };
    AddScores(scoresCollection);
}

In C# 13, you can achieve this with better performance using ReadOnlySpan<T>.

public void AddScores(ReadOnlySpan<int> scores)
{
    foreach (var score in scores)
    {
        // Process scores without allocations
    }
}

This is useful for apps that need optimal performance, such as real-time systems, game development, and high-frequency trading applications.

3. New Lock Object

C# 13 introduces the System.Threading.Lock type, designed to improve thread synchronization practices. It boasts a superior API compared to the traditional System.Threading.Monitor approach.

Benefits

• Improved thread safety: By using the System.Threading.Lock type, developers can achieve better synchronization and avoid common pitfalls associated with thread contention.
• Code maintainability: The new API makes the code more readable and maintainable, reducing the complexity of thread synchronization.

4) Auto properties with custom logic

Auto-properties in C# 3 provide a more streamlined way to declare properties without explicit backing fields. However, if you wanted to add custom logic to the getter or setter,

using System;

public class Event
{
    private DateTime eventDate;

    public DateTime EventDate
    {
        get => eventDate;
        set => eventDate = value < DateTime.Now ? DateTime.Now : value;
    }
}

public class Program
{
    public static void Main()
    {
        Event myEvent = new Event();
        
        // Setting a past date.
        myEvent.EventDate = new DateTime(2020, 1, 1);
        Console.WriteLine(myEvent.EventDate); // Outputs current date

        // Setting a future date.
        myEvent.EventDate = new DateTime(2025, 1, 1);
        Console.WriteLine(myEvent.EventDate); // Outputs 2025-01-01
    }
}

5) New escape sequence for ESCAPE character

C# 13 introduces a more convenient way to represent the ESCAPE character (Unicode U+001B) within character literals. This new feature allows developers to use the \e escape sequence instead of the older methods, \u001B or \x1B. This enhancement simplifies code readability and reduces potential errors associated with hexadecimal interpretations.

har escapeChar1 = '\u001B'; // Using Unicode escape sequence.
char escapeChar2 = '\x1B';   // Using hexadecimal escape sequence.

With C# 13, you can now use the \e escape sequence to represent the ESCAPE character. This new method is more intuitive and reduces the likelihood of errors.

6) Implicit Index Access

You can use indices and ranges in a more intuitive way using the `^` operator.

class Program

{

    public static void Main()

    {

        int[] numbers = { 1, 2, 3, 4, 5 };

        int lastElement = numbers[^1];

        Console.WriteLine("Last Element: " + lastElement);

        int secondLastElement = numbers[^2];

        Console.WriteLine("Second to Last Element: " + secondLastElement);

        int[] subArray = numbers[1..4];

        Console.WriteLine("Sub Array: " + string.Join(", ", subArray));

    }

    

}

7. More Partial Members

Partial members allow you to split method, property, and event declarations across multiple files.

// File1.cs

public partial class MyClass

{

    public partial void MyMethod();

}

// File2.cs

public partial class MyClass

{

    public partial void MyMethod()

    {

        Console.WriteLine("MyMethod implementation");

    }

}

8. Overload Resolution Property

You can use the `with` expression to create a new object by copying an existing object's properties.

public class Person

{

    public string Name { get; init; }

    public int Age { get; init; }

}

public class Program

{

    public static void Main()

    {

        Person person1 = new Person { Name = "Alice", Age = 30 };

        Person person2 = person1 with { Age = 35 };

        Console.WriteLine($"Person1: {person1.Name}, {person1.Age}");

        Console.WriteLine($"Person2: {person2.Name}, {person2.Age}");

    }

}

9). The `field` Keyword

The `field` keyword can be used to refer to the backing field of an auto-implemented property.

public class MyClass

{

    public string MyProperty { get; set; } = "Default Value";

    public string MyPropertyWithField

    {

        get => field;

        set

        {

            if (!string.IsNullOrEmpty(value))

            {

                field = value;

            }

        }

    }

}

10) Extension methods

Extension methods have existed since C# 3. They allow us to add new methods to existing types without altering their definitions. These methods are defined as static methods in static classes, and the “this” keyword specifies the type they extend.

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
}