C# versions: release history and guides
What this section covers
Section titled “What this section covers”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.
Start here: pick a reading path
Section titled “Start here: pick a reading path”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.
Release table
Section titled “Release table”| 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).
Map of version pages
Section titled “Map of version pages”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
breakandcontinue, with breaking changes and upgrade steps. - C# 14 release guide: extension members, the
fieldkeyword, null-conditional assignment and the span conversion break. - C# 13 release guide:
paramscollections, theLocktype,ref structin 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 structandinparameters. - C# 7.1 highlights: async
Mainand thedefaultliteral. - 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 voidtraps. - 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.
C# 11 highlights
Section titled “C# 11 highlights”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 abstractmembers, 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
u8suffix produces aReadOnlySpan<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
requiredmodifier 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
filemodifier limits a type to its source file, which helps source generators avoid name clashes. reffields andscoped: aref structcan holdreffields, andscopedlimits how far a reference can escape. Memory and performance- Unsigned right shift (
>>>) and checked user-defined operators: a logical shift operator, andcheckedvariants of user-defined operators. Control flow and operators - Smaller changes:
nintandnuintbecome aliases ofSystem.IntPtrandSystem.UIntPtr,nameofcan refer to parameters in attributes on a method, and method group conversion to a delegate can reuse a cached delegate.
C# 10 highlights
Section titled “C# 10 highlights”Released with .NET 6 in November 2021. Its theme is removing ceremony and improving performance in the runtime libraries.
- Global using directives:
global usingimports 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 structbrings record syntax and value equality to value types, andwithexpressions 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
ToStringin records: a record can seal itsToStringoverride 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 stringcan 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
varworks), 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 byArgumentNullException.ThrowIfNull.- Smaller changes: more accurate definite-assignment and null-state analysis,
AsyncMethodBuilderon individual methods, and a new#linedirective format for source generators.
C# 9 highlights
Section titled “C# 9 highlights”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
ToStringand positional syntax. Types and records - Init-only setters:
initaccessors allow a property to be set only during object initialization. Object construction and initialization withexpressions: non-destructive copies of records, such asorder with { Status = "Shipped" }. Object construction and initialization- Top-level statements: a program’s entry point can be plain statements in one file, with no
Mainmethod orProgramclass. 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:
staticlambdas 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:
nintandnuintmatch the platform pointer size, anddelegate*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
GetEnumeratorinforeach, attributes on local functions, and[SkipLocalsInit]to suppress zero-initialization of locals.
C# 8 highlights
Section titled “C# 8 highlights”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 ??= yassigns only whenxisnull. 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:
^1counts from the end anda..bslices arrays, strings and spans. Collections and queries - Asynchronous streams:
IAsyncEnumerable<T>withawait foreach. Async and await - Using declarations and
await using:using vardisposes at the end of the scope, andawait usingdisposes 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:
staticlocal functions cannot capture locals orthis. Methods and lambdas - Readonly members and disposable ref structs: individual struct members can be
readonly, and aref structcan be disposed withusing. Memory and performance - Smaller changes: unmanaged constructed types,
stackallocin nested expressions,@$"..."as well as$@"..."for interpolated verbatim strings, and lambda and local function parameters that may shadow outer variables.
C# 7.3 highlights
Section titled “C# 7.3 highlights”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 : Enumandwhere T : Delegate. - Ref local reassignment:
reflocals and parameters can be pointed at a different variable with= ref. Memory and performance stackallocinitializers:Span<int> codes = stackalloc[] { 1, 2, 3 };. Memory and performance- Fixed buffer and
fixedimprovements: fixed-size buffers can be indexed without pinning, and any type with a suitableGetPinnableReferenceworks in afixedstatement. Memory and performance - Tuple equality: tuples can be compared with
==and!=, element by element. Types and records - Expression variables in more places:
out varand 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-publicsignand-pathmapcompiler 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.
C# 7.2 highlights
Section titled “C# 7.2 highlights”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 structtypes andSpan<T>: stack-only types that can wrap any contiguous memory without copying. Memory and performancereadonly struct: declares a struct immutable so the compiler can avoid defensive copies. Memory and performanceinparameters andref readonlyreturns: pass and return large structs by reference without allowing writes. Memory and performance- Conditional
refexpressions:refcan 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_1010and0x_FFmay start with an underscore after the base prefix. Types, variables and operators
C# 7.1 highlights
Section titled “C# 7.1 highlights”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 bestatic async Task Main(). Async and await defaultliteral:defaultwithout a type when the compiler can infer it, as inLoad(default). Types and records- Inferred tuple element names:
(order.Id, order.Total)gets elements namedIdandTotal. Types and records - Pattern matching on generic type parameters:
isandswitchpatterns work on values of a type parameterT. Pattern matching - Compiler options:
-refoutand-refonlyproduce reference assemblies.
C# 7.0 highlights
Section titled “C# 7.0 highlights”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 aDeconstructmethod. Types and records - Discards:
_ignores values you do not need. Types and records - Pattern matching: type, constant and
varpatterns inisexpressions andswitchstatements, pluswhenclauses 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:
throwinside expressions, as inname ?? throw new ArgumentNullException(nameof(name)). Control flow and operators - Generalized async return types:
asyncmethods can return types such asValueTask<T>. Async and await - Binary literals and digit separators:
0b1010_1010and1_000_000. Types, variables and operators
C# 6 highlights
Section titled “C# 6 highlights”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.
- String interpolation:
$"Order {id} total {total}". String literals and interpolation - Null-conditional operators:
customer?.Address?.Cityanditems?[0]stop atnullinstead of throwing. Null handling nameof: the name of a variable, type or member as a string that survives renames. Methods and lambdas- Expression-bodied methods and get-only properties:
=>for one-expression members. Methods and lambdas - Auto-property initializers and get-only auto-properties:
public decimal Total { get; } = 0m;. Object construction and initialization - Index initializers:
new Dictionary<string, int> { ["CABLE-01"] = 3 }. Object construction and initialization using static: import the static members of a type. Code organization- Exception filters:
catch (HttpRequestException ex) when (ex.StatusCode == ...). Control flow and methods awaitincatchandfinallyblocks. Async and await
C# 4 highlights
Section titled “C# 4 highlights”Released with Visual Studio 2010 and .NET Framework 4 in April 2010.
- Dynamic binding: the
dynamictype 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:
outandinon interface and delegate type parameters, so anIEnumerable<Order>can be used as anIEnumerable<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.
C# 3 highlights
Section titled “C# 3 highlights”Released with Visual Studio 2008 in November 2007, with the full feature set arriving in .NET Framework 3.5. Almost every feature serves LINQ.
- LINQ query expressions:
from o in orders where o.Total > 100 select o.Id. Collections and queries - Lambda expressions:
o => o.Total > 100, short inline functions. Collections and queries - Expression trees: lambdas compiled to data that providers such as Entity Framework translate to SQL. Collections and queries
- Extension methods: static methods called as if they were instance methods, the mechanism behind LINQ’s
WhereandSelect. Methods and lambdas - Anonymous types:
new { o.Id, o.Total }for projections. Collections and queries - Implicitly typed local variables (
var). Types and records - Auto-implemented properties:
public string Sku { get; set; }. Object construction and initialization - Object and collection initializers: set properties and add items in the
newexpression. Object construction and initialization - Partial methods: a method declared in one part of a partial class and optionally implemented in another, used by code generators. Object construction and initialization
C# 2 highlights
Section titled “C# 2 highlights”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 holdnull, and??supplies a fallback. Null handling - Iterators:
yield returnproduces 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::andalias::resolve names unambiguously.
C# 1 highlights
Section titled “C# 1 highlights”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.
- Classes, structs and interfaces: reference types, value types and contracts. Classes and objects and inheritance and interfaces
- Properties, indexers and events: members that look like fields, array-style access, and publish-subscribe notifications. Object construction and initialization
- Delegates: type-safe references to methods, the basis of events and later lambdas. Collections and queries
- Operators and statements: arithmetic, comparison and logical operators,
if,switch, loops andtry. Types, variables and operators and control flow and methods checkedanduncheckedarithmetic: opt in to overflow exceptions. Control flow and operators- Attributes: declarative metadata read by the compiler, runtime and tools. Code organization
- The
usingstatement: deterministic disposal of resources. Resource management - Unsafe code: pointers and
fixedinsideunsafeblocks. Memory and performance
C# 1.2 followed with Visual Studio .NET 2003 in April 2003. Its notable change: foreach calls Dispose on an enumerator that implements IDisposable.
Where to go next
Section titled “Where to go next”- 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.
Official references
Section titled “Official references”- The history of C# (Microsoft Learn, includes C# 15)
- C# language version history (dotnet/csharplang repository, feature lists for every version)
- What’s new in C# 15
- What’s new in C# 14
- What’s new in C# 11, C# 10 and C# 9
- C# language versioning: defaults by target framework
- Microsoft .NET and .NET Core lifecycle dates
- Releases and support for .NET (STS and LTS)
- .NET Framework lifecycle FAQ and supported .NET Framework versions
- .NET Framework versions and the Visual Studio release that included each
- Visual Studio 2017 release notes for 15.3 (C# 7.1), 15.5 (C# 7.2) and 15.7 (C# 7.3)