Every .Net Developer Must Learn These Latest Features in C# Version 11 and 12

Introduction

C# is an object-oriented programming language widely used to build desktop applications, web applications, mobile apps and games. Thanks to its versatility, efficiency, and ease of use, it is considered one of the most popular programming languages.

C# has undergone several updates, significantly improving versions 11 and 12. These updates have introduced more robust features, including the ability to write code more concisely and readable.

These latest versions of C# introduce several new features designed to improve developer productivity and code performance. Moreover, C# 11 and 12 also introduce new syntax and language constructs that make it easier for developers to write clean, concise, and maintainable code. For instance, introducing interpolated strings in C# 12 lets developers embed expressions and variables in string literals easily, making writing complex string formatting code easier.

In this article, we will detail the latest features of C# versions 11 and 12, highlighting their impact and advantages for developers.

What's New in C# Version 11

Static Virtual Members in Interfaces for Generic Math Support

C# 11 significantly enhances interfaces by introducing static abstract members. This allows interfaces to declare static methods, properties, and operators without implementing them. It proves particularly beneficial in generic math, exemplified by interfaces like System.IAdditionOperators<TSelf, TOther, TResult>. These interfaces facilitate the definition of mathematical operators, such as operator +, tailored for specific types. Including static virtual members in interfaces augments generic types, offering flexibility and expressiveness. Additionally, this feature streamlines code by reducing the need for separate utility classes for mathematical operations. These operations can be neatly encapsulated within the interfaces, fostering a more integrated and coherent approach to type-specific operations.

This snippet shows how the IAdditionOperators<TSelf, TOther, TResult> interface can be used to define a generic addition operation and how a Vector2 struct can implement this interface to provide a specific addition logic for vector types.

interface IAdditionOperators<TSelf, TOther, TResult>
    where TSelf : IAdditionOperators<TSelf, TOther, TResult>
{
    // Static abstract method declaration
    static abstract TResult Add(TSelf left, TOther right);
}

// Example implementation for a specific type
public struct Vector2 : IAdditionOperators<Vector2, Vector2, Vector2>
{
    public double X { get; set; }
    public double Y { get; set; }

    // Implementing the static abstract method
    public static Vector2 Add(Vector2 left, Vector2 right)
    {
        return new Vector2 { X = left.X + right.X, Y = left.Y + right.Y };
    }
}

Numeric `IntPtr` and `UIntPtr`

The introduction of nint and nuint in C# 9, further consolidated in C# 11, represents a pivotal enhancement in handling pointers and native integers. These aliases are directly linked to System.IntPtr and System.UIntPtr, respectively, aligns closely with their underlying types. This development simplifies operations involving pointers and native integers, a domain traditionally marked by verbosity and complexity.

Alias for IntPtr and UIntPtr: Initially introduced in C# 9, nint and nuint served as contextual keywords aligning with IntPtr and UIntPtr. In C# 11, this alignment was strengthened, making nint and nuint exact aliases for System.IntPtr and System.UIntPtr, underscoring their identity rather than mere similarity.

Simplification of Syntax: Before the advent of nint and nuint, operations involving pointers and native integers were often more complex and verbose. The new aliases significantly streamline the syntax, fostering a more intuitive and efficient coding experience, especially in low-level programming contexts.

Enhanced Low-Level Programming: Introducing these aliases has improved the ease of working with pointers and native integers in C#. Their utility is particularly pronounced in scenarios requiring direct interaction with the platform-specific code or interoperability across diverse software components.

Platform-Dependent Size: A distinctive feature of nint and nuint is their platform-dependent sizing. On a 32-bit system, they are represented as 32 bits, while on a 64-bit system, they are 64 bits. This adaptability is crucial for scenarios where integer size needs to match the pointer size of the platform, enhancing the flexibility and applicability of these types across different architectures.

The introduction and enhancement of nint and nuint in C# have simplified the coding process and enriched the toolkit available for developers working with low-level code, contributing to more readable and maintainable software solutions in this domain.

// Example of using nint and nuint in C# 11

// Declaration of native integer variables
nint nativeInt = 10;
nuint nativeUInt = 20;

// Example of arithmetic operation
nint sum = nativeInt + (nint)nativeUInt;

// Platform-dependent sizing demonstration
Console.WriteLine($"Size of nint: {sizeof(nint)} bytes");
Console.WriteLine($"Size of nuint: {sizeof(nuint)} bytes");

// Output will vary based on the platform (32-bit or 64-bit)

Unsigned Right-shift Operator in C#

In C#, the introduction of the unsigned right-shift operator (>>>) is a valuable addition, enhancing the language's ability to handle bitwise operations. This operator performs a right-shift on binary numbers but differs from the traditional right-shift operator (>>) in a key aspect:

Zero-Filling: Unlike the >> operator, which replicates the high-order bit (sign bit), the >>> operator shifts the bits to the right and fills the leftmost bit with 0, regardless of the sign of the number.
Predictable Results: This zero-filling approach results in more predictable outcomes, which is beneficial when dealing with unsigned binary numbers.
Use Cases: The >>> operator is especially valuable in precise bitwise operations, such as algorithms involving unsigned numbers, data processing, or low-level hardware interactions.
Behavior in Different Contexts: It behaves consistently in both checked and unchecked contexts in C#, not causing overflows.
Overloading Capability: C# allows for the overloading of this operator, enabling customised behaviour for user-defined types.
Syntax and Compatibility: It is defined for integral types such as int, uint, long, and ulong.

Here are a couple of code snippets demonstrating the >>> operator in C#:

Example 1: Basic Unsigned Right-shift

// Example of unsigned right-shift on a positive number
int positiveNumber = 8; // Binary: 0000 1000
int shiftedPositive = positiveNumber >>> 2; // Shift right by 2 bits
Console.WriteLine(shiftedPositive); // Expected output: 2 (Binary: 0000 0010)

Example 2: Unsigned Right-shift on a Negative Number

// Example of unsigned right-shift on a negative number
int negativeNumber = -8; // Binary representation depends on system architecture (e.g., two's complement)
int shiftedNegative = negativeNumber >>> 2; // Shift right by 2 bits
Console.WriteLine(shiftedNegative); // The output would be different from a signed right-shift

In both examples, the >>> operator shifts the number to the right by 2 bits, filling the leftmost bits with zeros. The behaviour is consistent for positive and negative numbers, making it a predictable and reliable operation in various programming contexts.

Your summary of the generic attributes feature in C# 11 is accurate but could benefit from additional detail and code examples. Here's a revised version with added explanations and code snippets:

Generic Attributes in C# 11

C# 11 introduces the ability to create custom generic attributes, marking a significant advancement in attribute-based programming. This feature allows developers to define their attribute types with generic parameters. These custom attributes can be applied to various program elements such as classes, methods, properties, and fields. Using generic attributes can add metadata, influence behaviour, or impose constraints on the annotated elements, enhancing code expressiveness, flexibility, and reusability. This feature is handy for developing more versatile and robust frameworks, libraries, and tools that accommodate a broader array of data types and structures. The introduction of generic attributes in C# 11 is a notable improvement that aids in increasing productivity, elevating code quality, and simplifying maintenance in software development.

Code Example

Consider a scenario where you want to apply an attribute to a class containing information about a database table. In previous versions of C#, you had to create a separate attribute class for each data type. With C# 11, you can create a single, generic attribute class that can be applied to any data type.

Here's a basic example:

In this example, the TableAttribute<T> is a generic attribute that takes a type parameter T. It can annotate different classes with specific table names, such as StringData and IntData. This approach reduces the need for multiple attribute definitions for different data types, streamlining the codebase and enhancing maintainability.

List and Slice Patterns in Pattern Matching

The latest updates have brought exciting new features to our pattern-matching capabilities. In particular, list and slice patterns have been introduced, which offer more advanced and expressive ways to manipulate and handle collections. These new patterns enable you to match against a range of values in a list or slice, giving you greater control and flexibility when working with complex data structures. Whether dealing with large datasets or complex algorithms, these enhanced pattern-matching capabilities will provide the tools you need to do the job quickly and efficiently.

public void ProcessList(IEnumerable<int> numbers)
{
    switch (numbers)
    {
        case ():
            Console.WriteLine("The list is empty.");
            break;
        case (int first, .., int last):
            Console.WriteLine($"First: {first}, Last: {last}");
            break;
        case (.., var middle, ..):
            Console.WriteLine($"Middle element(s): {string.Join(", ", middle)}");
            break;
        default:
            Console.WriteLine("Unknown pattern.");
            break;
    }
}

Raw String Literals

In C# 11, raw string literals allow developers to include special characters, such as newlines and quotes, in a string without having to use escape sequences. Raw string literals make it much simpler and more convenient to format strings that contain complex content, such as multi-line text or code snippets. With raw string literals, developers can write cleaner and more readable code without worrying about escaping special characters or breaking up strings into multiple lines. This excellent addition to the C# language should simplify developers' lives.

string multiLineString = """
    This is a multi-line string
    using raw string literals in C# 11.
    Special characters like "quotes" and \backslashes\
    can be included without escaping.
    Newlines are also preserved as they are.
""";

Newlines in String Interpolations

This new feature allows for multi-line string interpolations, greatly enhancing the readability and ease of writing longer expressions like pattern matching and LINQ queries. It allows for more organised and structured code, making it easier to keep track of complex statements and reducing the likelihood of errors or bugs. Overall, this feature is a valuable addition to the C# language that can significantly improve the efficiency and effectiveness of coding.

string name = "John";
int age = 30;
string occupation = "Developer";

string userProfile = $@"
    Name: {name}
    Age: {age}
    Occupation: {occupation}
";
Console.WriteLine(userProfile);

List Patterns

List patterns provide: A way to match sequences like arrays or lists based on their elements. Enabling you to perform sequence matching in a more granular way. Considering various criteria such as constant values. Data types. Properties. Relational patterns. By leveraging list patterns, you can write more robust and efficient code that can easily handle complex data structures. Whether you're working with simple arrays or complicated nested lists, list patterns offer a powerful tool for pattern matching that can help you streamline your code and improve its readability.

Improved Method Group Conversion to Delegate

C# 11 introduces an improved mechanism for delegate object reuse. When a delegate object is created from a method group conversion, the compiler can now cache and reuse the delegate object. This optimisation leads to better performance and improved efficiency of delegate object reuse. Reusing existing delegate objects instead of creating new ones reduces the overhead of allocating and deallocating memory, resulting in faster and more efficient execution. This feature is handy when dealing with large numbers of delegate objects, such as in event-driven programming, where many event handlers may be registered and unregistered during the application's lifetime.

Improved Method Group Conversion to Delegate

Example Code Snippet:

// Traditional delegate creation
EventHandler traditionalDelegate = new EventHandler(MyEventHandler);

// Improved method group conversion in C# 11
EventHandler cachedDelegate = MyEventHandler;

// Usage in an event-driven scenario
myEvent += cachedDelegate;
myEvent -= cachedDelegate;

In this example, cachedDelegate utilizes the improved method group conversion feature of C# 11, where the compiler optimizes the delegate object's reuse.

Other Notable Features

One of the notable updates includes expanded scope for nameof function, which allows developers to retrieve the name of an identifier as a string literal, making debugging and error handling more robust and convenient.

Moreover, the new version introduces required members for object initialisers, ensuring that all necessary properties and values are specified during the initialisation process, reducing the possibility of runtime errors and improving the readability of the code.

Finally, the auto-default structs feature automatically initialises all struct fields to their default values, eliminating manual initialisation and reducing the likelihood of bugs related to uninitialised or partially initialised variables. These features contribute to more expressive and safer coding practices, making the development process more efficient and reliable.

Exploring C# Version 12

Primary Constructors

In C# 12, primary constructors have been introduced to simplify the initialisation of properties in classes and structs. With this feature, you can now declare constructors within the class or struct declaration itself, eliminating the need for separate constructor definitions. This streamlines the syntax and makes the code more concise and readable. The primary constructor can initialise the properties of the class or struct using the same syntax as property declarations. It also provides an easy way to validate the values of the properties during initialisation. This feature is handy when working with immutable types that require all properties to be initialised in the constructor. Introducing primary constructors in C# 12 significantly enhances the language's expressiveness and reduces boilerplate code.

public class Employee(string firstName, string lastName, int age)
{
    public string FirstName { get; } = firstName;
    public string LastName { get; } = lastName;
    public int Age { get; } = age;
    
    public override string ToString() => $"{FirstName} {LastName}, Age: {Age}";
}

The provided C# code snippet above shows the new primary constructor feature in C# 12, exemplified through an Employee class. This class is declared with a primary constructor that includes three parameters: firstName, lastName, and age. The primary constructor is integrated directly into the class declaration, streamlining the initialization process. Within the class are three read-only properties: FirstName, LastName, and Age, each initialised using the corresponding parameters from the constructor. This approach not only simplifies the syntax but also enhances readability and conciseness. The properties are immutable, aligning with scenarios where immutable types are essential, such as in multi-threaded environments where data consistency is crucial. The snippet concludes with an overridden ToString method, providing a formatted string representation of the Employee object, showcasing the ease of using and displaying the initialised properties.

Collection Expressions

C# 12 is the latest C# programming language version, introducing a new collection expression feature. This feature enables programmers to create arrays, lists and spans using a unified syntax, simplifying code and enhancing its readability. With collection expressions, developers can directly initialise collections with their elements, making writing and maintaining code easier. This new feature also introduces a range of new capabilities, such as support for nested collections, filtering, and ordering, which can significantly improve the performance and efficiency of code. Overall, collection expressions are a valuable addition to the C# language, providing developers with a more intuitive and flexible way to work with collections.

Collection Expressions

// Example of Collection Expressions in C# 12
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var matrix = new int(,) { { 1, 2 }, { 3, 4 } };
var filteredNumbers = new List<int> { 1, 2, 3, 4, 5 }.Where(n => n > 2);
var orderedNumbers = new List<int> { 5, 3, 1, 4, 2 }.OrderBy(n => n);

Using a straightforward syntax, the first line in the example above initialises a List<int> named numbers with elements 1 through 5. The second line demonstrates the creation of a two-dimensional array matrix with predefined values. The third line, filteredNumbers, shows how collection expressions can seamlessly integrate with LINQ methods, in this case using .Where to filter elements greater than 2. Lastly, orderedNumbers illustrates the use of .OrderBy to sort elements in a list, highlighting the flexibility and efficiency of collection expressions in handling complex operations with minimal and readable code.

Inline Arrays

C# 12 introduces inline arrays, a new type of array in the language. These arrays are struct-based and have a fixed length, which makes them ideal for memory management in specific scenarios. Inline arrays are especially useful when working with memory buffers, as they help developers work with large amounts of data safely and efficiently. They also enable developers to work with arrays of structures, allowing for better performance and memory usage. Overall, inline arrays are a powerful addition to the C# language that can significantly improve the efficiency and safety of memory management in certain use cases.

// Example of using an inline array in C# 12
public struct InlineArrayExample
{
    public InlineArray<int, 10> Numbers; // Inline array of int with a length of 10

    public void PopulateNumbers()
    {
        for (int i = 0; i < Numbers.Length; i++)
        {
            Numbers(i) = i;
        }
    }
}

This snippet provides an example of how an inline array can be declared and used in C#. The InlineArray<int, 10> syntax declares an inline array of integers with a fixed length of 10. The PopulateNumbers method demonstrates how to populate this array.

Ref Readonly Parameters

C# 12 introduces a new feature that builds on the existing in parameter feature, called ref readonly parameters. This feature allows for passing arguments by reference but in a read-only manner. It is handy for methods that require the memory location of an argument without modifying it, thereby improving performance and ensuring immutability. The ref readonly parameters allow passing large value types to a method without incurring the cost of copying the entire value type. The feature enables the technique to read the value type without modifying it, guaranteeing the immutability of the passed-in argument. This enhancement also ensures that the method can call concurrently from multiple threads, as there is no risk of race conditions arising from modifying shared memory locations.

public double CalculateArea(ref readonly Rectangle rectangle)
{
    return rectangle.Width * rectangle.Height;
}

In this example, the ref readonly parameter ensures that the original rectangle object remains unmodified, allowing efficient access to its properties for area calculation while maintaining its immutability.

Default Lambda Parameters

The latest version of C# (version 12) has introduced a new feature that allows developers to define default values for parameters in lambda expressions. This feature has brought more flexibility and expressiveness to lambda expressions by enabling developers to set parameter default values. This means that if a parameter is not explicitly passed while defining a lambda function, it will take on the value specified as the default value. This feature can be handy when developing complex applications where you need to handle different scenarios efficiently. By using default values for parameters in lambda expressions, developers can save time and reduce the code they need to write.

var IncrementBy = (int source, int increment = 1) => source + increment;

Console.WriteLine(IncrementBy(5)); // Outputs: 6
Console.WriteLine(IncrementBy(5, 2)); // Outputs: 7

This example demonstrates how a lambda expression with a default parameter can be used in different scenarios by utilizing the default value or specifying a different value.

Alias Any Type

In the latest version of C# 12, developers can take advantage of the extended using alias directive, which now allows the creation of semantic aliases for any type. Developers can use these aliases to enhance code readability and organisation by providing descriptive and meaningful names to frequently used types in their codebase. This feature provides a powerful tool for developers to create cleaner and more maintainable code, as it allows them to avoid using long and complicated type names and instead use more straightforward and more expressive aliases. Overall, this new capability in C# 12 is a significant improvement for developers, as it enables them to write more efficient and elegant code, which is easier to understand and maintain over time.

The extended using alias directive in C# 12 allows developers to create aliases for any type, not just named types like classes, structs, interfaces, delegates, or enums. This enhancement enables using aliases for tuple types, pointer types, array types, and other previously unsupported types.

For instance, you can now define an alias for a tuple type as follows:

using Point = (int x, int y);

This code creates an alias named Point for the tuple (int x, int y). Once defined, Point can be used as a shorthand in your code. For example, you can declare a Point variable and use it like this:

Point p = (1, 2);
Console.WriteLine(p.x); // Outputs 1
Console.WriteLine(p.y); // Outputs 2

This feature enhances code readability and maintainability, especially when dealing with complex types. It allows for concise, clear, and self-documenting code by enabling the creation of meaningful and descriptive aliases.

It's important to note that there are specific rules and limitations to using aliases. For example, since aliases are defined at the namespace or compilation unit level, you cannot create an alias for a type at the local variable level or inside a class or struct. Moreover, each alias must be unique within its scope, and aliases cannot be used as type arguments for other generic types.

Experimental Features

The latest version of C#, C# 12, has introduced some exciting new features that developers should know about. One of these features is the ExperimentalAttribute, which allows developers to mark specific features as experimental, providing a way to test and gather feedback before making them a permanent part of the language. Another significant addition to C# 12 is interceptors for method call redirection, which enables developers to optimise performance. Intercepting method calls allow developers to insert additional logic before, after, or around a method call, which can be helpful for caching, logging, or adding security checks. Overall, these additions to C# 12 give developers more control over their code and the ability to fine-tune performance more efficiently. using System.Diagnostics.CodeAnalysis;

namespace ExperimentalFeatures
{
    public class ExperimentalClass
    {
        (Experimental("EX001"))
        public void ExperimentalMethod()
        {
            // Method implementation
        }
    }
}

In this snippet, the ExperimentalMethod is marked as experimental with the ExperimentalAttribute. The "EX001" is a diagnostic ID unique to this method. When this method is used elsewhere in the code, it triggers a compiler warning indicating its experimental nature. Developers can suppress this warning if they choose to proceed with using the experimental feature.

The ExperimentalAttribute also allows for a UrlFormat property, which can be used to provide a URL to documentation or further information about the experimental feature. This URL can be a direct link or a format string that includes the diagnostic ID.

Interpolated Strings and Lambda Expression Improvements

In C# 12, you can create more complex expressions within lambda functions and transform them into expression trees. This feature is beneficial for those who work on complex projects that require a lot of data processing, as it allows for more efficient and streamlined code.

int x = 10;
string message = $"The value of x is {x}, and its square is {x*x}.";

This snippet demonstrates how to embed expressions directly within a string, resulting in a more concise and readable format.

var greetUser = (string name = "User") => $"Hello, {name}!";
Console.WriteLine(greetUser()); // Output: Hello, User!
Console.WriteLine(greetUser("Peter")); // Output: Hello, Peter!

Here, the lambda expression greetUser has a default parameter. It uses the default value "User" if no argument is passed. This feature enhances the flexibility and resilience of lambda expressions.

Improved Switch Expressions

C# 12 introduces a new and improved pattern-matching syntax for switch expressions. This new syntax not only simplifies the process of writing code but also increases the expressiveness of the code. With this new feature, programmers can write more concise and readable code that is easier to maintain and update.

Here is a more detailed code snippet in markdown, showcasing the improved switch expressions in C# 12 through a weather scenario:

public class WeatherForecast
{
    public enum WeatherType { Sunny, Rainy, Snowy, Cloudy }

    public string GetClothingRecommendation(WeatherType weather) => weather switch
    {
        WeatherType.Sunny => "Wear sunglasses and a hat",
        WeatherType.Rainy => "Don't forget an umbrella",
        WeatherType.Snowy => "Warm coat and gloves are a must",
        WeatherType.Cloudy => "A light jacket would be ideal",
        _ => "No recommendation available"
    };
}

// Usage
var forecast = new WeatherForecast();
var recommendation = forecast.GetClothingRecommendation(WeatherType.Snowy);

Async Streams

C# 12 introduces a new async stream feature to make asynchronous programming more powerful and efficient. This feature enables developers to iterate through asynchronous data sources more streamlined and conveniently, improving the language's capabilities in handling asynchronous operations. With async streams, developers can write cleaner, more concise code that can easily handle large amounts of asynchronous data. This feature is handy in scenarios where data is being pulled from sources such as databases, web APIs, or streaming services, where fetching large amounts of data asynchronously is a common requirement.

Consider a scenario where you need to consume data from a third-party API, which provides a substantial amount of data. Instead of loading the entire dataset into memory, you can process it piece by piece using Async Streams. Here's a simplified example:

async IAsyncEnumerable<MyDataObject> GetDataAsync()
{
    using var client = new HttpClient();
    using var response = await client.GetAsync("https://myapi.com/data");

    response.EnsureSuccessStatusCode();

    var stream = await response.Content.ReadAsStreamAsync();
    using var reader = new StreamReader(stream);
    using var jsonReader = new JsonTextReader(reader);

    while (await jsonReader.ReadAsync())
    {
        if (jsonReader.TokenType == JsonToken.StartObject)
        {
            var obj = await JsonSerializer.DeserializeAsync<MyDataObject>(jsonReader);
            yield return obj;
        }
    }
}

// Usage
await foreach (var obj in GetDataAsync())
{
    // Process each data object
}

This snippet demonstrates how to define a data source that provides data asynchronously. In this example, HttpClient is used to make an asynchronous HTTP request to the API. The response stream is then read, and each JSON object is deserialized into an instance of MyDataObject. Finally, the yield return statement returns each object as it's produced. The await foreach loop is then used to asynchronously consume the data.

Conclusion

Both C# 11 and 12 have introduced many improvements that significantly enhance the language's functionality, making it an even more powerful tool for developers. These advancements include new features, improved code readability, enhanced safety, and increased performance. Developers who stay up-to-date with these developments can optimise their coding efficiency and fully leverage the capabilities of the language. Some of the latest features include support for records, improved pattern matching, enhanced nullability, and more. These features offer many benefits for developers, including more manageable and efficient coding, better performance, and increased safety. Developers must remain updated with these advancements to stay competitive and maximise C#'s capabilities.

Additional Resources

For more in-depth information and examples, visit the official Microsoft documentation on

Every .Net Developer Must Learn These Latest Features in C# Version 11 and 12

TL;DR

Updated features in C# version 11 & 12

C# 11 Features:

C# 12 Features:

Introduction

What's New in C# Version 11

Static Virtual Members in Interfaces for Generic Math Support

Numeric `IntPtr` and `UIntPtr`

Unsigned Right-shift Operator in C#

Example 1: Basic Unsigned Right-shift

Example 2: Unsigned Right-shift on a Negative Number

Generic Attributes in C# 11

Code Example

List and Slice Patterns in Pattern Matching

Raw String Literals

Newlines in String Interpolations

List Patterns

Improved Method Group Conversion to Delegate

Improved Method Group Conversion to Delegate

Example Code Snippet:

Other Notable Features

Exploring C# Version 12

Primary Constructors

Collection Expressions

Collection Expressions

Inline Arrays

Ref Readonly Parameters

Default Lambda Parameters

Alias Any Type

Experimental Features

Interpolated Strings and Lambda Expression Improvements

Improved Switch Expressions

Async Streams

Conclusion

Additional Resources