16th Aug 2022

Underlining the Newest Features of C# 11


Written By, Jeet Limbani


Hello Geeks,

We all are well aware the prominent benefits of C#11, However let’s quickly recap the new features and their advantages from the user’s perspective. Every upgrade unveils new features in .NET6 and ‘Visual Studio 2022’ that improves code’s simplicity, makes it faster, and makes it more expressive. Here are some of the characteristics that aid in the understanding of essential ideas as well as improve our workflow.

Let’s look at a few samples to acquire a better understanding of some characteristics.


Every new release adds to the list of features available in previous versions of C#. Every new feature efficiently scales the level of code purity and simplicity to the project. As a result, C#10 support is included in.NET 6.

Here are the add on in C#10 features which are provided by Microsoft.

  • Generic attributes.
  • Static abstract members in interfaces.
  • Newlines in string interpolation expressions.
  • Simplified parameter null checks.

Generic attributes

In C# 11, developers now have the ability to create their own new Generic attributes. We had to create an attribute with a type as its constructor parameter.


  • Before C# 11
  • In C# 11 Feature

The type arguments must be compliant with the same constraints as the type of operator. There are no types that require metadata annotations. The following types, for example, are not permitted as type parameters:

  • Dynamic
  • nint, nunit
  • string?(or any nullable reference type)
  • (int x, int y ) (or any other tuple types using C# tuple syntax).

Metadata does not directly reflect these categories. Annotations that describe the type are included. You may always use the underlying type instead:

  • Object for dynamic
  • IntPtr instead of nint or unint.
  • String instead of string?
  • ValueTuple<int, int> instead of ( int x, int y).

In practice the API does not work efficiently as it may be introduced to the path it has not been technically come across before so eliminating these limitations one can remove these limitations of pattern and by doing so increase the efficiency of the code.

Static abstract members in interfaces.

This is a runtime preview feature in the interfaces. In our project profile we have to add <EnablePreviewFeatures> True </EnablePreviewFeatures>.


Implementing a dedicated version of static accessor is made possible by implementing static abstract members in interfaces. Frameworks that act on reflection can make great use of this little update as it will make it more accessible and increase the performance during the runtime.

Newlines in string interpolation

String interpolation content can now span multiple lines inside the {and} characters. C# is used to parse the text between the {and} markers. It’s fine to use any lawful C#, including newlines. This feature makes string interpolations using lengthy C# expressions, such as pattern matching switch expressions or LINQ queries, are easier to read.

Simplified parameter null checks

Null validation parameter syntax is provided by the ‘!!’ operator. When you add ‘!!’ to a parameter declaration, the compiler is told to apply a runtime check for that parameter. Consider the following scenario:


Hire Our Worthy Web Developers

Explore the Benefits of Our Web
Development Services

Get Expert Assistance


I hope this blog has helped you in comprehending and gaining a thorough knowledge of the features of C#11 using examples, as well as coding expressions.

Written By,

.NET Developer at Yudiz Solutions Ltd