When troubleshooting code, it can be important to understand what version of C# you are using. The link kept up-to-date by Microsoft is https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-version-history. Up to the time of this writing, here is a brief overview of the different versions of C#.
Released November, 2022
The following features were added in C# 11:
Span<char>
on a constant string
nameof
scoperef
fields and scoped ref
C# 11 introduces generic math and several features that support that goal. You can write numeric algorithms once for all number types. There’s more features to make working with struct
types easier, like required members and auto-default structs. Working with strings gets easier with Raw string literals, newline in string interpolations, and UTF-8 string literals. Features like file local types enable source generators to be simpler. Finally, list patterns add more support for pattern matching.
Released November, 2021
C# 10 adds the following features and enhancements to the C# language:
global using
directivesconst
interpolated stringsToString()
AsyncMethodBuilder
attribute on methods#line
pragmaMore features were available in preview mode. In order to use these features, you must set <LangVersion>
to Preview
in your project:
C# 10 continues work on themes of removing ceremony, separating data from algorithms, and improved performance for the .NET Runtime.
Many of the features mean you’ll type less code to express the same concepts. Record structs synthesize many of the same methods that record classes do. Structs and anonymous types support with expressions. Global using directives and file scoped namespace declarations mean you express dependencies and namespace organization more clearly. Lambda improvements makes it easier to declare lambda expressions where they’re used. New property patterns and deconstruction improvements create more concise code.
The new interpolated string handlers and AsyncMethodBuilder
behavior can improve performance. These language features were applied in the .NET Runtime to achieve performance improvements in .NET 6.
C# 10 also marks more of a shift to the yearly cadence for .NET releases. Because not every feature can be completed in a yearly timeframe, you can try a couple of “preview” features in C# 10. Both generic attributes and static abstract members in interfaces can be used, but these preview features may change before their final release.
Released November, 2020
C# 9 was released with .NET 5. It’s the default language version for any assembly that targets the .NET 5 release. It contains the following new and enhanced features:
C# 9 continues three of the themes from previous releases: removing ceremony, separating data from algorithms, and providing more patterns in more places.
Top level statements means your main program is simpler to read. There’s less need for ceremony: a namespace, a Program
class, and static void Main()
are all unnecessary.
The introduction of records
provides a concise syntax for reference types that follow value semantics for equality. You’ll use these types to define data containers that typically define minimal behavior. Init-only setters provide the capability for non-destructive mutation (with
expressions) in records. C# 9 also adds covariant return types so that derived records can override virtual methods and return a type derived from the base method’s return type.
The pattern matching capabilities have been expanded in several ways. Numeric types now support range patterns. Patterns can be combined using and
, or
, and not
patterns. Parentheses can be added to clarify more complex patterns.
Another set of features supports high-performance computing in C#:
nint
and nuint
types model the native-size integer types on the target CPU.localsinit
instruction can be omitted to save instructions.Another set of improvements supports scenarios where code generators add functionality:
C# 9 adds many other small features that improve developer productivity, both writing and reading code:
new
expressionsstatic
anonymous functionsGetEnumerator()
support for foreach
loopsThe C# 9 release continues the work to keep C# a modern, general-purpose programming language. Features continue to support modern workloads and application types.
Released September, 2019
C# 8.0 is the first major C# release that specifically targets .NET Core. Some features rely on new CLR capabilities, others on library types added only in .NET Core. C# 8.0 adds the following features and enhancements to the C# language:
Default interface members require enhancements in the CLR. Those features were added in the CLR for .NET Core 3.0. Ranges and indexes, and asynchronous streams require new types in the .NET Core 3.0 libraries. Nullable reference types, while implemented in the compiler, is much more useful when libraries are annotated to provide semantic information regarding the null state of arguments and return values. Those annotations are being added in the .NET Core libraries.
Released May, 2018
There are two main themes to the C# 7.3 release. One theme provides features that enable safe code to be as performant as unsafe code. The second theme provides incremental improvements to existing features. New compiler options were also added in this release.
The following new features support the theme of better performance for safe code:
ref
local variables.stackalloc
arrays.fixed
statements with any type that supports a pattern.The following enhancements were made to existing features:
==
and !=
with tuple types.in
has been improved.The new compiler options are:
-publicsign
to enable Open Source Software (OSS) signing of assemblies.-pathmap
to provide a mapping for source directories.Released November, 2017
C# 7.2 added several small language features:
stackalloc
arrays.fixed
statements with any type that supports a pattern.ref
local variables.readonly struct
types, to indicate that a struct is immutable and should be passed as an in
parameter to its member methods.in
modifier on parameters, to specify that an argument is passed by reference but not modified by the called method.ref readonly
modifier on method returns, to indicate that a method returns its value by reference but doesn’t allow writes to that object.ref struct
types, to indicate that a struct type accesses managed memory directly and must always be stack allocated.private protected
access modifier
private protected
access modifier enables access for derived classes in the same assembly.ref
expressions
?:
) can now be a reference.Released August, 2017
C# started releasing point releases with C# 7.1. This version added the language version selection configuration element, three new language features, and new compiler behavior.
The new language features in this release are:
async
Main
method
async
modifier.default
literal expressions
Finally, the compiler has two options -refout
and -refonly
that control reference assembly generation
Released March, 2017
C# version 7.0 was released with Visual Studio 2017. This version has some evolutionary and cool stuff in the vein of C# 6.0. Here are some of the new features:
Other features included:
All of these features offer new capabilities for developers and the opportunity to write cleaner code than ever. A highlight is condensing the declaration of variables to use with the out
keyword and by allowing multiple return values via tuple. .NET Core now targets any operating system and has its eyes firmly on the cloud and on portability. These new capabilities certainly occupy the language designers’ thoughts and time, in addition to coming up with new features.
Released July, 2015
Version 6.0, released with Visual Studio 2015, released many smaller features that made C# programming more productive. Here are some of them:
Other new features include:
Each of these features is interesting in its own right. But if you look at them altogether, you see an interesting pattern. In this version, C# started to eliminate language boilerplate to make code more terse and readable. So for fans of clean, simple code, this language version was a huge win.
They did one other thing along with this version, though it’s not a traditional language feature in itself. They released Roslyn the compiler as a service. The C# compiler is now written in C#, and you can use the compiler as part of your programming efforts.
Released August, 2012
C# version 5.0, released with Visual Studio 2012, was a focused version of the language. Nearly all of the effort for that version went into another groundbreaking language concept: the async
and await
model for asynchronous programming. Here’s the major features list:
The caller info attribute lets you easily retrieve information about the context in which you’re running without resorting to a ton of boilerplate reflection code. It has many uses in diagnostics and logging tasks.
But async
and await
are the real stars of this release. When these features came out in 2012, C# changed the game again by baking asynchrony into the language as a first-class participant. If you’ve ever dealt with long running operations and the implementation of webs of callbacks, you probably loved this language feature.
Released April, 2010
C# version 4.0, released with Visual Studio 2010, would have had a difficult time living up to the groundbreaking status of version 3.0. This version introduced some interesting new features:
Embedded interop types eased the deployment pain of creating COM interop assemblies for your application. Generic covariance and contravariance give you more power to use generics, but they’re a bit academic and probably most appreciated by framework and library authors. Named and optional parameters let you eliminate many method overloads and provide convenience. But none of those features are exactly paradigm altering.
The major feature was the introduction of the dynamic
keyword. The dynamic
keyword introduced into C# version 4.0 the ability to override the compiler on compile-time typing. By using the dynamic keyword, you can create constructs similar to dynamically typed languages like JavaScript. You can create a dynamic x = "a string"
and then add six to it, leaving it up to the runtime to sort out what should happen next.
Dynamic binding gives you the potential for errors but also great power within the language.
Released November, 2007
C# version 3.0 came in late 2007, along with Visual Studio 2008, though the full boat of language features would actually come with .NET Framework version 3.5. This version marked a major change in the growth of C#. It established C# as a truly formidable programming language. Let’s take a look at some major features in this version:
In retrospect, many of these features seem both inevitable and inseparable. They all fit together strategically. It’s thought that C# version’s killer feature was the query expression, also known as Language-Integrated Query (LINQ).
A more nuanced view examines expression trees, lambda expressions, and anonymous types as the foundation upon which LINQ is constructed. But, in either case, C# 3.0 presented a revolutionary concept. C# 3.0 had begun to lay the groundwork for turning C# into a hybrid Object-Oriented / Functional language.
Specifically, you could now write SQL-style, declarative queries to perform operations on collections, among other things. Instead of writing a for
loop to compute the average of a list of integers, you could now do that as simply as list.Average()
. The combination of query expressions and extension methods made a list of integers a whole lot smarter.
Released November, 2005
Let’s take a look at some major features of C# 2.0, released in 2005, along with Visual Studio 2005:
Other C# 2.0 features added capabilities to existing features:
While C# may have started as a generic Object-Oriented (OO) language, C# version 2.0 changed that in a hurry. With generics, types and methods can operate on an arbitrary type while still retaining type safety. For instance, having a List<T> lets you have List<string>
or List<int>
and perform type-safe operations on those strings or integers while you iterate through them. Using generics is better than creating a ListInt
type that derives from ArrayList
or casting from Object
for every operation.
C# version 2.0 brought iterators. To put it succinctly, iterators let you examine all the items in a List
(or other Enumerable types) with a foreach
loop. Having iterators as a first-class part of the language dramatically enhanced readability of the language and people’s ability to reason about the code.
And yet, C# continued to play a bit of catch-up with Java. Java had already released versions that included generics and iterators. But that would soon change as the languages continued to evolve apart.
Released April, 2003
C# version 1.2 shipped with Visual Studio .NET 2003. It contained a few small enhancements to the language. Most notable is that starting with this version, the code generated in a foreach
loop called Dispose on an IEnumerator when that IEnumerator implemented IDisposable.
Released January, 2002
When you go back and look, C# version 1.0, released with Visual Studio .NET 2002, looked a lot like Java. As part of its stated design goals for ECMA, it sought to be a “simple, modern, general-purpose object-oriented language.” At the time, looking like Java meant it achieved those early design goals.
But if you look back on C# 1.0 now, you’d find yourself a little dizzy. It lacked the built-in async capabilities and some of the slick functionality around generics you take for granted. As a matter of fact, it lacked generics altogether. And LINQ? Not available yet. Those additions would take some years to come out.
C# version 1.0 looked stripped of features, compared to today. You’d find yourself writing some verbose code. But yet, you have to start somewhere. C# version 1.0 was a viable alternative to Java on the Windows platform.
The major features of C# 1.0 included: