{"id":60647,"date":"2026-08-24T10:00:00","date_gmt":"2026-08-24T17:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=60647"},"modified":"2026-08-24T10:00:00","modified_gmt":"2026-08-24T17:00:00","slug":"explore-csharp-15","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/explore-csharp-15\/","title":{"rendered":"Explore new features available in C# 15 preview"},"content":{"rendered":"

C# 15 will ship with .NET 11 in November. All the new features are available in .NET 11 preview 7 for you to try now. C# 15 adds union types<\/em>, closed hierarchies<\/em>, the first preview of an updated unsafe<\/code> model, collection expression arguments, extension indexers, and labeled break<\/code> and continue<\/code>. For more details on each of these features, see What’s new in C# 15<\/a> and the articles linked from that page.<\/p>\n

Union types<\/h2>\n

A union type<\/em> lets you say, in the type system, exactly which types a value may hold. With object<\/code>, a marker interface, or an abstract base class, the runtime type can still be anything derived from object<\/code> or anything that implements or derives from the shared type. A union constrains the value to one of the specified case types<\/em>. The case types in a union aren’t necessarily related by inheritance. Use the closed hierarchies<\/a> feature to restrict the set of types related by inheritance.<\/p>\n

public record class Cat(string Name);\npublic record class Dog(string Name);\npublic record class Bird(string Name);\n\npublic union Pet(Cat, Dog, Bird);<\/code><\/pre>\n
A Pet<\/code> holds a Cat<\/code>, a Dog<\/code>, or a Bird<\/code>. Each case type converts implicitly to Pet<\/code>. Because the compiler knows the complete set, a switch<\/code> expression over a non-null Pet<\/code> is exhaustive without a discard or default arm:<\/p>\n
Pet pet = new Dog(\"Rex\");\n\nstring name = pet switch\n{\n    Dog d => d.Name,\n    Cat c => c.Name,\n    Bird b => b.Name,\n};<\/code><\/pre>\n
Union types are one expression of a broader design idea: make the allowed set of types explicit. Closed hierarchies<\/em>, covered next, and the planned closed enums<\/em> apply the same idea in other shapes.<\/p>\n
For more, read the C# 15 union types<\/a> post, try the Work with union types<\/a> tutorial, and see the union types<\/a> reference.<\/p>\n
Closed hierarchies<\/h2>\n
Closed hierarchies<\/em> apply the same idea to class hierarchies you design. The closed<\/code> modifier on a class makes it implicitly abstract<\/code>, and restricts its direct derived types to the declaring assembly. You declare which subtypes are allowed instead of leaving derivation open-ended. For example, you can model the states of a background job as records that derive from a closed base:<\/p>\n
public closed record class JobStatus;\npublic record class Queued : JobStatus;\npublic record class Running(int PercentComplete) : JobStatus;\npublic record class Completed(TimeSpan Elapsed) : JobStatus;\npublic record class Failed(string Error) : JobStatus;<\/code><\/pre>\n
Closed hierarchies, union types, and the planned closed enums<\/em> all express the allowed set of shapes directly in the type system. For rules, including how closed<\/code> composes with inheritance, see the closed modifier<\/a> and closed hierarchy patterns<\/a> references.<\/p>\n
Memory-safety redesign (preview)<\/h2>\n
C# 15 starts a redesign of unsafe<\/code>: from a syntax marker\u2014”there are pointers here”\u2014to a contract the compiler can’t verify and a developer upholds. This is a preview<\/strong> feature in .NET 11 and C# 15. The model and syntax might change for .NET 12 and C# 16. The current preview includes two language changes you can try. You need to opt in explicitly: add <Features>$(Features);updated-memory-safety-rules<\/Features><\/code> and <LangVersion>preview<\/LangVersion><\/code> to your project file.<\/p>\n
In the new model, pointer types no longer need an unsafe<\/code> context. You can declare a pointer type, take an address with &<\/code>, use the fixed<\/code> statement, convert a stackalloc<\/code> to a pointer, and use sizeof<\/code> on an unmanaged type in a safe context.<\/p>\n
Operations that dereference pointers still require unsafe<\/code>: pointer indirection (*p<\/code>), member access through a pointer (p->m<\/code>), element access through a pointer (p[i]<\/code>), fixed-size-buffer element access, and function-pointer invocation.<\/p>\n
Finally, when a member adds the unsafe<\/code> modifier to its signature, that member can be called only in an unsafe<\/code> context. This is a breaking change from the current semantics of unsafe<\/code> on a member. The member is declaring that its callers must ensure that the contract is followed, or propagate the unsafety by also including the unsafe<\/code> modifier in its declaration.<\/p>\n
Read Improving C# memory safety<\/a> for the full model, and see the unsafe code<\/a> reference for the rules implemented in preview in C# 15.<\/p>\n
<\/i>Important<\/strong><\/p>This is a preview feature in .NET 11 and C# 15. The design isn’t final and will continue to evolve before it ships in its final form. We want people to try the preview behavior and give us feedback in csharplang<\/a> so we can shape the final experience.<\/div><\/p>\n
Collection expression arguments<\/h2>\n
Collection expressions convert to many collection types, but until now you couldn’t pass arguments to the underlying constructor or Create<\/code> method. C# 15 adds a with(...)<\/code> element, written first, that forwards arguments to the constructor or factory method.<\/p>\n
This feature is necessary for the upcoming dictionary expressions<\/em> syntax. You will often specify the comparer for a dictionary. You can use the feature now for sequence containers:<\/p>\n
\/\/ Before\nList<string> names = new(capacity: values.Length * 2);\nnames.AddRange(values);\n\nvar set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { \"Hello\", \"HELLO\" };<\/code><\/pre>\n
\/\/ After (C# 15)\nList<string> names = [with(capacity: values.Length * 2), .. values];\n\nHashSet<string> set = [with(StringComparer.OrdinalIgnoreCase), \"Hello\", \"HELLO\"];<\/code><\/pre>\n
Learn more in collection expression arguments<\/a>.<\/p>\n
Extension indexers<\/h2>\n
C# 14 introduced extension members: properties and operators alongside methods. C# 15 adds extension indexers<\/em>, so you can index into a receiver as if the indexer were declared on its type. Indexers can’t be static, so the extension container must include a named receiver.<\/p>\n
\/\/ Before: a helper method\npublic static class SequenceExtensions\n{\n    public static int ElementAtIndex(this IEnumerable<int> sequence, int index)\n        => sequence.ElementAt(index);\n}\n\nint third = numbers.ElementAtIndex(2);<\/code><\/pre>\n
\/\/ After (C# 15): an extension indexer\npublic static class SequenceExtensions\n{\n    extension(IEnumerable<int> sequence)\n    {\n        public int this[int index] => sequence.ElementAt(index);\n    }\n}\n\nint third = numbers[2];<\/code><\/pre>\n
Learn more in the extension indexers<\/a> reference.<\/p>\n
Labeled break and continue<\/h2>\n
Breaking out of a nested loop usually means a flag, a goto<\/code>, or an extracted method. With C# 15, you can label a loop and target it directly with break<\/code> or continue<\/code>.<\/p>\n
\/\/ Before: a flag to unwind the outer loop\nbool found = false;\nforeach (Warehouse warehouse in warehouses)\n{\n    foreach (Bin bin in warehouse.Bins)\n    {\n        if (bin.Sku == requestedSku && bin.Quantity > 0)\n        {\n            reserved = Reserve(bin);\n            found = true;\n            break;\n        }\n    }\n    if (found)\n        break;\n}<\/code><\/pre>\n
\/\/ After (C# 15): label the loop and break it directly\nscan: foreach (Warehouse warehouse in warehouses)\n{\n    foreach (Bin bin in warehouse.Bins)\n    {\n        if (bin.Sku == requestedSku && bin.Quantity > 0)\n        {\n            reserved = Reserve(bin);\n            break scan;\n        }\n    }\n}<\/code><\/pre>\n
The intent is in the code, with no flag to track. See the jump statements<\/a> reference.<\/p>\n
Try the preview<\/h2>\n
Download .NET 11<\/a> and try C# 15 on your apps. Read What’s new in C# 15<\/a> for the complete reference and participate in the ongoing discussions in csharplang<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
C# 15 ships with .NET 11. It adds union types, closed hierarchies, a preview of the updated unsafe model, and a few smaller changes that remove everyday ceremony.<\/p>\n","protected":false},"author":56654,"featured_media":60648,"comment_status":"open","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[685,756],"tags":[7893,8201,46,8200,63],"class_list":["post-60647","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet","category-csharp","tag-dotnet-11","tag-net-11-preview-7","tag-c","tag-c-15","tag-dotnet"],"acf":[],"blog_post_summary":"
C# 15 ships with .NET 11. It adds union types, closed hierarchies, a preview of the updated unsafe model, and a few smaller changes that remove everyday ceremony.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/60647","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/56654"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=60647"}],"version-history":[{"count":1,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/60647\/revisions"}],"predecessor-version":[{"id":60649,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/60647\/revisions\/60649"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/60648"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=60647"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=60647"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=60647"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}