{"id":46459,"date":"2023-07-11T10:11:00","date_gmt":"2023-07-11T17:11:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=46459"},"modified":"2023-07-18T11:07:54","modified_gmt":"2023-07-18T18:07:54","slug":"new-csharp-12-preview-features","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/new-csharp-12-preview-features\/","title":{"rendered":"New C# 12 preview features"},"content":{"rendered":"

Visual Studio 17.7 Preview 3 and .NET 8 Preview 6 continue the evolution of C# 12. This preview includes features designed to lay the groundwork for future performance enhancements. Easy access to inline arrays will allow libraries to use them in more places without effort on your part. This preview debuts an experimental feature called interceptors<\/em> that allow generators to reroute code, such as to provide context specific optimization. Finally, nameof<\/code> is enhanced to work in more places.<\/p>\n

You can get C# 12 by installing the latest Visual Studio preview<\/a> or the latest version of the .NET SDK<\/a>. To check out C# 12 features, you’ll need to set the language version of your project to preview:<\/p>\n

<PropertyGroup>\r\n   <LangVersion>preview<\/LangVersion>\r\n<\/PropertyGroup><\/code><\/pre>\n
Since they are experimental, interceptors require an additional flag<\/a> in your project file.<\/p>\n
nameof<\/code> accessing instance members<\/h2>\n
The nameof<\/code> keyword now works with member names, including initializers, on static members, and in attributes:<\/p>\n
internal class NameOf\r\n{\r\n    public string S { get; } = \"\";\r\n    public static int StaticField;\r\n    public string NameOfLength { get; } = nameof(S.Length);\r\n    public static void NameOfExamples()\r\n    {\r\n        Console.WriteLine(nameof(S.Length));\r\n        Console.WriteLine(nameof(StaticField.MinValue));\r\n    }\r\n    [Description($\"String {nameof(S.Length)}\")]\r\n    public int StringLength(string s)\r\n    { return s.Length; }\r\n}<\/code><\/pre>\n
You can learn more at What’s new in C# 12<\/a>.<\/p>\n
Inline arrays<\/h2>\n
The InlineArrayAttribute<\/a> was introduced to the runtime in a previous .NET 8 preview. This is an advanced feature that will be used primarily by the compiler, .NET libraries and some other libraries. The attribute identifies a type that can be treated as a contiguous sequence of primitives for efficient, type-safe, overrun-safe indexable\/sliceable inline data. The .NET libraries improve performance of your application and tools using inline arrays.<\/p>\n
The compiler creates different IL to access inline arrays. This results in a few restrictions, such as list patterns not being supported. In most cases, you access inline arrays the same as other arrays. The different IL creates performance gains without changing your code:<\/p>\n
private static void InlineArrayAccess(Buffer10<int> inlineArray)\r\n{\r\n    for (int i = 0; i < 10; i++)\r\n    {\r\n        inlineArray[i] = i * i;\r\n    }\r\n    foreach (int i in inlineArray)\r\n    {\r\n        Console.WriteLine(i);\r\n    }\r\n}<\/code><\/pre>\n
Most folks will consume inline arrays, rather than create them. But, it’s nice to understand how things work. Inline arrays are fast because they rely on an exact layout of a specified length. An inline array is a type with a single field and marked with the InlineArrayAttribute<\/code> that specifies the length of the array. In the type used in the previous example, the runtime creates storage for exactly ten elements in Buffer10<T><\/code> due to the attribute parameter:<\/p>\n
[System.Runtime.CompilerServices.InlineArray(10)]\r\npublic struct Buffer10<T>\r\n{\r\n    private T _element0;\r\n}<\/code><\/pre>\n
You can learn more at What’s new in C# 12<\/a>.<\/p>\n
Interceptors<\/h2>\n
This preview introduces an experimental feature called interceptors<\/em>. It\u2019s intended for advanced scenarios, particularly allowing better ahead of time compilation (AOT). As an experimental part of .NET 8, it may be changed or removed in a future version. Thus, it should not be used in production.<\/p>\n
Interceptors allow specific method calls to be rerouted to different code. Attributes specify the actual source code location so interceptors are generally appropriate only for source generators. You can read the interceptors proposal<\/a> to learn more about how interceptors work.<\/p>\n
Because interceptors are an experimental feature, you’ll need to explicitly enable them in your project file:<\/p>\n
<PropertyGroup>\r\n   <Features>InterceptorsPreview<\/Features>\r\n<\/PropertyGroup><\/code><\/pre>\n
Interceptors enable exciting code patterns. A few examples are:<\/p>\n