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: Blocks

⌨️ extension(TypeName) { }

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: Index reverse

var a = new int[] { [^3] = 0, [^2] = 1, [^1] = 2, }; // [0, 1, 2]

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: Param defaults

(int index = 1) ⇒ arrayValues[index]

Lambda expressions: Param modifiers

// Untyped params can be scoped, ref, in, out, or ref readonly

Lambda expressions: Return type

var name = returntype params ⇒ expression ;

Literals: Binary literals

0b10011

Literals: Collection expressions

[1, 2, 3, 4, ..arrayValues]

Literals: Default literals

⌨️ default

Literals: Digit separators

7_000_000

Literals: Escape escape

"\e" // U+001B Escape control character

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() { … }

Multithreading: New lock object

🏷️ System.Threading.Lock

Nameof operator

⌨️ nameof()

Nameof operator: Generics

nameof(GenericType<T>)

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: Null-conditional assignment

object.?property = _value 🔹 object?[index] = value

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

Operators: Compound assignment

void operator+() { } 🔹 void operator=(type other) { } 🔹 …

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: Params collections

Method(params IEnumerable<string> strings)

Parameters: Out variables

Method(out var param)

Parameters: Ref readonly parameters

⌨️ ref readonly

Partial classes

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

Partial constructors

public partial TypeName();

Partial events

public partial event EventHandler? OnEvent;

Partial methods

⌨️ partial TypeName 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: Field

⌨️ public type PropertyName { get; set ⇒ field = 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: 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: Alias any type

using stringset = System.Collections.Generic.HashSet<string>;

Types: Experimental attribute

[Experimental] class MyClass { [Experimental] void Method() { … } }

Types: Pointer aliases

nint or nuint

Types: Primary constructors

class MyClass(int id, string name) { … }

Visibility: File scope

file class MyClass