The Evolution of C#: From 1.0 to 14

Themes That Shaped Each Era of C#

Generics and Type Safety (C# 2.0)#

Generics are the most consequential addition in C# history. Unlike Java's erasure-based generics, .NET generics are reified by the runtime, so List<int> stores integers without boxing and type information survives to run time. Nullable value types, iterators and anonymous methods arrived in the same release and laid the groundwork for everything that followed. The generics and variance guide explains how the CLR implements them.

LINQ and the Functional Turn (C# 3.0)#

C# 3.0 is where C# became a hybrid object-oriented and functional language. Lambdas, extension methods, implicitly typed locals, anonymous types and expression trees all serve Language-Integrated Query. Expression trees made it possible to translate the same query into SQL, which is still how Entity Framework Core works. See LINQ in depth for execution semantics.

Dynamic Interop and Asynchrony (C# 4.0 and 5.0)#

C# 4.0 added dynamic and named and optional arguments, which made COM and dynamic-language interop far less painful, plus generic variance for interfaces and delegates. It remains useful at interop boundaries, but runtime binding requires runtime code generation that is incompatible with Native AOT. C# 5.0 was a focused release built around async and await, which replaced callback-based asynchronous patterns with sequential-looking code. It also fixed a notorious closure bug: each foreach iteration now gets a fresh loop variable.

// C# 5.0 (2012): asynchronous code that reads like synchronous code
public async Task<int> CountWordsAsync(HttpClient http, string url)
{
    string html = await http.GetStringAsync(url);
    return html.Split(new[] { ' ', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
}

The async/await deep dive covers what the compiler generates for this method.

Roslyn and Everyday Productivity (C# 6.0)#

C# 6.0 shipped with Roslyn, the open-source compiler written in C# that exposes syntax trees and semantic models as APIs. Roslyn made analyzers, code fixes and later source generators possible, and it let the team ship language features faster. The language changes themselves were small conveniences that removed boilerplate:

// C# 6 (2015): getter-only auto-properties, expression-bodied members,
// string interpolation, nameof and null-conditional access
public class Account
{
    public Account(string owner)
    {
        if (owner == null) throw new ArgumentNullException(nameof(owner));
        Owner = owner;
    }

    public string Owner { get; }
    public decimal Balance { get; private set; }
    public List<string> Tags { get; } = new List<string>();
    public bool IsOverdrawn => Balance < 0;

    public override string ToString() => $"{Owner}: {Balance:C}";
}

Pattern Matching and Data-Oriented Code (C# 7 to 11)#

Pattern matching grew over five releases, from type patterns in C# 7.0 to switch expressions and property patterns in C# 8, relational and logical patterns in C# 9, extended property patterns in C# 10 and list patterns in C# 11:

// C# 7.0: type pattern with a declaration
if (payment is CardPayment card && card.Amount > 1_000m)
    RequireStrongAuthentication(card);

// C# 8.0: switch expression with property patterns
decimal fee = payment switch
{
    CardPayment { IsInternational: true } => 2.5m,
    CardPayment _ => 1.2m,
    BankTransfer _ => 0m,
    _ => throw new NotSupportedException(payment.GetType().Name),
};

// C# 9.0: relational and logical patterns
string risk = score switch
{
    < 300 => "high",
    >= 300 and < 700 => "medium",
    _ => "low",
};

// C# 11: list patterns
if (args is ["--port", var portText, ..] && int.TryParse(portText, out var port))
    Console.WriteLine($"Listening on {port}");

Records in C# 9, record structs in C# 10 and required members in C# 11 complete the picture: data can be declared concisely, compared by value and copied with with expressions. The records and pattern matching guide goes further.

Safety by Default (C# 8 onward)#

Nullable reference types in C# 8 were arguably the biggest change to everyday C# since generics. Rather than changing the runtime, the compiler tracks null state and warns when you might dereference null. New project templates enable it by default, and the .NET libraries are annotated, so modern code treats null warnings as real defects.

Performance Without Unsafe Code (C# 7.2 to 14)#

A steady thread of features lets safe code reach speeds that once required pointers: ref returns in C# 7.0, Span<T>, ref struct and in parameters in C# 7.2, ref fields and scoped in C# 11, inline arrays in C# 12, allows ref struct in C# 13, and first-class span conversions plus user-defined compound assignment in C# 14. Most application developers consume these indirectly, through faster libraries such as System.Text.Json and ASP.NET Core.

Less Ceremony and Better Metaprogramming (C# 9 to 14)#

Top-level statements, global usings, file-scoped namespaces, primary constructors, collection expressions and the field keyword steadily removed boilerplate. At the same time, source generators (introduced with C# 9 and made incremental with C# 10), partial members and C# 14 extension members moved code generation and API extension from runtime reflection to compile time, which also suits trimming and Native AOT.