Skip to content

C# versions: release history and guides

This page indexes C# by release. Six releases have full release guides that cover every headline feature with a compiled sample, the breaking changes, upgrade steps and interview questions: C# 5, C# 12, C# 13, C# 14, C# 15 and the C# 16 preview. Every other release has a highlights section on this page that lists its headline features, one line each, with a link to the topic hub that explains the feature in depth.

The release table is the only place on this page with dates and support status. “Support today” describes the platform that the version is the default for, because a C# version is supported only on the .NET version it ships with and newer ones. Status is as of November 15, 2026.

You build on .NET 10 (LTS) today. Read C# 14 first: it is your default language version, and its span conversions and field keyword are the changes most likely to affect existing code. Then read C# 15 to see what moving to .NET 11 gives you (union types, closed hierarchies, collection expression arguments).

You are starting a new project on .NET 11. Read C# 15, then C# 14 and C# 12, because collection expressions, primary constructors and extension members show up in every modern codebase.

You are upgrading from .NET 8 or .NET 9. Both left support on November 10, 2026. Read the guides in order, C# 12, C# 13, C# 14, C# 15, and work through each page’s breaking-changes section before you change the target framework.

You maintain .NET Framework code. Projects that target .NET Framework default to C# 7.3, and newer versions are unsupported there. Read C# 5 for async/await, the source of most deadlocks in legacy code, then the highlights for C# 6, C# 7.0, C# 7.1, C# 7.2 and C# 7.3 to know exactly which features you can use.

You are learning C# from scratch. Start with the C# basics tutorials, then the topic hubs. Come back to this page when you need to know which version a feature needs.

You are curious about what is next. Read the C# 16 preview page. It separates what Microsoft has shipped as a preview from proposals that are only in progress.

Version Released Shipped with Default for Support today
C# 16 (preview) Guide Not announced .NET 11 SDK: LangVersion preview plus the updated-memory-safety-rules feature (Learn files it as a C# 15 preview; the breaking-change list labels it C# 16) No target framework Preview only; not for production
C# 15 Guide November 2026 .NET 11, Visual Studio 2026 net11.0 Supported: .NET 11 is STS, supported until November 2028
C# 14 Guide November 2025 .NET 10, Visual Studio 2026 net10.0 Supported: .NET 10 is LTS, supported until November 14, 2028
C# 13 Guide November 2024 .NET 9, Visual Studio 2022 version 17.12 net9.0 Out of support: .NET 9 ended November 10, 2026
C# 12 Guide November 2023 .NET 8, Visual Studio 2022 version 17.8 net8.0 Out of support: .NET 8 (LTS) ended November 10, 2026
C# 11 November 2022 .NET 7, Visual Studio 2022 net7.0 Out of support: .NET 7 ended May 14, 2024
C# 10 November 2021 .NET 6, Visual Studio 2022 net6.0 Out of support: .NET 6 (LTS) ended November 12, 2024
C# 9 November 2020 .NET 5, Visual Studio 2019 net5.0 Out of support: .NET 5 ended May 10, 2022
C# 8 September 2019 .NET Core 3.0, Visual Studio 2019 .NET Core 3.x, .NET Standard 2.1 Out of support: .NET Core 3.1 ended December 13, 2022
C# 7.3 May 2018 Visual Studio 2017 version 15.7 .NET Framework (all), .NET Standard 2.0, .NET Core 2.x Through .NET Framework: 4.6.2 and later are serviced as Windows components (4.6.2 until January 12, 2027)
C# 7.2 November 2017 Visual Studio 2017 version 15.5 No target framework Superseded by C# 7.3, the .NET Framework default; selectable with LangVersion 7.2
C# 7.1 August 2017 Visual Studio 2017 version 15.3 No target framework Superseded by C# 7.3; selectable with LangVersion 7.1
C# 7.0 March 2017 Visual Studio 2017 No target framework Superseded by C# 7.3; selectable with LangVersion 7
C# 6 July 2015 Visual Studio 2015, .NET Framework 4.6 No target framework .NET Framework 4.6 ended April 26, 2022; selectable with LangVersion 6
C# 5 Guide August 2012 Visual Studio 2012, .NET Framework 4.5 No target framework .NET Framework 4.5 ended January 12, 2016; the language still compiles with LangVersion 5
C# 4 April 2010 Visual Studio 2010, .NET Framework 4 No target framework .NET Framework 4 ended January 12, 2016; selectable with LangVersion 4
C# 3 November 2007 Visual Studio 2008, .NET Framework 3.5 No target framework .NET Framework 3.5 SP1 runtime supported until January 9, 2029, but not for new development; selectable with LangVersion 3
C# 2 November 2005 Visual Studio 2005, .NET Framework 2.0 No target framework .NET Framework 2.0 is out of support; selectable with LangVersion 2
C# 1.0 January 2002 Visual Studio .NET 2002, .NET Framework 1.0 No target framework .NET Framework 1.0 is out of support; selectable with LangVersion 1

Guide marks a full release guide; the other rows link to their highlights section below. “Shipped with” names the Visual Studio release that first included the compiler and, where Microsoft pairs them, the .NET or .NET Framework version installed with it. C# 1.2 (April 2003, Visual Studio .NET 2003) was a small follow-up release and is covered in the C# 1 highlights. Version labels drop “.0” except where it distinguishes a release (C# 1.0 from 1.2, C# 7.0 from 7.1 to 7.3).

Each entry gives the page or section for that release and a one-line purpose. Features are explained once, in the topic hubs; the release guides and highlights link to them.

  • C# 16 preview: the memory safety preview in the .NET 11 SDK and the proposals that are only in progress.
  • C# 15 release guide: union types, closed hierarchies, collection expression arguments, extension indexers and labeled break and continue, with breaking changes and upgrade steps.
  • C# 14 release guide: extension members, the field keyword, null-conditional assignment and the span conversion break.
  • C# 13 release guide: params collections, the Lock type, ref struct in generics and partial properties.
  • C# 12 release guide: primary constructors, collection expressions, inline arrays and [Experimental].
  • C# 11 highlights: the generic math release, plus raw string literals, required members and list patterns.
  • C# 10 highlights: ceremony removal (global usings, file-scoped namespaces) and record structs.
  • C# 9 highlights: records, init-only setters, top-level statements and pattern combinators.
  • C# 8 highlights: the first release built for .NET Core: nullable reference types, switch expressions, async streams.
  • C# 7.3 highlights: safe code as fast as unsafe code, and the ceiling for .NET Framework projects.
  • C# 7.2 highlights: Span<T>, ref struct, readonly struct and in parameters.
  • C# 7.1 highlights: async Main and the default literal.
  • C# 7.0 highlights: tuples, deconstruction, the first patterns, out variables and local functions.
  • C# 6 highlights: the first Roslyn release, focused on less boilerplate.
  • C# 5 release guide: async/await and caller info attributes, with the deadlock and async void traps.
  • C# 4 highlights: dynamic, named and optional arguments, and generic variance.
  • C# 3 highlights: the LINQ release.
  • C# 2 highlights: generics, nullable value types and iterators.
  • C# 1 highlights: the object-oriented foundation, and the small C# 1.2 follow-up.

Released with .NET 7 in November 2022. Its theme is generic math, with several features that make structs, strings and source generators easier to work with.

  • Generic math (static abstract members in interfaces): interfaces can declare static abstract members, so one generic algorithm works for every numeric type. Memory and performance
  • Raw string literals: """ strings that never need escaping, ideal for JSON, SQL and regular expressions. String literals and interpolation
  • UTF-8 string literals: the u8 suffix produces a ReadOnlySpan<byte> at compile time. String literals and interpolation
  • Newlines in interpolation expressions: the expression inside { } may span several lines. String literals and interpolation
  • List patterns: match arrays and lists by shape, such as [first, .., last]. Pattern matching
  • Pattern match Span<char> on a constant string: spans of characters can be compared with string constants in patterns. Pattern matching
  • Required members: the required modifier forces callers to set a property in the object initializer. Object construction and initialization
  • Auto-default structs: struct constructors no longer need to assign every field; the compiler defaults the rest.
  • Generic attributes: attributes can have type parameters, as in [Validator<Order>]. Code organization
  • File-local types: the file modifier limits a type to its source file, which helps source generators avoid name clashes.
  • ref fields and scoped: a ref struct can hold ref fields, and scoped limits how far a reference can escape. Memory and performance
  • Unsigned right shift (>>>) and checked user-defined operators: a logical shift operator, and checked variants of user-defined operators. Control flow and operators
  • Smaller changes: nint and nuint become aliases of System.IntPtr and System.UIntPtr, nameof can refer to parameters in attributes on a method, and method group conversion to a delegate can reuse a cached delegate.

Released with .NET 6 in November 2021. Its theme is removing ceremony and improving performance in the runtime libraries.

  • Global using directives: global using imports a namespace into every file of the project; the SDK’s implicit usings build on it. Code organization
  • File-scoped namespaces: namespace OrdersPortal.Billing; applies to the whole file and removes one level of indentation. Code organization
  • Record structs: record struct brings record syntax and value equality to value types, and with expressions now work on structs and anonymous types. Types and records
  • Parameterless struct constructors and field initializers: structs can declare a parameterless constructor and initialize fields inline.
  • Sealed ToString in records: a record can seal its ToString override so derived records keep it. Types and records
  • Interpolated string handlers: library types can build interpolated strings without allocating, which logging APIs use. String literals and interpolation
  • Constant interpolated strings: a const string can use interpolation when every placeholder is itself a constant string. String literals and interpolation
  • Extended property patterns: { Customer.Address.City: "Lisbon" } reads nested properties in one pattern. Pattern matching
  • Lambda improvements: lambdas get a natural delegate type (so var works), explicit return types and attributes. Collections and queries
  • Mixed deconstruction: one deconstruction can assign existing variables and declare new ones. Types and records
  • CallerArgumentExpression: a parameter can capture the source text of another argument, used by ArgumentNullException.ThrowIfNull.
  • Smaller changes: more accurate definite-assignment and null-state analysis, AsyncMethodBuilder on individual methods, and a new #line directive format for source generators.

Released with .NET 5 in November 2020. It continues the themes of less ceremony, separating data from behavior, and more patterns in more places.

  • Records: reference types with value-based equality, a readable ToString and positional syntax. Types and records
  • Init-only setters: init accessors allow a property to be set only during object initialization. Object construction and initialization
  • with expressions: non-destructive copies of records, such as order with { Status = "Shipped" }. Object construction and initialization
  • Top-level statements: a program’s entry point can be plain statements in one file, with no Main method or Program class. Code organization
  • Pattern matching enhancements: relational patterns (< 0), logical patterns (and, or, not), type patterns and parenthesized patterns. Pattern matching
  • Target-typed new: Order order = new("ORD-1"); omits the type when the compiler already knows it. Object construction and initialization
  • Static anonymous functions and lambda discard parameters: static lambdas cannot capture state by accident, and (_, _) => discards unused parameters. Collections and queries
  • Covariant return types: an override can return a more derived type than the method it overrides.
  • Native sized integers and function pointers: nint and nuint match the platform pointer size, and delegate* calls functions without a delegate allocation.
  • Source generator support: module initializers and partial methods with return values and any accessibility, which source generators complete.
  • Smaller changes: target-typed conditional expressions, extension GetEnumerator in foreach, attributes on local functions, and [SkipLocalsInit] to suppress zero-initialization of locals.

Released with .NET Core 3.0 in September 2019. It is the first release built specifically for .NET Core: default interface members, ranges and async streams depend on runtime or library support that .NET Framework lacks.

  • Nullable reference types: opt-in compile-time analysis that warns when a reference might be null. Null handling
  • Null-coalescing assignment: x ??= y assigns only when x is null. Null handling
  • Switch expressions: value switch { pattern => result, ... } returns a value from patterns. Pattern matching
  • Property, tuple and positional patterns: recursive patterns that test into an object’s members. Pattern matching
  • Indices and ranges: ^1 counts from the end and a..b slices arrays, strings and spans. Collections and queries
  • Asynchronous streams: IAsyncEnumerable<T> with await foreach. Async and await
  • Using declarations and await using: using var disposes at the end of the scope, and await using disposes asynchronously. Resource management
  • Default interface members: interface members can have a body, so published interfaces can grow without breaking implementers. Methods and lambdas
  • Static local functions: static local functions cannot capture locals or this. Methods and lambdas
  • Readonly members and disposable ref structs: individual struct members can be readonly, and a ref struct can be disposed with using. Memory and performance
  • Smaller changes: unmanaged constructed types, stackalloc in nested expressions, @$"..." as well as $@"..." for interpolated verbatim strings, and lambda and local function parameters that may shadow outer variables.

Released with Visual Studio 2017 version 15.7 in May 2018. Two themes: let safe code perform like unsafe code, and polish existing features. C# 7.3 is the default for every .NET Framework project, so it is the newest version available to most legacy code.

  • More generic constraints: where T : unmanaged, where T : Enum and where T : Delegate.
  • Ref local reassignment: ref locals and parameters can be pointed at a different variable with = ref. Memory and performance
  • stackalloc initializers: Span<int> codes = stackalloc[] { 1, 2, 3 };. Memory and performance
  • Fixed buffer and fixed improvements: fixed-size buffers can be indexed without pinning, and any type with a suitable GetPinnableReference works in a fixed statement. Memory and performance
  • Tuple equality: tuples can be compared with == and !=, element by element. Types and records
  • Expression variables in more places: out var and pattern variables work in field initializers, constructor initializers and query clauses. Methods and lambdas
  • Attributes on backing fields: [field: NonSerialized] on an auto-property targets its hidden field. Code organization
  • Smaller changes: fewer ambiguous overload resolution cases, better resolution when arguments differ only by in, and the -publicsign and -pathmap compiler options.

Microsoft Learn’s version history also repeats several of these items (stackalloc initializers, fixed patterns, ref reassignment, the new constraints) under C# 7.2; the C# language repository’s version history and the Visual Studio 15.7 release notes place them in C# 7.3, which is what this page follows.

Released with Visual Studio 2017 version 15.5 in November 2017. It arrived alongside Span<T> and focuses on passing and storing data by reference safely.

  • ref struct types and Span<T>: stack-only types that can wrap any contiguous memory without copying. Memory and performance
  • readonly struct: declares a struct immutable so the compiler can avoid defensive copies. Memory and performance
  • in parameters and ref readonly returns: pass and return large structs by reference without allowing writes. Memory and performance
  • Conditional ref expressions: ref can select between two references with ?:. Memory and performance
  • private protected: access for derived classes in the same assembly only. Classes and objects
  • Non-trailing named arguments: positional arguments may follow named ones when the names are in position. Control flow and methods
  • Leading digit separators: 0b_1010_1010 and 0x_FF may start with an underscore after the base prefix. Types, variables and operators

Released with Visual Studio 2017 version 15.3 in August 2017, the first C# point release. It also introduced the LangVersion project setting for choosing a language version.

  • Async Main: the entry point can be static async Task Main(). Async and await
  • default literal: default without a type when the compiler can infer it, as in Load(default). Types and records
  • Inferred tuple element names: (order.Id, order.Total) gets elements named Id and Total. Types and records
  • Pattern matching on generic type parameters: is and switch patterns work on values of a type parameter T. Pattern matching
  • Compiler options: -refout and -refonly produce reference assemblies.

Released with Visual Studio 2017 in March 2017.

  • Tuples: lightweight value types with named elements, such as (decimal Total, int Count). Types and records
  • Deconstruction: var (total, count) = Summarize(order); splits a tuple or any type with a Deconstruct method. Types and records
  • Discards: _ ignores values you do not need. Types and records
  • Pattern matching: type, constant and var patterns in is expressions and switch statements, plus when clauses on cases. Pattern matching
  • Out variables: int.TryParse(text, out var quantity) declares the variable at the call. Methods and lambdas
  • Local functions: helper methods declared inside another method. Methods and lambdas
  • More expression-bodied members: => bodies for constructors, finalizers and property and indexer accessors. Methods and lambdas
  • Ref locals and ref returns: return and store references to existing storage instead of copies. Memory and performance
  • Throw expressions: throw inside expressions, as in name ?? throw new ArgumentNullException(nameof(name)). Control flow and operators
  • Generalized async return types: async methods can return types such as ValueTask<T>. Async and await
  • Binary literals and digit separators: 0b1010_1010 and 1_000_000. Types, variables and operators

Released with Visual Studio 2015 and .NET Framework 4.6 in July 2015, the first release of the Roslyn compiler, which is written in C#. Most features remove boilerplate.

Released with Visual Studio 2010 and .NET Framework 4 in April 2010.

  • Dynamic binding: the dynamic type defers member lookup to run time, for COM, scripting languages and dynamic data. Types and records
  • Named and optional arguments: default parameter values, and arguments passed by parameter name. Control flow and methods
  • Generic covariance and contravariance: out and in on interface and delegate type parameters, so an IEnumerable<Order> can be used as an IEnumerable<object>.
  • Embedded interop types: COM interop type information is embedded in your assembly, so primary interop assemblies no longer need to ship with the application.

Released with Visual Studio 2008 in November 2007, with the full feature set arriving in .NET Framework 3.5. Almost every feature serves LINQ.

Released with Visual Studio 2005 and .NET Framework 2.0 in November 2005.

  • Generics: type-safe types and methods such as List<T> without casts or boxing. Collections and queries
  • Nullable value types and the ?? operator: int? can hold null, and ?? supplies a fallback. Null handling
  • Iterators: yield return produces a sequence lazily. Collections and queries
  • Anonymous methods: delegate (Order o) { ... } inline, the forerunner of lambdas. Collections and queries
  • Partial types: one class split across several files, used by designers and generators. Object construction and initialization
  • Static classes: classes that hold only static members and cannot be instantiated. Classes and objects
  • Separate getter and setter accessibility: public decimal Balance { get; private set; }. Classes and objects
  • Delegate improvements: method group conversions, delegate inference, and covariance and contravariance for method groups.
  • Namespace alias qualifier: global:: and alias:: resolve names unambiguously.

C# 1.0 shipped with Visual Studio .NET 2002 and .NET Framework 1.0 in January 2002. It established the object-oriented core every later version builds on.

C# 1.2 followed with Visual Studio .NET 2003 in April 2003. Its notable change: foreach calls Dispose on an enumerator that implements IDisposable.

  • C# topic hubs: every feature explained once, grouped by the problem it solves, in a suggested learning order.
  • C# features overview: a one-line index of the twelve hubs.
  • C# basics: four beginner tutorials for the C# 1.0 foundations that every version builds on.
  • C# interview questions: practice questions that cut across versions.