Skip to content

Latest commit

 

History

History
215 lines (195 loc) · 29.3 KB

Language-Version-History.md

File metadata and controls

215 lines (195 loc) · 29.3 KB

Features Added in C# Language Versions

C# 13.0 - .NET 9 and Visual Studio 2022 version 17.12

  • ESC escape sequence: introduces the \e escape sequence to represent the ESCAPE/ESC character (U+001B).
  • Method group natural type improvements: look scope-by-scope and prune inapplicable candidates early when determining the natural type of a method group.
  • Lock object: allow performing a lock on System.Threading.Lock instances.
  • Implicit indexer access in object initializers: allows indexers in object initializers to use implicit Index/Range indexers (new C { [^1] = 2 }).
  • params collections: extends params support to collection types (void M(params ReadOnlySpan<int> s)).
  • ref/unsafe in iterators/async: allows using ref/ref struct locals and unsafe blocks in iterators and async methods between suspension points.
  • ref struct interfaces: allows ref struct types to implement interfaces and introduces the allows ref struct constraint.
  • Overload resolution priority: allows API authors to adjust the relative priority of overloads within a type using System.Runtime.CompilerServices.OverloadResolutionPriority.
  • Partial properties: allows splitting a property into multiple parts using the partial modifier.
  • Better conversion from collection expression element: improves overload resolution to account for the element type of collection expressions.

C# 12.0 - .NET 8 and Visual Studio 2022 version 17.8

  • Collection expressions: provides a uniform and efficient way of creating collections using collection-like types (List<int> list = [1, 2, 3];)
  • Primary Constructors: helps reduce field and constructor boilerplate (class Point(int x, int y);)
  • Inline Arrays: provides a general-purpose and safe mechanism for declaring arrays using the [InlineArray(size)] attribute.
  • Using aliases for any type: relaxes many restrictions on using alias declarations, allowing built-in types, tuple types, pointer types, array types (using Point = (int x, int y);)
  • Ref readonly parameters: ref readonly parameters mandate that arguments are passed by reference instead of potentially copied, can’t be modified, and warn if a temporary variable must be created.
  • Nameof accessing instance members: relaxes some restrictions on usage of instance members inside nameof (nameof(field.ToString))
  • Lambda optional parameters: allows lambda parameters to declare default values ((int i = 42) => { })

C# 11.0 - .NET 7 and Visual Studio 2022 version 17.4

C# 10.0 - .NET 6 and Visual Studio 2022 version 17.0

  • Record structs (record struct Point(int X, int Y);, var newPoint = point with { X = 100 };).
  • With expression on structs and anonymous types.
  • Global using directives: global using directives avoid repeating the same using directives across many files in your program.
  • Improved definite assignment: definite assignment and nullability analysis better handle common patterns such as dictionary?.TryGetValue(key, out value) == true.
  • Constant interpolated strings: interpolated strings composed of constants are themselves constants.
  • Extended property patterns: property patterns allow accessing nested members (if (e is MethodCallExpression { Method.Name: "MethodName" })).
  • Sealed record ToString: a record can inherit a base record with a sealed ToString.
  • Incremental source generators: improve the source generation experience in large projects by breaking down the source generation pipeline and caching intermediate results.
  • Mixed deconstructions: deconstruction-assignments and deconstruction-declarations can be blended together ((existingLocal, var declaredLocal) = expression).
  • Method-level AsyncMethodBuilder: the AsyncMethodBuilder used to compile an async method can be overridden locally.
  • #line span directive: allow source generators like Razor fine-grained control of the line mapping with #line directives that specify the destination span (#line (startLine, startChar) - (endLine, endChar) charOffset "fileName").
  • Lambda improvements: attributes and return types are allowed on lambdas; lambdas and method groups have a natural delegate type (var f = short () => 1;).
  • Interpolated string handlers: interpolated string handler types allow efficient formatting of interpolated strings in assignments and invocations.
  • File-scoped namespaces: files with a single namespace don't need extra braces or indentation (namespace X.Y.Z;).
  • Parameterless struct constructors: support parameterless constructors and instance field initializers for struct types.
  • CallerArgumentExpression: this attribute allows capturing the expressions passed to a method as strings.

C# 9.0 - .NET 5 and Visual Studio 2019 version 16.8

C# 8.0 - .NET Core 3.0 and Visual Studio 2019 version 16.3

  • Nullable reference types: express nullability intent on reference types with ?, notnull constraint and annotations attributes in APIs, the compiler will use those to try and detect possible null values being dereferenced or passed to unsuitable APIs.
  • Default interface members: interfaces can now have members with default implementations, as well as static/private/protected/internal members except for state (ie. no fields).
  • Recursive patterns: positional and property patterns allow testing deeper into an object, and switch expressions allow for testing multiple patterns and producing corresponding results in a compact fashion.
  • Async streams: await foreach and await using allow for asynchronous enumeration and disposal of IAsyncEnumerable<T> collections and IAsyncDisposable resources, and async-iterator methods allow convenient implementation of such asynchronous streams.
  • Enhanced using: a using declaration is added with an implicit scope and using statements and declarations allow disposal of ref structs using a pattern.
  • Ranges and indexes: the i..j syntax allows constructing System.Range instances, the ^k syntax allows constructing System.Index instances, and those can be used to index/slice collections.
  • Null-coalescing assignment: ??= allows conditionally assigning when the value is null.
  • Static local functions: local functions modified with static cannot capture this or local variables, and local function parameters now shadow locals in parent scopes.
  • Unmanaged generic structs: generic struct types that only have unmanaged fields are now considered unmanaged (ie. they satisfy the unmanaged constraint).
  • Readonly members: individual members can now be marked as readonly to indicate and enforce that they do not modify instance state.
  • Stackalloc in nested contexts: stackalloc expressions are now allowed in more expression contexts.
  • Alternative interpolated verbatim strings: @$"..." strings are recognized as interpolated verbatim strings just like $@"...".
  • Obsolete on property accessors: property accessors can now be individually marked as obsolete.
  • Permit t is null on unconstrained type parameter

C# 7.3 - Visual Studio 2017 version 15.7

C# 7.2 - Visual Studio 2017 version 15.5

C# 7.1 - Visual Studio 2017 version 15.3

C# 7.0 - Visual Studio 2017

C# 6 - Visual Studio 2015

C# 5 - Visual Studio 2012

C# 4 - Visual Studio 2010

C# 3 - Visual Studio 2008

C# 2 - Visual Studio 2005

C# 1.2 - Visual Studio .NET 2003

  • Dispose in foreach
  • foreach over string specialization

C# 1.0 - Visual Studio .NET 2002