The next major version of C# is C# 8.0. It’s been in the works for quite some time, even as we built and shipped the minor releases C# 7.1, 7.2 and 7.3, and I’m quite excited about the new capabilities it will bring.<\/p>\n
The current plan is that C# 8.0 will ship at the same time as .NET Core 3.0. However, the features will start to come alive with the previews of Visual Studio 2019 that we are working on. As those come out and you can start trying them out in earnest, we will provide a whole lot more detail about the individual features. The aim of this post is to give you an overview of what to expect, and a heads-up on where to expect it.<\/p>\n
Here’s an overview of the most significant features slated for C# 8.0. There are a number of smaller improvements in the works as well, which will trickle out over the coming months.<\/p>\n
The purpose of this feature is to help prevent the ubiquitous null reference exceptions that have riddled object-oriented programming for half a century now.<\/p>\n
It stops you from putting What if you do<\/em> want null? Then you can use a nullable reference type<\/em>, such as When you try to use a nullable reference, you need to check it for null first. The compiler analyzes the flow of your code to see if a null value could make it to where you use it:<\/p>\n The upshot is that C# lets you express your “nullable intent”, and warns you when you don’t abide by it.<\/p>\n The async\/await feature of C# 5.0 lets you consume (and produce) asynchronous results in straightforward code, without callbacks:<\/p>\n It is not so helpful if you want to consume (or produce) continuous streams of results, such as you might get from an IoT device or a cloud service. Async streams are there for that.<\/p>\n We introduce We’re adding a type We’re also introducing a Today, once you publish an interface it’s game over: you can’t add members to it without breaking all the existing implementers of it.<\/p>\n In C# 8.0 we let you provide a body for an interface member. Thus, if somebody doesn’t implement that member (perhaps because it wasn’t there yet when they wrote the code), they will just get the default implementation instead.<\/p>\n The We’re allowing patterns to contain other patterns:<\/p>\n The pattern Switch statements with patterns are quite powerful in C# 7.0, but can be cumbersome to write. Switch expressions are a “lightweight” version, where all the cases are expressions:<\/p>\n In many cases, when you’re creating a new object, the type is already given from context. In those situations we’ll let you omit the type:<\/p>\n The implementation of this feature was contributed<\/a> by a member of the community, Alireza Habibi<\/a>. Thank you!<\/span><\/p>\n Many of the C# 8.0 language features have platform dependencies. Async streams, indexers and ranges all rely on new framework types that will be part of .NET Standard 2.1. As Immo describes in his post Announcing .NET Standard 2.1<\/a>, .NET Core 3.0 as well as Xamarin, Unity and Mono will all implement .NET Standard 2.1, but .NET Framework 4.8 will not. This means that the types required to use these features won’t be available on .NET Framework 4.8. Likewise, default interface member implementations rely on new runtime enhancements, and we will not make those in the .NET Runtime 4.8 either. <\/p>\n For this reason, using C# 8.0 is only supported on platforms that implement .NET Standard 2.1. The need to keep the runtime stable has prevented us from implementing new language features in it for more than a decade. With the side-by-side and open-source nature of the modern runtimes, we feel that we can responsibly evolve them again, and do language design with that in mind. Scott explained in his Update on .NET Core 3.0 and .NET Framework 4.8<\/a> that .NET Framework is going to see less innovation in the future, instead focusing on stability and reliability. Given that, we think it is better for it to miss out on some language features than for nobody to get them.<\/p>\n The C# language design process is open source, and takes place in the github.com\/dotnet\/csharplang)<\/a> repo. It can be a bit overwhelming and chaotic if you don’t follow along regularly. The heartbeat of language design is the language design meetings, which are captured in the C# Language Design Notes<\/a>.<\/p>\n About a year ago I wrote a post Introducing Nullable Reference Types in C#<\/a>. It should still be an informative read.<\/p>\n You can also watch videos such as The future of C#<\/a> from Microsoft Build 2018, or What’s Coming to C#?<\/a> from .NET Conf 2018, which showcase several of the features.<\/p>\nnull<\/code> into ordinary reference types such as string<\/code> – it makes those types non-nullable! It does so gently, with warnings, not errors. But on existing code there will be new warnings, so you have to opt in to using the feature (which you can do at the project, file or even source line level).<\/p>\n\r\nstring s = null; \/\/ Warning: Assignment of null to non-nullable reference type\r\n<\/pre>\n
string?<\/code>:<\/p>\n\r\nstring? s = null; \/\/ Ok\r\n<\/pre>\n
\r\nvoid M(string? s)\r\n{\r\n Console.WriteLine(s.Length); \/\/ Warning: Possible null reference exception\r\n if (s != null)\r\n {\r\n Console.WriteLine(s.Length); \/\/ Ok: You won't get here if s is null\r\n }\r\n}\r\n<\/pre>\nAsync streams<\/h2>\n
\r\nasync Task<int> GetBigResultAsync()\r\n{\r\n var result = await GetResultAsync();\r\n if (result > 20) return result; \r\n else return -1;\r\n}\r\n<\/pre>\nIAsyncEnumerable<T><\/code>, which is exactly what you’d expect; an asynchronous version of IEnumerable<T><\/code>. The language lets you await foreach<\/code> over these to consume their elements, and yield return<\/code> to them to produce elements.<\/p>\n\r\nasync IAsyncEnumerable<int> GetBigResultsAsync()\r\n{\r\n await foreach (var result in GetResultsAsync())\r\n {\r\n if (result > 20) yield return result; \r\n }\r\n}\r\n<\/pre>\nRanges and indices<\/h2>\n
Index<\/code>, which can be used for indexing. You can create one from an int<\/code> that counts from the beginning, or with a prefix ^<\/code> operator that counts from the end:<\/p>\n\r\nIndex i1 = 3; \/\/ number 3 from beginning\r\nIndex i2 = ^4; \/\/ number 4 from end\r\nint[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };\r\nConsole.WriteLine($\"{a[i1]}, {a[i2]}\"); \/\/ \"3, 6\"\r\n<\/pre>\nRange<\/code> type, which consists of two Index<\/code>es, one for the start and one for the end, and can be written with a x..y<\/code> range expression<\/em>. You can then index with a Range<\/code> in order to produce a slice:<\/p>\n\r\nvar slice = a[i1..i2]; \/\/ { 3, 4, 5 }\r\n<\/pre>\nDefault implementations of interface members<\/h2>\n
\r\ninterface ILogger\r\n{\r\n void Log(LogLevel level, string message);\r\n void Log(Exception ex) => Log(LogLevel.Error, ex.ToString()); \/\/ New overload\r\n}\r\n\r\nclass ConsoleLogger : ILogger\r\n{\r\n public void Log(LogLevel level, string message) { ... }\r\n \/\/ Log(Exception) gets default implementation\r\n}\r\n<\/pre>\nConsoleLogger<\/code> class doesn’t have to implement the Log(Exception)<\/code> overload of ILogger<\/code>, because it is declared with a default implementation. Now you can add new members to existing public interfaces as long as you provide a default implementation for existing implementors to use.<\/p>\nRecursive patterns<\/h2>\n
\r\nIEnumerable<string> GetEnrollees()\r\n{\r\n foreach (var p in People)\r\n {\r\n if (p is Student { Graduated: false, Name: string name }) yield return name;\r\n }\r\n}\r\n<\/pre>\nStudent { Graduated: false, Name: string name }<\/code> checks that the Person<\/code> is a Student<\/code>, then applies the constant pattern false<\/code> to their Graduated<\/code> property to see if they’re still enrolled, and the pattern string name<\/code> to their Name<\/code> property to get their name (if non-null). Thus, if p<\/code> is a Student<\/code>, has not graduated and has a non-null name, we yield return<\/code> that name.<\/p>\nSwitch expressions<\/h2>\n
\r\nvar area = figure switch \r\n{\r\n Line _ => 0,\r\n Rectangle r => r.Width * r.Height,\r\n Circle c => Math.PI * c.Radius * c.Radius,\r\n _ => throw new UnknownFigureException(figure)\r\n};\r\n<\/pre>\nTarget-typed new-expressions<\/h2>\n
\r\nPoint[] ps = { new (1, 4), new (3,-2), new (9, 5) }; \/\/ all Points\r\n<\/pre>\nPlatform dependencies<\/h2>\n
How can I learn more?<\/h2>\n