<p>What are the correct version numbers for C#? What came out when? Why can't I find any answers about <strong><em>C# 3.5</em></strong>?</p>

<p>This question is primarily to aid those who are searching for an answer using an incorrect version number, e.g. <strong><em>C# 3.5</em></strong>. The hope is that anyone failing to find an answer with the wrong version number will find <em>this</em> question and then search again with the right version number.</p>

C# language version history:
These are the
versions of C#
known about at the time of this writing:
C# 1.0
released with .NET 1.0 and VS2002 (January 2002)
C# 1.2
(bizarrely enough); released with .NET 1.1 and VS2003 (April 2003). First version to call
```
Dispose
```
on
```
IEnumerator
```
s which implemented
```
IDisposable
```
. A few other small features.
C# 2.0
released with .NET 2.0 and VS2005 (November 2005). Major new features: generics, anonymous methods, nullable types, and iterator blocks
C# 3.0
released with .NET 3.5 and VS2008 (November 2007). Major new features: lambda expressions, extension methods, expression trees, anonymous types, implicit typing (
```
var
```
), and query expressions
C# 4.0
released with .NET 4 and VS2010 (April 2010). Major new features: late binding (
```
dynamic
```
), delegate and interface generic variance, more
COM
support, named arguments, tuple data type and optional parameters
C# 5.0
released with .NET 4.5 and VS2012 (August 2012).
Major features
: async programming, and caller info attributes. Breaking change:
loop variable closure
.
C# 6.0
released with .NET 4.6 and VS2015 (July 2015). Implemented by
Roslyn
.
Features
: initializers for automatically implemented properties, using directives to import static members, exception filters, element initializers,
```
await
```
in
```
catch
```
and
```
finally
```
, extension
```
Add
```
methods in collection initializers.
C# 7.0
released with .NET 4.7 and VS2017 (March 2017). Major
new features
:
tuples
,
ref locals and ref return
,
pattern matching
(including pattern-based switch statements),
inline
```
out
```
parameter declarations
,
local functions
,
binary literals, digit separators
, and
arbitrary async returns
.
C# 7.1
released with VS2017 v15.3 (August 2017). New features:
async main
,
tuple member name inference
,
default expression
, and
pattern matching with generics
.
C# 7.2
released with VS2017 v15.5 (November 2017). New features:
private protected access modifier
,
Span<T>, aka interior pointer, aka stackonly struct
, and
everything else
.
C# 7.3
released with VS2017 v15.7 (May 2018). New features:
enum, delegate and
```
unmanaged
```
generic type constraints
.
```
ref
```
reassignment. Unsafe improvements:
```
stackalloc
```
initialization, unpinned indexed
```
fixed
```
buffers, custom
```
fixed
```
statements. Improved overloading resolution. Expression variables in initializers and queries.
```
==
```
and
```
!=
```
defined for tuples. Auto-properties' backing fields can now be targeted by attributes.
C# 8.0
released with .NET Core 3.0 and VS2019 v16.3 (September 2019). Major
new features
:
nullable reference-types
,
asynchronous streams
,
indices and ranges
,
readonly members
,
using declarations
,
default interface methods
,
static local functions
, and
enhancement of interpolated verbatim strings
.
C# 9.0
released with
.NET 5.0
and VS2019 v16.8 (November 2020). Major
new features
:
init-only properties
,
records
,
with-expressions
, data classes, positional records,
top-level programs
,
improved pattern matching
(simple type patterns, relational patterns, logical patterns), improved target typing (target-type
```
new
```
expressions, target typed
```
??
```
and
```
?
```
), and covariant returns. Minor features: relax ordering of
```
ref
```
and
```
partial
```
modifiers, parameter null checking, lambda discard parameters, native
```
int
```
s, attributes on local functions, function pointers, static lambdas, extension
```
GetEnumerator
```
, module initializers, and extending partial.
C# 10.0
released with .NET 6.0 (November 2021). Major
new features
: record structs, struct parameterless constructors, interpolated string handlers, global
```
using
```
directives, file-scoped namespace declarations, extended property patterns, const interpolated strings, mixed assignment and declaration in deconstruction, async method builders (via attributes) for individual methods, the
```
CallerArgumentExpression
```
attribute for parameters, enhanced
```
#line
```
pragmas.
C# 11.0
will be released with .NET 7.0 (Date to be annonced, already testable). Major
new features
: file-scoped types, generic math support, auto-default structs, pattern match
```
Span<char>
```
on a constant string, extended nameof scope, numeric
```
IntPtr
```
, UTF-8 string literals, required members,
```
ref
```
fields and
```
scoped ref
```
, raw string literals, improved method group conversion to delegate, warning wave 7, generic attributes, newlines in string interpolation expressions, list patterns
In response to the OP's question:
What are the correct version numbers for C#? What came out when? Why can't I find any answers about C# 3.5?
There is no such thing as C# 3.5 - the cause of confusion here is that the C# 3.0 is present in .NET 3.5. The language and framework are versioned independently, however - as is the CLR, which is at version 2.0 for .NET 2.0 through 3.5, .NET 4 introducing CLR 4.0, service packs notwithstanding. The CLR in .NET 4.5 has various improvements, but the versioning is unclear: in some places it may be referred to as CLR 4.5 (
this MSDN page
used to refer to it that way, for example), but the
```
Environment.Version
```
property still reports 4.0.xxx.
As of May 3, 2017, the C# Language Team created a history of C# versions and features on their GitHub repository:
Features Added in C# Language Versions
. There is also
a page that tracks upcoming and recently implemented language features
.