C# History

Anonymous methods

⌨️ delegate

Asynchronous members

⌨️ async ⌨️ await

Asynchronous streams

async IAsyncEnumerable<T> Method( … )

Discards

_

Dynamic binding

⌨️ dynamic

Exceptions: Exception filters

catch (ExceptionType e) when expression

Exceptions: Throw expressions

expr ? expr : throw exception 🔹 x ?? throw exception 🔹 Member ⇒ throw exception

Expression bodied members

Member ⇒ expression; // method, operator, or read-only property

Expression bodied members: Expanded

// constructors, finalizers, indexers, and all properties now supported

Extension methods

Method(this Type param)

Function pointers

⌨️ delegate

Generics

Type<T> and 🧩 System.Collections.Generic

Generics: INumber

🧩 INumber<T>

Global usings

global using Namespace ;

Indices and ranges

❇️ ^ ❇️ .. 🧩 System.Index 🧩 System.Range

Initialization: Anonymous types

new { }

Initialization: Implicitly typed local variables

⌨️ var

Initialization: Index initializers

❇️ new Dictionary<_type_,type> { [value] = value, }

Initialization: Initializers

new Type { … } 🔹 new CollectionType { item, item, item, … }

Initialization: Required

❇️ required fieldOrProperty

Initialization: Target typed new

// new() doesn’t require a type name when inferrable

Interfaces: Default methods

// provide interface method implementations to inherit

Interfaces: Static virtual

static virtual or abstract virtual

Iterators

⌨️ yield return

Lambda expressions

params ⇒ expression

Lambda expressions: Attributes

var name = [Attribute] params ⇒ expression ;

Lambda expressions: Discard params

() ⇒ _expression

Lambda expressions: Natural type

var name = params ⇒ expression ; _// or name as object, Delegate, &c

Lambda expressions: Return type

var name = returntype params ⇒ expression ;

Literals: Binary literals

0b10011

Literals: Default literals

⌨️ default

Literals: Digit separators

7_000_000

Literals: Raw strings

// multiline, multiquoted, indented string literals

Literals: UTF-8 strings

"string literal"u8

Local functions

type Name() { type OtherName() { … } … OtherName(); }

Local functions: Attributes

// attributes are allowed before local functions

Local functions: Extern

// local functions may be marked as extern

Local functions: Static

// local functions can now be static

Module initializers

[ModuleInitializer] Method() { … }

Nameof operator

⌨️ nameof()

Native sized integers

⌨️ nint // System.IntPtr ⌨️ nuint // System.UIntPtr

Nesting: File scoped namespaces

namespace Name ;

Nesting: Top level statements

// statements in one source file outside any containing method imply program entry point

Nesting: Using declarations

using var x = disposble; // applies to end of scope

Nulls: Null forgiving operator

❇️ !

Nulls: Null propagator

❇️ x?.member ❇️ x?[expression]

Nulls: Null-coalescing assignment

❇️ ??=

Nulls: Nullable types

🧩 Nullable<T> ❇️ Type?

Nulls: Nullable types: Reference types

// reference types may not be null without ?, and require null-checking with it

Operators: Checked/unchecked

❇️ checked or unchecked

Parameters: Caller info attributes

🧩 CallerFilePathAttribute 🧩 CallerLineNumberAttribute 🧩 CallerMemberNameAttribute

Parameters: Caller info attributes: Expression

🧩 CallerArgumentExpressionAttribute

Parameters: In parameters

⌨️ in

Parameters: Named arguments

Method( paramName: value)

Parameters: Non-trailing named arguments

// named params can precede unnamed ones that are in the right position

Parameters: Out variables

Method(out var param)

Partial classes

⌨️ partial class ⌨️ partial interface ⌨️ partial struct

Partial Methods

⌨️ partial type Method( … );

Pattern matching

expression is pattern // or is not 🔹 switch(expression) { case pattern: … }

Pattern matching: Character spans

charSpan is "string literal"

Pattern matching: Conjunction

x is pattern and pattern

Pattern matching: Disjunction

x is pattern or pattern

Pattern matching: Lists

value is [1, 2, 3, _, 5, ..]

Pattern matching: Negation

x is not pattern // not just types

Pattern matching: Parentheses

x is ( patterns ) and ( patterns )

Pattern matching: Properties

expression is { Property: value }

Pattern matching: Properties: Extended

expression is { Property.Subproperty: value }

Pattern matching: Relational

x is > value // or >= < ⇐

Pattern matching: Switch expressions

expression switch { pattern ⇒ value, … }

Pattern matching: Tuples

expression is ( value/identifier , …)

Pattern matching: Type variables

x is type

Properties: Auto properties

Property { get; set; }

Properties: Auto properties: Initializers

Property { get; set; } = value;

Properties: Init only setters

Property { get; init; }

Query expressions

⌨️ from item in Items where item != null orderby item select item

Readonly members

⌨️ readonly Method

Records

⌨️ record

Records: Record structs

record struct

Static imports

using static Namespace.StaticClassName ;

Static lambdas and anonymous funcions

// lambdas and anonymous functions may be static

String interpolation

❇️ $"…{expression}…"

String interpolation: Braces

$$""{"value": "{{value}}"}"" // multiple $ add extra { } for interpolation

String interpolation: Const

const string name = $"…{constantexpr}…";

String interpolation: Custom handler

🧩 InterpolatedStringHandlerAttribute

String interpolation: Newlines

// newlines allowed within interpolation expressions

String interpolation: Verbatim enhancement

❇️ @$"…" (previously only $@"…" worked)

Struct initializers

Property { get; init; } = value ;

Suppress emitting localsinit

🧩 SkipLocalsInitAttribute

Tuples and deconstruction

(type, …) x = (value, …); // or with (_type PropertyName, …)

Tuples: Inferred element names

list.Select(x ⇒ (x.Id, x.Name)).Where(y ⇒ y.Id == 1)

Types: Pointer aliases

nint or nuint

Visibility: File scope

file class MyClassName