What is the difference between an expression and a statement in C#? Explain switch expressions, pattern matching and expression-bodied members, and when you would use each.

1. The grammar distinction

The C# grammar has two separate categories: expression and statement. A method body is a list of statements; expressions only appear inside statements (as conditions, initialisers, arguments, or as an expression statement). Since C# 7 the language has been adding expression forms of statement-like constructs:

Why this trend? Expressions are composable (you can nest them), make immutability easy (var x = ... assigned once), and let the compiler reason about completeness.

2. How the compiler lowers a switch expression

The compiler builds a decision DAG (directed acyclic graph) from all the patterns, sharing tests between arms so each input is examined as few times as possible. For example, type tests are done once, property values read once, and constant comparisons may become a jump table (switch IL opcode) or a binary search.

string Describe(object o) => o switch
{
    int n when n < 0 => "negative int",
    int              => "int",
    string { Length: 0 } => "empty string",
    string s         => $"string of {s.Length}",
    null             => "null",
    _                => o.GetType().Name
};

Lowered, this is roughly: one isinst Int32 check, one isinst String check, a single Length read, and branches. Because the DAG is built from all arms, the compiler can also prove subsumption — an arm that can never be reached because an earlier arm covers it is an error (CS8510).

3. Exhaustiveness

The compiler checks whether every possible input value is matched:

• For bool, both true and false must be covered.
• For enums, the compiler requires a discard _ even if you list every named member, because an enum variable can hold any underlying integer ((OrderStatus)99). That is exactly the case SwitchExpressionException protects against.
• For null on reference types, a missing null arm produces a warning when nullable analysis says the input may be null.
• For class hierarchies, C# does not (yet) know a hierarchy is closed, so a _ arm is needed. Discriminated unions are on the language roadmap; until then a common trick is an abstract base with a private constructor and nested sealed subclasses.

4. Patterns in depth

• Type patterns compile to isinst plus a null check — x is Foo f is both safer and faster than as + null check because it is one operation.
• Property patterns call property getters; they are not free if the getter does work. Since C# 10, { Customer.Address.City: "Sydney" } is shorthand for nested property patterns and implicitly null-checks each level.
• Positional patterns call Deconstruct, which records generate automatically.
• Relational and logical patterns combine: is > 0 and < 100 or 999. Precedence is not > and > or; use parentheses.
• List patterns (C# 11) work on any type with Length/Count and an indexer (arrays, List<T>, spans), and a slice pattern .. works with ranges: [var first, .., var last].
• Patterns do not call user-defined == for constant tests on most types; is null is a pure reference check.

5. Expression-bodied members under the hood

public int Count => _items.Count; produces exactly the same IL as public int Count { get { return _items.Count; } }. There is no runtime difference. A subtle trap is confusing

public List<Item> Items => new();      // NEW list on every access!
public List<Item> Items { get; } = new(); // one list created at construction

The first is a computed property that allocates each time and loses any items added; the second is an auto-property with an initialiser.

6. Statements still matter

Some things are only statements: loops, try/catch/finally, using blocks, lock, return, yield. Trying to force everything into expressions (deeply nested ternaries, side effects inside switch-expression arms via helper calls) hurts readability and debugging — you cannot easily set a breakpoint on one arm of a big expression in some IDEs, and stack traces point at a single line.

Try it yourself

1. Write a switch expression over an enum without _, observe CS8509, then call it with (MyEnum)42.
2. Put a broad arm (int) before a specific one (int n when n < 0) and observe CS8510.
3. Paste a switch expression into SharpLab and read the lowered C# to see the decision tree.
4. Rewrite an if/else chain from your own code as a property-pattern switch expression and compare readability.

namespace Basics;

public enum Zone { Metro, Regional, Remote }
public abstract record Shape;
public sealed record Circle(double Radius) : Shape;
public sealed record Rectangle(double Width, double Height) : Shape;
public sealed record Customer(string Country, int Age, bool IsMember);

public static class Expressions
{
    // Tuple pattern + relational patterns
    public static decimal ShippingRate(Zone zone, decimal kg) => (zone, kg) switch
    {
        (_, <= 0m)                 => throw new ArgumentOutOfRangeException(nameof(kg)),
        (Zone.Metro, <= 5m)        => 9.95m,
        (Zone.Metro, _)            => 14.95m,
        (Zone.Regional, <= 5m)     => 14.95m,
        (Zone.Regional, _)         => 24.95m,
        (Zone.Remote, _)           => 39.95m,
        _                          => throw new ArgumentOutOfRangeException(nameof(zone))
    };

    // Type patterns with property patterns
    public static double Area(Shape shape) => shape switch
    {
        Circle { Radius: var r }          => Math.PI * r * r,
        Rectangle { Width: var w, Height: var h } => w * h,
        _ => throw new NotSupportedException(shape.GetType().Name)
    };

    // Property + logical patterns
    public static bool CanBuyAlcohol(Customer c) => c is { Country: "AU", Age: >= 18 };

    // List patterns (C# 11)
    public static string Describe(int[] values) => values switch
    {
        []             => "empty",
        [var only]     => $"one item: {only}",
        [var first, .., var last] => $"{first}..{last}"
    };

    // Statement form where there are side effects
    public static void Process(Customer c)
    {
        if (c is { IsMember: true })
        {
            Console.WriteLine("Apply member discount");
            return;
        }
        Console.WriteLine("Standard pricing");
    }
}