The Evolution of C#

The first version introduced core features like classes, structs, interfaces, events, and properties. It established the foundation of the language with managed code execution.

Added generics, partial classes, anonymous methods, nullable types, and iterator blocks. This version significantly improved type safety and code reuse.

// Example of generics in C# 2.0
List<string> names = new List<string>();
names.Add("John");
names.Add("Jane");

Introduced Language Integrated Query (LINQ), lambda expressions, extension methods, anonymous types, and automatic properties. This version revolutionized data querying in .NET.

Added dynamic typing, named and optional parameters, and improved COM interoperability. This version made working with dynamic languages and COM objects much easier.

Introduced async/await for asynchronous programming, caller info attributes. This version simplified writing asynchronous code dramatically.

// Async/await example
public async Task<string> GetDataAsync()
{
    return await httpClient.GetStringAsync(url);
}

Added null-conditional operators, string interpolation, expression-bodied members, and the Roslyn compiler-as-a-service. This version focused on developer productivity.

Introduced tuples, pattern matching, local functions, and out variables. This version continued to enhance functional programming capabilities.

Added nullable reference types, async streams, ranges and indices, pattern matching enhancements, and default interface methods.

Introduced global using directives, file-scoped namespaces, record structs, constant interpolated strings, and improvements to pattern matching and lambda expressions.

// File-scoped namespace example
    namespace MyApp;
    

Added raw string literals, generic math support, required members, list patterns, UTF-8 string literals, and improvements to pattern matching and structs.

// Raw string literal example
    string json = """
    {
      "name": "Alice"
    }
    """;
    

Introduced primary constructors for all types, collection expressions, alias any type, and improvements to lambda expressions and method groups.

// Primary constructor example
    class Point(int x, int y)
    {
        public int X => x;
        public int Y => y;
    }
    

Added collection literals, params spans, extension types, and further enhancements to pattern matching and type inference. C# 13 continues to focus on developer productivity and modern language features.

// Collection literal example
    var numbers = [1, 2, 3, 4];