Today, we are happy to announce the release of C# 10 as part of .NET 6 and Visual Studio 2022. In this post, we’re covering a lot of the new C# 10 features that make your code prettier, more expressive, and faster.<\/p>\n
Read the Visual Studio 2022 announcement<\/a> and the .NET 6 announcement<\/a> to find out more, including how to install.<\/p>\n If the keyword You can use any feature of You can put global usings in any For more information, see global using directives<\/a>.<\/p>\n The Implicit usings feature automatically adds common Implicit usings are enabled in the new .NET 6 templates. Read more about the changes to the .NET 6 templates at this blog post<\/a>.<\/p>\n The specific set of For more information, see this implicit usings<\/a> article.<\/p>\n Traditional Regardless of how they are defined, extra If you need to remove namespaces that have been included via implicit usings, you can specify them in your project file:<\/p>\n You can also add namespace that behave as though they were Many files contain code for a single namespace. Starting in C# 10, you can include a namespace as a statement, followed by a semi-colon and without the curly brackets:<\/p>\n This simplifies the code and removes a level of nesting. Only one file-scoped namespace declaration is allowed, and it must come before any types are declared.<\/p>\n For more information about file-scoped namespaces, see the namespace keyword<\/a> article.<\/p>\n We’ve made several improvements to both the types and the syntax surrounding lambdas<\/a>. We expect these to be widely useful, and one of the driving scenarios has been to make ASP.NET Minimal APIs<\/a> even more straightforward.<\/p>\n Lambda expressions now sometimes have a “natural” type. This means that the compiler can often infer the type of the lambda expression.<\/p>\n Up until now a lambda expression had to be converted to a delegate or an expression type. For most purposes you’d use one of the overloaded Starting with C# 10, however, if a lambda does not have such a “target type” we will try to compute one for you:<\/p>\n You can hover over Not all lambdas have natural types – some just don’t have enough type information. For instance, leaving off parameter types will leave the compiler unable to decide which delegate type to use:<\/p>\n The natural type of lambdas means that they can be assigned to a weaker type, such as When it comes to expression trees we do a combination of “target” and “natural” typing. If the target type is Method groups (that is, method names without argument lists) now also sometimes have a natural type. You have always been able to convert a method group to a compatible delegate type:<\/p>\n Now, if the method group has just one overload it will have a natural type:<\/p>\n In the previous examples, the return type of the lambda expression was obvious and was just being inferred. That isn’t always the case:<\/p>\n In C# 10, you can specify an explicit return type on a lambda expression, just like you do on a method or a local function. The return type goes right before the parameters. When you specify an explicit return type, the parameters must be parenthesized, so that it’s not too confusing to the compiler or other developers:<\/p>\n Starting in C# 10, you can put attributes on lambda expressions in the same way you do for methods and local functions. They go right where you expect; at the beginning. Once again, the lambda’s parameter list must be parenthesized when there are attributes:<\/p>\n Just like local functions, attributes can be applied to lambdas if they are valid on Lambdas are invoked differently than methods and local functions, and as a result attributes do not have any effect when the lambda is invoked. However, attributes on lambdas are still useful for code analysis, and they are also emitted on the methods that the compiler generates under the hood for lambdas, so they can be discovered via reflection.<\/p>\n C# 10 introduces features for structs that provide better parity between structs and classes. These new features include parameterless constructors, field initializers, record structs and Prior to C# 10, every struct had an implicit public parameterless constructor that set the struct’s fields to Starting in C# 10, you can include your own parameterless struct constructors. If you don\u2019t supply one, the implicit parameterless constructor will be supplied to set all fields to their default. Parameterless constructors you create in structs must be public and cannot be partial:<\/p>\n You can initialize fields in a parameterless constructor as above, or you can initialize them via field or property initializers:<\/p>\n Structs that are created via Starting in C# 10, records can now be defined with You can continue to define record classes with Structs already had value equality – when you compare them it is by value. Record structs add Record structs can be positional<\/em>, with a primary constructor implicitly declaring public members:<\/p>\n The parameters of the primary constructor become public auto-implemented properties of the record struct. Unlike record classes, the implicitly created properties are read\/write. This makes it easier to convert tuples to named types. Changing return types from a tuple like If you declare a property or field with the same name as a primary constructor parameter, no auto-property will be synthesized and yours will be used.<\/p>\n To create an immutable record struct, add Find out more about record structs in this article<\/a>.<\/p>\n Record classes have also been improved. Starting in C# 10 the Find out more about C# 10 supports This returns a new instance with the new value. You can update any number of values. Values you do not set will retain the same value as the initial instance.<\/p>\n Learn more about When we added interpolated strings to C#, we always felt that there was more that could be done with that syntax down the line, both for performance and expressiveness. With C# 10, that time has come!<\/p>\n Today the compiler turns interpolated strings into a call to In C# 10 we’ve added a library pattern that allows an API to “take over” the handling of an interpolated string argument expression. As an example, consider Up until now, this would call the In general, when you see parameter types of the form Sometimes you want to do the work of building the string only under certain conditions. An example is In most cases, the condition will be true and the second parameter is unused. However, all of the arguments are computed on every call, needlessly slowing down execution. Finally, here’s an example of actually changing the behavior of string interpolation in a given call: You can learn more about interpolated string handlers, in this article<\/a> and this tutorial<\/a> on creating a custom handler.<\/p>\n If all the holes of an interpolated string are constant strings, then the resulting string is now also constant. This lets you use string interpolation syntax in more places, like attributes:<\/p>\n Note that the holes must be filled with constant strings<\/em>. Other types, like numeric or date values, cannot be used because they are sensitive to C# 10 has a number of smaller improvements across the language. Some of these just make C# work in the way you expect.<\/p>\n Prior to C# 10, deconstruction required all variables to be new, or all of them to be previously declared. In C# 10, you can mix:<\/p>\n Find out more in the article on deconstruction<\/a>.<\/p>\n C# produces errors if you use a value that has not been definitely assigned. C# 10 understands your code better and produces less spurious errors. These same improvements also mean you’ll see less spurious errors and warnings for null references.<\/p>\n Find out more about C# definite assignment in the what’s new in C# 10 article<\/a>.<\/p>\n C# 10 adds extended property patterns to make it easier to access nested property values in patterns. For example, if we add an address to the The extended property pattern simplifies the code and makes it easier to read, particularly when matching against multiple properties.<\/p>\n Find out more about extended property patterns in the pattern matching article<\/a>.<\/p>\n The parameter name passed to A good example of how this attribute can be used is ArgumentNullException.ThrowIfNull(). It avoids have to pass in the parameter name by defaulting it from the provided value:<\/p>\n Find out more about CallerArgumentExpressionAttribute<\/a><\/p>\n C# 10 GA includes static abstract members in interfaces<\/em> as a preview feature. Rolling out a preview feature in GA allows us to get feedback on a feature that will take longer than a single release to create. Static abstract members in interfaces<\/em> is the basis for a new set of generic math constraints that allow you to abstract over which operators are available. You can read more about generic math constraints in this article<\/a>.<\/p>\n Install .NET 6 or Visual Studio 2022, enjoy C# 10, and tell us what you think!<\/p>\n Check out the great new features in C# 10 as part of .NET 6 and Visual Studio 2022, that make your code prettier, more expressive, and faster.<\/p>\n","protected":false},"author":1097,"featured_media":37391,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[685,756],"tags":[46],"class_list":["post-37390","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet","category-csharp","tag-c"],"acf":[],"blog_post_summary":" Check out the great new features in C# 10 as part of .NET 6 and Visual Studio 2022, that make your code prettier, more expressive, and faster.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/37390","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\/1097"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=37390"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/37390\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/37391"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=37390"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=37390"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=37390"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Global and implicit usings<\/h2>\n
using<\/code> directives simplify how you work with namespaces. C# 10 includes a new global using<\/code> directive and implicit usings<\/em> to reduce the number of usings you need to specify at the top of each file.<\/p>\nGlobal using directives<\/h3>\n
global<\/code> appears prior to a using<\/code> directive, that using applies to the entire project:<\/p>\nglobal using System;<\/code><\/pre>\nusing<\/code> within a global using<\/code> directive. For example, adding static<\/code> imports a type and makes the type’s members and nested types available throughout your project. If you use an alias in your using directive, that alias will also affect your entire project:<\/p>\nglobal using static System.Console;\r\nglobal using Env = System.Environment;<\/code><\/pre>\n.cs<\/code> file, including Program.cs<\/code> or a specifically named file like globalusings.cs<\/code>. The scope of global usings is the current compilation, which generally corresponds to the current project.<\/p>\nImplicit usings<\/h3>\n
global using<\/code> directives for the type of project you are building. To enable implicit usings set the ImplicitUsings<\/code> property in your .csproj<\/code> file:<\/p>\n<PropertyGroup>\r\n <!-- Other properties like OutputType and TargetFramework -->\r\n <ImplicitUsings>enable<\/ImplicitUsings>\r\n<\/PropertyGroup><\/code><\/pre>\nglobal using<\/code> directives included depend on the type of application you are building. For example, implicit usings for a console application or a class library are different than those for an ASP.NET application.<\/p>\nCombining using features<\/h3>\n
using<\/code> directives at the top of your files, global using<\/code> directives, and implicit usings work well together. Implicit usings let you include the .NET namespaces appropriate to the kind of project you’re building with a single line in your project file. global using<\/code> directives let you include additional namespaces to make them available throughout your project. The using<\/code> directives at the top of your code files let you include namespaces used by just a few files in your project.<\/p>\nusing<\/code> directives increase the possibility of ambiguity in name resolution. If you encounter this, consider adding an alias or reducing the number of namespaces you are importing. For example, you can replace global using<\/code> directives with explicit using directives at the top of a subset of files.<\/p>\n<ItemGroup>\r\n <Using Remove=\"System.Threading.Tasks\" \/>\r\n<\/ItemGroup><\/code><\/pre>\nglobal using<\/code> directives, you can add Using<\/code> items to your project file, for example:<\/p>\n<ItemGroup>\r\n <Using Include=\"System.IO.Pipes\" \/>\r\n<\/ItemGroup><\/code><\/pre>\nFile-scoped namespaces<\/h2>\n
namespace MyCompany.MyNamespace;\r\n\r\nclass MyClass \/\/ Note: no indentation\r\n{ ... } <\/code><\/pre>\nImprovements for lambda expressions and method groups<\/h2>\n
Natural types for lambdas<\/h3>\n
Func<...><\/code> or Action<...><\/code> delegate types in the BCL:<\/p>\nFunc<string, int> parse = (string s) => int.Parse(s);<\/code><\/pre>\nvar parse = (string s) => int.Parse(s);<\/code><\/pre>\nvar parse<\/code> in your favorite editor and see that the type is still Func<string, int><\/code>. In general, the compiler will use an available Func<\/code> or Action<\/code> delegate, if a suitable one exists. Otherwise, it will synthesize a delegate type (for example, when you have ref<\/code> parameters or have a large number of parameters).<\/p>\nvar parse = s => int.Parse(s); \/\/ ERROR: Not enough type info in the lambda<\/code><\/pre>\nobject<\/code> or Delegate<\/code>:<\/p>\nobject parse = (string s) => int.Parse(s); \/\/ Func<string, int>\r\nDelegate parse = (string s) => int.Parse(s); \/\/ Func<string, int><\/code><\/pre>\nLambdaExpression<\/code> or the non-generic Expression<\/code> (base type for all expression trees) and<\/em> the lambda has a natural delegate type D<\/code> we will instead produce an Expression<D><\/code>:<\/p>\nLambdaExpression parseExpr = (string s) => int.Parse(s); \/\/ Expression<Func<string, int>>\r\nExpression parseExpr = (string s) => int.Parse(s); \/\/ Expression<Func<string, int>>\r\n<\/code><\/pre>\nNatural types for method groups<\/h3>\n
Func<int> read = Console.Read;\r\nAction<string> write = Console.Write;<\/code><\/pre>\nvar read = Console.Read; \/\/ Just one overload; Func<int> inferred\r\nvar write = Console.Write; \/\/ ERROR: Multiple overloads, can't choose<\/code><\/pre>\nReturn types for lambdas<\/h3>\n
var choose = (bool b) => b ? 1 : \"two\"; \/\/ ERROR: Can't infer return type<\/code><\/pre>\nvar choose = object (bool b) => b ? 1 : \"two\"; \/\/ Func<bool, object><\/code><\/pre>\nAttributes on lambdas<\/h3>\n
Func<string, int> parse = [Example(1)] (s) => int.Parse(s);\r\nvar choose = [Example(2)][Example(3)] object (bool b) => b ? 1 : \"two\";<\/code><\/pre>\nAttributeTargets.Method<\/code>.<\/p>\nImprovements to structs<\/h2>\n
with<\/code> expressions.<\/p>\nParameterless struct constructors and field initializers<\/h3>\n
default<\/code>. It was an error for you to create a parameterless constructor on a struct.<\/p>\npublic struct Address\r\n{\r\n public Address()\r\n {\r\n City = \"<unknown>\";\r\n }\r\n public string City { get; init; }\r\n}\r\n<\/code><\/pre>\npublic struct Address\r\n{\r\n public string City { get; init; } = \"<unknown>\";\r\n}<\/code><\/pre>\ndefault<\/code> or as part of array allocation ignore explicit parameterless constructors, and always set struct members to their default values. For more information about parameterless constructors in structs, see the struct type<\/a>.<\/p>\nrecord structs<\/h3>\n
record struct<\/code>. These are similar to record classes that were introduced in C# 9:<\/p>\npublic record struct Person\r\n{\r\n public string FirstName { get; init; }\r\n public string LastName { get; init; }\r\n}<\/code><\/pre>\nrecord<\/code>, or you can use record class<\/code> for clarity.<\/p>\nIEquatable<T><\/code> support and the ==<\/code> operator. Record structs provide a custom implementation of IEquatable<T><\/code> to avoid the performance issues of reflection, and they include record features like a ToString()<\/code> override.<\/p>\npublic record struct Person(string FirstName, string LastName);<\/code><\/pre>\n(string FirstName, string LastName)<\/code> to a named type of Person<\/code> can clean up your code and guarantee consistent member names. Declaring the positional record struct is easy and keeps the mutable semantics.<\/p>\nreadonly<\/code> to the struct (as you can to any struct) or apply readonly<\/code> to individual properties. Object initializers are part of the construction phase where readonly properties can be set. Here is just one of the ways you can work with immutable record structs:<\/p>\nvar person = new Person { FirstName = \"Mads\", LastName = \"Torgersen\"};\r\n\r\npublic readonly record struct Person\r\n{\r\n public string FirstName { get; init; }\r\n public string LastName { get; init; }\r\n}<\/code><\/pre>\nsealed<\/code> modifier on ToString()<\/code> in record classes<\/h3>\nToString()<\/code> method can include the sealed modifier, which prevents the compiler from synthesizing a ToString<\/code> implementation for any derived records.<\/p>\nToString()<\/code> in records in this article<\/a>.<\/p>\nwith<\/code> expressions on structs and anonymous types<\/h3>\nwith<\/code> expressions for all structs, including record structs, as well as for anonymous types:<\/p>\nvar person2 = person with { LastName = \"Kristensen\" };<\/code><\/pre>\nwith<\/code> in this article<\/a><\/p>\nInterpolated string improvements<\/h2>\n
Interpolated string handlers<\/h3>\n
string.Format<\/code>. This can lead to a lot of allocations – the boxing of arguments, allocation of an argument array, and of course the resulting string itself. Also, it leaves no wiggle room in the meaning of the actual interpolation.<\/p>\nStringBuilder.Append<\/code>:<\/p>\nvar sb = new StringBuilder();\r\nsb.Append($\"Hello {args[0]}, how are you?\");<\/code><\/pre>\nAppend(string? value)<\/code> overload with a newly allocated and computed string, appending that to the StringBuilder<\/code> in one chunk. However, Append<\/code> now has a new overload Append(ref StringBuilder.AppendInterpolatedStringHandler handler)<\/code> which takes precedence over the string overload when an interpolated string is used as argument.<\/p>\nSomethingInterpolatedStringHandler<\/code> the API author has done some work behind the scenes to handle interpolated strings more appropriately for their purposes. In the case of our Append<\/code> example, the strings \"Hello \"<\/code>, args[0]<\/code> and \", how are you?\"<\/code> will be individually appended to the StringBuilder<\/code>, which is much more efficient and has the same outcome.<\/p>\nDebug.Assert<\/code>:<\/p>\nDebug.Assert(condition, $\"{SomethingExpensiveHappensHere()}\");<\/code><\/pre>\nDebug.Assert<\/code> now has an overload with a custom interpolated string builder, which ensures that the second argument isn’t even evaluated unless the condition is false.<\/p>\nString.Create()<\/code> lets you specify the IFormatProvider<\/code> used to format the expressions in the holes of the interpolated string argument itself:<\/p>\nString.Create(CultureInfo.InvariantCulture, $\"The result is {result}\");<\/code><\/pre>\nConstant interpolated strings<\/h3>\n
[Obsolete($\"Call {nameof(Discard)} instead\")]<\/code><\/pre>\nCulture<\/code>, and can’t be computed at compile time.<\/p>\nOther improvements<\/h2>\n
Mix declarations and variables in deconstruction<\/h3>\n
int x2;\r\nint y2;\r\n(x2, y2) = (0, 1); \/\/ Works in C# 9\r\n(var x, var y) = (0, 1); \/\/ Works in C# 9\r\n(x2, var y3) = (0, 1); \/\/ Works in C# 10 onwards<\/code><\/pre>\nImproved definite assignment<\/h3>\n
Extended property patterns<\/h3>\n
Person<\/code> record above, we can pattern match in both of the ways shown here:<\/p>\nobject obj = new Person\r\n{\r\n FirstName = \"Kathleen\",\r\n LastName = \"Dollard\",\r\n Address = new Address { City = \"Seattle\" }\r\n};\r\n\r\nif (obj is Person { Address: { City: \"Seattle\" } })\r\n Console.WriteLine(\"Seattle\");\r\n\r\nif (obj is Person { Address.City: \"Seattle\" }) \/\/ Extended property pattern\r\n Console.WriteLine(\"Seattle\");<\/code><\/pre>\nCaller expression attribute<\/h3>\n
CallerArgumentExpressionAttribute<\/code> supplies information about the context of a method call. Like the other CompilerServices attributes, this attribute is applied to an optional parameter. In this case, a string:<\/p>\nvoid CheckExpression(bool condition, \r\n [CallerArgumentExpression(\"condition\")] string? message = null )\r\n{\r\n Console.WriteLine($\"Condition: {message}\");\r\n}<\/code><\/pre>\nCallerArgumentExpression<\/code> is the name of a different parameter. The expression passed as the argument to that parameter will be contained in the string. For example,<\/p>\nvar a = 6;\r\nvar b = true;\r\nCheckExpression(true);\r\nCheckExpression(b);\r\nCheckExpression(a > 5);\r\n\r\n\/\/ Output:\r\n\/\/ Condition: true\r\n\/\/ Condition: b\r\n\/\/ Condition: a > 5<\/code><\/pre>\nvoid MyMethod(object value)\r\n{\r\n ArgumentNullException.ThrowIfNull(value);\r\n}<\/code><\/pre>\nPreview features<\/h2>\n
Closing<\/h2>\n
\n