.CS File Format – Expressions

Operator precedence

Highest first. Operators in one row have the same precedence (clause 12.4.2).

Arithmetic and shift operators

• Integer division truncates towards zero. The remainder has the sign of the left operand, and a % b is a - (a / b) * b.
• Integer division by zero throws DivideByZeroException. Floating-point division by zero gives an infinity or NaN.
• Smaller integer types are promoted to int first (clause 12.4.7), so byte + byte is an int. If one operand is decimal, the other must be convertible to it; it cannot mix with float or double.
• << shifts left. >> is arithmetic for signed types and logical for unsigned. >>> (C# 11) is always logical. Shift counts are masked: only the low 5 bits for 32-bit operands, and the low 6 bits for 64-bit ones.
• + on strings concatenates, and treats null as empty.
• ++ and -- have a prefix form that returns the new value and a postfix form that returns the old one.

Comparison and logical operators

• == compares values for value types and strings, and references for other reference types, unless a type overloads it.
• &, | and ^ work bitwise on integers and enums, and logically on bool, always evaluating both operands.
• && and || skip the right operand if the left one decides the result.
• A NaN compares false with everything, including itself; only != gives true.

x is string s;            // pattern test, with a new variable
x is null;                // never calls a user-defined ==
var t = x as string;      // the value, or null if the type is wrong
var u = (string)x;        // throws InvalidCastException if the type is wrong

Null operators

int? len = name?.Length;
string text = input ?? "none";
list ??= new List<int>();
handler?.Invoke();
customer?.Order = GetCurrentOrder();    // C# 14

Null-conditional assignment also works with compound assignment such as +=, but not with ++ or --. A chain stops at the first null: in a?.b.c, nothing after a null a is evaluated (clause 12.8.8).

Primary expressions

new Person("Ann");
new Person("Ann") { Age = 30 };              // object initialiser
new List<int> { 1, 2, 3 };                  // collection initialiser
new Dictionary<string, int> { ["a"] = 1 };   // index initialiser, C# 6
new { X = 1, Y = 2 };                        // anonymous type

Collection expressions

A collection expression (C# 12, clause 12.8.25) lists elements in square brackets. It needs a target type and has no type of its own.

int[] a = [1, 2, 3];
List<string> b = ["x", "y"];
Span<int> c = [1, 2];
IEnumerable<int> d = [];
int[] e = [.. a, 4, .. a];          // spread

• Targets are arrays, Span<T> and ReadOnlySpan<T>, types with a collection initialiser, types with a builder named by [CollectionBuilder], and the interfaces IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T> and IList<T>.
• ..x is a spread element; x must be enumerable with foreach.
• A collection expression is not a constant, and always creates a collection holding every element. It cannot be lazy.

List<string> names = [with(capacity: values.Length * 2), .. values];
HashSet<string> set = [with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO"];

Ranges and indices

^x gives an index from the end, and x..y gives a range from x up to but not including y (C# 8, clauses 12.9.6, 12.11 and 18). They produce values of System.Index and System.Range.

int[] a = { 0, 1, 2, 3, 4 };
a[^1];        // 4, the last element
a[1..3];      // { 1, 2 }
a[..2];       // { 0, 1 }
a[3..];       // { 3, 4 }
a[..^1];      // all except the last
a[..];        // all

Range r = 1..^1;

Types get these through their members, without declaring Index or Range overloads (clause 18.4): a Length or Count property with an integer indexer supports ^, and adding Slice(int, int) supports ranges. A range of an array makes a copy, and a range of a string makes a new string. A range of a span gives a slice. Since C# 13, ^ can also be used in object initialisers.

With expressions

x with { Member = value } copies a value and sets some members (C# 9, clause 12.10). It works on records and, since C# 10, on any struct and anonymous type.

Conditional expressions

c ? a : b evaluates only one branch. Branches may be refs, with ref on each (C# 7.2). If the branches share no natural type, the expression can take its type from the target (C# 9, clause 12.21).

Deconstruction

A deconstruction splits a tuple, or any type with a Deconstruct method, into variables (C# 7.0, clauses 12.7 and 12.24.3).

var (a, b) = (1, 2);
(int x, string y) = GetPair();
(x, _) = GetPair();
int z;
(z, var w) = GetPair();     // mixed, C# 10

public void Deconstruct(out int x, out int y) => (x, y) = (X, Y);

Assignment

x = y stores a value and is itself an expression. x op= y is shorthand for x = x op y with x evaluated once. Since C# 14 a type can overload a compound assignment directly. x = ref y makes a ref variable refer to a different target (clause 12.24.4).

Lambda expressions

A lambda (C# 3, clause 12.22) is an anonymous function. It converts to a delegate, or to an expression tree.

Func<int, int> a = x => x * 2;
Func<int, int, int> b = (x, y) => x + y;
Action c = () => Console.WriteLine("hi");
Func<int, int> d = x => { var y = x * 2; return y; };
Func<int, Task<int>> e = async x => await Task.FromResult(x);
Func<int, int> f = static x => x + 1;     // cannot capture, C# 9
Func<int, int, int> g = (_, _) => 0;      // discard parameters, C# 9

• A lambda can capture local variables and parameters of the enclosing method (clause 12.22.6). The capture is of the variable, not its value. Since C# 5 the variable of a foreach is a new one in each iteration.
• A lambda has a natural type when its parameters and return type can be determined. It then becomes a Func or Action type, or a compiler-synthesised delegate.
• A params modifier still needs an explicitly typed parameter list.
• An expression tree (Expression<Func<int, int>>, clause 8.6) represents the lambda as data, so a library such as a database provider can translate it.

Query expressions

A query expression (C# 3, clause 12.23) is a syntax for filtering, ordering and transforming data. The compiler translates it into method calls such as Where and Select, so it works on any type with those methods. The library methods come from System.Linq.

var names =
    from p in people
    where p.Age >= 18
    orderby p.Name descending
    select p.Name;

// the compiler translates the query above into:
var names2 = people.Where(p => p.Age >= 18)
                   .OrderByDescending(p => p.Name)
                   .Select(p => p.Name);

Queries are usually lazy: they run when the result is enumerated, and they run again each time it is. Calling ToList() or ToArray() runs a query once.

Constant expressions

A constant expression is fully evaluated at compile time (clause 12.26). It may use literals, const names, enum members, default, nameof, sizeof of built-in types, and the operators on those. String constants may be joined, and an interpolated string of constant strings is also constant (C# 10). Overflow in a constant expression is a compile-time error, unless it is written inside unchecked.