{"id":43180,"date":"2022-11-08T08:58:30","date_gmt":"2022-11-08T15:58:30","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=43180"},"modified":"2022-11-08T09:09:33","modified_gmt":"2022-11-08T16:09:33","slug":"welcome-to-csharp-11","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/welcome-to-csharp-11\/","title":{"rendered":"Welcome to C# 11"},"content":{"rendered":"

I am excited to announce that C# 11 is out! As always, C# opens some entirely new fronts, even while advancing several themes that have been in motion over past releases. There are many features and many details, which are beautifully covered under What’s new in C# 11<\/a> on our docs pages. What follows here is an appetizer of some of the highlights – small and big.<\/p>\n

Before we dive in, let me just say how happy I am about the way this version of C# came into being! With every release there’s more and more participation from the community, contributing everything from suggestions, insights and bug reports all the way up to entire feature implementations. This is really everyone’s C#. Thank you!<\/strong><\/p>\n

UTF-8 string literals<\/h2>\n

By default C# strings are hardcoded to UTF-16, whereas the prevailing string encoding on the internet is UTF-8. To minimize the hassle and performance overhead of converting, you can now simply append a u8<\/code> suffix to your string literals to get them in UTF-8 right away:<\/p>\n

var u8 = \"This is a UTF-8 string!\"u8;<\/code><\/pre>\n
UTF-8 string literals simply give you back a chunk of bytes – in the form of a ReadOnlySpan<byte><\/code>. For the scenarios where it’s important to have a UTF-8 encoding this is probably more useful than some dedicated new UTF-8 string type.<\/p>\n
Read the docs on UTF-8 string literals<\/a>.<\/p>\n
Raw string literals<\/h2>\n
A lot of what gets put in string literals is “code” of some sort – not just program text, but also JSON and XML data, HTML, regular expressions, SQL queries, etc. It’s really unhelpful when many of the special characters that show up in such text have special meaning in C# string literals! Noteworthy examples include \\<\/code> and \"<\/code>, joined in interpolated strings by {<\/code> and }<\/code>. Having to escape all of those is a real bummer, and an ongoing source of pain an bugs.<\/p>\n
Why not have a form of string literals that has no escape characters at all? That’s what raw string literals are. Everything is content!<\/p>\n
A raw string literal is delimited by at least three double-quotes:<\/p>\n
var raw1 = \"\"\"This\\is\\all \"content\"!\"\"\";\r\nConsole.WriteLine(raw1);<\/code><\/pre>\n
This prints:<\/p>\n
This\\is\\all \"content\"!<\/code><\/pre>\n
If you need three or more \"<\/code>s to be part of your content, you just use more<\/em> \"<\/code>s on the outside. The beginning and end just have to match:<\/p>\n
var raw2 = \"\"\"\"\"I can do \", \"\", \"\"\" or even \"\"\"\" double quotes!\"\"\"\"\";<\/code><\/pre>\n
This makes it really easy to paste in, maintain and read at a glance what the literal contains.<\/p>\n
Multi-line raw string literals can also truncate leading white space: The position of the end quote determines where white space starts to be included in the output:<\/p>\n
var raw3 = \"\"\"\r\n    <element attr=\"content\">\r\n      <body>\r\n        This line is indented by 4 spaces.\r\n      <\/body>\r\n    <\/element>\r\n    \"\"\";\r\n\/\/  ^white space left of here is removed<\/code><\/pre>\n
Since there are four spaces to the left of the end quote, four spaces will be removed from the beginning of every line of content, yielding this output:<\/p>\n
<element attr=\"content\">\r\n  <body>\r\n    This line is indented by 4 spaces.\r\n  <\/body>\r\n<\/element><\/code><\/pre>\n
There’s much more to raw string literals than this – for instance they support interpolation! Read more about raw string literals<\/a> in the docs. <\/p>\n
Abstracting over static members<\/h2>\n
How do you abstract over operations that are inherently static – such as operators? The traditional answer is “poorly”. In C# 11 we released support for static virtual members in interfaces, which was in preview in C# 10. With this you can now define a very simple mathematical interface:<\/p>\n
public interface IMonoid<TSelf> where TSelf : IMonoid<TSelf>\r\n{\r\n    public static abstract TSelf operator +(TSelf a, TSelf b);\r\n    public static abstract TSelf Zero { get; }\r\n}<\/code><\/pre>\n
Notice how the interface takes a type parameter for “itself”. That’s because static members don’t have a this<\/code>. <\/p>\n
Anyone can now implement this interface by providing implementations for the two static members, and passing themselves as the TSelf<\/code> type argument:<\/p>\n
public struct MyInt : IMonoid<MyInt>\r\n{\r\n    int value;\r\n    public MyInt(int i) => value = i;\r\n    public static MyInt operator +(MyInt a, MyInt b) => new MyInt(a.value + b.value);\r\n    public static MyInt Zero => new MyInt(0);\r\n}<\/code><\/pre>\n
Importantly, how do you consume<\/em> these abstract operations? How do you call virtual members when there is no instance to call them on? The answer is via generics. Here is what it looks like:<\/p>\n
T AddAll<T>(params T[] elements) where T : IMonoid<T>\r\n{\r\n    T result = T.Zero;\r\n    foreach (var element in elements)\r\n    {\r\n        result += element;\r\n    }\r\n    return result;\r\n}<\/code><\/pre>\n
The type parameter T<\/code> is constrained by the IMonoid<T><\/code> interface, and that allows the static virtual members of that interface – Zero<\/code> and +<\/code> – to be called on T<\/code> itself! <\/p>\n
Now we can call the generic method with some MyInt<\/code>s, and the correct implementations of +<\/code> and Zero<\/code> are passed in through the type argument:<\/p>\n
MyInt sum = AddAll<MyInt>(new MyInt(3), new MyInt(4), new MyInt(5));<\/code><\/pre>\n
In fact .NET 7 comes with a new namespace System.Numerics<\/code> chock-full of math interfaces, representing the different combinations of operators and other static members that you’d ever want to use: the “grown-up” versions of the little IMonoid<T><\/code> interface above. All the numeric types in .NET now implement these new interfaces – and you can add them for your own types too! So it’s now easy to write numeric algorithms once and for all – abstracted from the concrete types they work on – instead of having forests of overloads containing essentially the same code.<\/p>\n
It’s also worth noting that static virtual members are useful for other things than math. For instance you can abstract over factory methods for a hierarchy of types. But we’ve covered enough for now – you might want to check out these tutorials in docs on static abstract interface methods<\/a> and generic math<\/a>.<\/p>\n
Even if you do not create interfaces with static virtual members, you benefit from the improvements they make to .NET libraries, now and in the future.<\/p>\n
List patterns<\/h2>\n
Pattern matching is one of the ongoing stories in C# that we just keep filling out. Pattern matching was introduced in C# 7 and since then it has grown to become one of the most important and powerful control structures in the language.<\/p>\n
C# 11 adds list patterns<\/em> to the story. With list patterns you can apply patterns recursively to the individual elements of list-like input – or to a range of them. Let’s jump right in with the generic algorithm from above, rewritten as a recursive method using list patterns:<\/p>\n
T AddAll<T>(params T[] elements) where T : IMonoid<T> => \r\n    elements switch\r\n{\r\n    [] => T.Zero,\r\n    [var first, ..var rest] => first + AddAll<T>(rest),\r\n};<\/code><\/pre>\n
There’s a lot going on, but at the center is a switch expression with two cases. One case returns zero for an empty list []<\/code>, where Zero<\/code> is defined by the interface. The other case extracts the first element into first<\/code> with the var first<\/code> pattern, and the remainder is extracted into rest<\/code> using the ..<\/code> to slice out all the remaining elements into the var rest<\/code> pattern.<\/p>\n
Read more about list patterns<\/a> in the docs.<\/p>\n
Required members<\/h2>\n
Another ongoing theme that we’ve been working on for several releases is improving object creation and initialization.  C# 11 continues these improvements with required members<\/em>.<\/p>\n
When creating types that used object initializers, you used to be unable to specify that some properties must be initialized. Now, you can say that a property or field is required<\/code>. This means that it must<\/em> be initialized by an object initializer when an object of the type is created:<\/p>\n
public class Person\r\n{\r\n    public required string FirstName { get; init; }\r\n    public string? MiddleName { get; init; }\r\n    public required string LastName { get; init; }\r\n}<\/code><\/pre>\n
It is now an error to create a Person<\/code> without initializing both the required properties:<\/p>\n
var person = new Person { FirstName = \"Ada\" }; \/\/ Error: no LastName!<\/code><\/pre>\n
Check the docs for more on required members<\/a>.<\/p>\n
In closing …<\/h2>\n
C# 11 also includes many other features. I hope this appetizer excites you to explore What’s new in C# 11<\/a> and that you have as much fun coding with C# 11 as we had making it! We strive to make the language ever more useful, not only by adding more expressive power (as with static virtual members) but also by simplifying, streamlining and removing boilerplate (as with e.g. raw string literals and list patterns) and making it safer (as with required members).<\/p>\n","protected":false},"excerpt":{"rendered":"
C# 11 is here! Bringing with it some highly anticipated features including string literals, generic math, required members, and much more.<\/p>\n","protected":false},"author":1379,"featured_media":43242,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[685,756],"tags":[7611,7601],"class_list":["post-43180","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet","category-csharp","tag-dotnet-7","tag-c-11"],"acf":[],"blog_post_summary":"
C# 11 is here! Bringing with it some highly anticipated features including string literals, generic math, required members, and much more.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/43180","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\/1379"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=43180"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/43180\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/43242"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=43180"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=43180"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=43180"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}