Modern C#

With nullable enabled, string? declares a reference that may hold null, while a plain string is one the compiler treats as never null. Dereferencing a maybe-null value warns (CS8602), as does assigning null to a non-nullable one.

Once. ?. evaluates its receiver a single time and short-circuits on null: nothing else runs — not the getter, not the setter, not GetOrder(). When non-null, the compound assignment reads via get and writes via set, once each.

{ get; set; } is auto-implemented: the compiler emits a hidden backing field, and the accessors write into it and read it back. An expression-bodied => expr property declares a get only, emits no field, and re-evaluates the expression on every read. Both forms compile to accessor methods.

is null is a constant pattern: the compiler lowers it to a direct reference comparison and never calls a user-defined operator ==. x == null invokes that overload when the type declares one, so it can answer differently or even throw. is not null is the negated form.

A raw string literal is delimited by three or more double quotes and needs no escaping: quotes, backslashes and braces stay literal, so JSON, regex and SQL stay readable. In a multi-line one, the closing delimiter's indent is stripped per line.

Target-typed new() takes the type from the assignment target, not the arguments, so you may omit it wherever the target type is known: a field, a typed local, a parameter, a return. With nothing to infer from — var x = new(); — it is an error.

Since C# 9 the entry point may be bare statements at the top of one file, with no class and no Main. The compiler generates the Program class and its Main around them. args and await work inside, and only one file per project may use them.

C# 14 allows ?. and ?[] on the left of an assignment or compound assignment. When customer is null the assignment is skipped and the right-hand side is never evaluated, so GetOrder() is not called. customer?.Order++ remains a compile error.

Nothing is enforced at run time: annotations are metadata, no null checks are emitted, IL is unchanged. At compile time a flow analysis tracks null-state and reports warnings, not errors, so null still arrives from unannotated code or a !.

A collection expression is target-typed: [1, 2, 3] becomes an array, a List<T>, a Span<T> or a type with a CollectionBuilder — whatever the target is — and the compiler picks how to build it. The spread ..other splices its items in place.

An extension(Receiver r) block in a static class names the receiver once and can declare extension properties, static members and operators — not only instance methods. Classic this-parameter methods keep working, and neither form adds state.

field names the compiler-synthesized backing field of the property declared, so one accessor can carry logic while the other stays auto-implemented. It works in get, set and init. Being contextual, it can shadow a variable named field.

Inside a property accessor field now binds to the compiler's backing field, so existing code with an identifier named field in scope can change meaning or stop compiling. Escape it as @field, or qualify a class field with this.field.

C# 14 makes span conversions language-level: they work for extension receivers and type inference. Widening only — T[] → Span<T>/ReadOnlySpan<T>, Span<T> → ReadOnlySpan<T>, string → ReadOnlySpan<char>. Never back to Span<T> or T[].

Two halves: .NET 7's System.Numerics interfaces — notably INumber<T> — abstract the operators, and C# 11's static abstract interface members let an interface demand them. One generic method constrained on INumber<T> then sums any numeric T.

A source generator runs inside the compiler and emits ordinary C#: the serializer's code is real, analysable source with no start-up metadata build. Reflection finds types at run time, so the trimmer cannot see usage and AOT has nothing to compile.