Positional patterns in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Positional patterns

Input value

↓

Match with positional pattern

↓

Extract parts

↓

Use extracted parts

↓

Execute matched case block

↓

Output or result

Positional patterns check the shape of data and extract parts to use in code, then run matching case blocks.

Execution Sample

C Sharp (C#)

record Point(int X, int Y);

Point p = new(3, 4);

string result = p switch
{
    (0, 0) => "Origin",
    (var x, 0) => $"X={x} on X-axis",
    (0, var y) => $"Y={y} on Y-axis",
    (var x, var y) => $"Point at ({x},{y})"
};

This code matches a Point record with positional patterns and returns a string describing its position.

Execution Table

Step	Input	Pattern Matched	Extracted Variables	Action	Output
1	Point(3,4)	(0,0)	none	No match, try next
2	Point(3,4)	(var x, 0)	x=3	Y is not 0, no match
3	Point(3,4)	(0, var y)	y=4	X is not 0, no match
4	Point(3,4)	(var x, var y)	x=3, y=4	Match, create string	Point at (3,4)

💡 All patterns checked; last pattern matches and execution stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
p	Point(3,4)	Point(3,4)	Point(3,4)	Point(3,4)	Point(3,4)	Point(3,4)
x	undefined	undefined	3	undefined	3	3
y	undefined	undefined	undefined	4	4	4
result	undefined	undefined	undefined	undefined	Point at (3,4)	Point at (3,4)

Key Moments - 2 Insights

Why does the pattern (var x, 0) not match when Y is 4?

Because the pattern requires the second value to be exactly 0, but Y is 4, so it fails as shown in step 2 of the execution_table.

What happens if no positional pattern matches?

The switch expression would not compile (non-exhaustive patterns); here, the last pattern (var x, var y) matches anything, ensuring a result as in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'x' when the pattern (var x, 0) is checked?

A 3

B 0

C undefined

D 4

💡 Hint

Check the 'Extracted Variables' column at step 2 in the execution_table.

At which step does the pattern match successfully?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at the 'Pattern Matched' and 'Action' columns to see when the match happens.

If the point was (0,0), which pattern would match first?

A (var x, var y)

B (var x, 0)

C (0, 0)

D (0, var y)

💡 Hint

Refer to the order of patterns in the code and the execution_table logic.

Concept Snapshot

Positional patterns match data by shape and extract parts.
Syntax: (var1, var2, ...)
Used in switch or is expressions.
Matches in order; first match runs.
Extracted variables can be used in code block.

Full Transcript

This example shows how positional patterns in C# match a Point record's X and Y values. The switch expression tries each pattern in order. It first checks if the point is at the origin (0,0). If not, it checks if Y is zero, then if X is zero. Finally, it matches any point and extracts X and Y. Variables x and y get values only when their pattern matches. The output string describes the point's position based on the matched pattern.

Practice

1.

What is the main purpose of positional patterns in C#?

record Point(int X, int Y);
Using case Point(var x, var y): inside a switch statement helps to:

easy

A. Extract values of X and Y from a Point object easily

B. Create a new Point object with given X and Y

C. Change the values of X and Y in the Point object

D. Call a method named Deconstruct on the Point object

Solution

1. Step 1: Understand positional pattern usage

   Positional patterns allow matching an object and extracting its parts in one step, like case Point(var x, var y):.

2. Step 2: Identify what the pattern does with Point

   It extracts the X and Y values from the Point object into variables x and y for use inside the case block.

3. Final Answer:

   Extract values of X and Y from a Point object easily -> Option A

4. Quick Check:

   Positional pattern extracts values [OK]

Hint: Positional patterns extract parts of an object [OK]

Common Mistakes:

• Thinking positional patterns create or modify objects
• Confusing Deconstruct method call with pattern matching
• Assuming positional patterns only check types without extracting

2.

Which of the following is the correct syntax for using a positional pattern with a record Person(string Name, int Age) inside a switch expression?

switch(person) {
    case ???:
        // code
        break;
}

easy

A. Person(var name, var age)

B. Person[name, age]

C. Person{name, age}

D. Person(name: name, age: age)

Solution

1. Step 1: Recall positional pattern syntax

   Positional patterns use parentheses with variables: Type(var1, var2).

2. Step 2: Match syntax to options

   Person(var name, var age) uses parentheses and variables correctly: Person(var name, var age). Others use invalid syntax for positional patterns.

3. Final Answer:

   Person(var name, var age) -> Option A

4. Quick Check:

   Positional pattern syntax uses parentheses [OK]

Hint: Positional patterns always use parentheses, not brackets or braces [OK]

Common Mistakes:

• Using square brackets or curly braces instead of parentheses
• Trying to use named arguments syntax inside patterns
• Omitting var keyword or variable names

3.

What is the output of the following code?

record Point(int X, int Y);

var p = new Point(3, 4);
switch (p)
{
    case Point(0, 0):
        Console.WriteLine("Origin");
        break;
    case Point(var x, var y) when x == y:
        Console.WriteLine("On diagonal");
        break;
    case Point(var x, var y):
        Console.WriteLine($"Point at ({x}, {y})");
        break;
}

medium

A. Origin

B. Point at (3, 4)

C. On diagonal

D. No output

Solution

1. Step 1: Check first case Point(0, 0)

   p is (3,4), so it does not match (0,0).

2. Step 2: Check second case with condition x == y

   x=3, y=4, so x != y; condition fails.

3. Step 3: Third case matches any Point and prints coordinates

   It matches and prints "Point at (3, 4)".

4. Final Answer:

   Point at (3, 4) -> Option B

5. Quick Check:

   Pattern matches last case with output [OK]

Hint: Check cases top to bottom; first match runs [OK]

Common Mistakes:

• Assuming (3,4) matches (0,0)
• Ignoring the when condition in second case
• Thinking no case matches and no output

4.

Identify the error in this code snippet using positional patterns:

record Rectangle(int Width, int Height);

var rect = new Rectangle(5, 10);
switch(rect)
{
    case Rectangle(var w, var h):
        Console.WriteLine($"Width: {w}, Height: {h}");
        break;
    case Rectangle(w, h):
        Console.WriteLine("Invalid pattern");
        break;
}

medium

A. Switch expression cannot use records

B. First case should use named arguments instead of positional pattern

C. Second case uses variables without var keyword, causing a syntax error

D. No error, code runs fine

Solution

1. Step 1: Review positional pattern variable declaration

   Variables in positional patterns must be declared with var or a type.

2. Step 2: Identify error in second case

   Second case uses Rectangle(w, h) without var, which is invalid syntax.

3. Final Answer:

   Second case uses variables without var keyword, causing a syntax error -> Option C

4. Quick Check:

   Variables need var keyword in patterns [OK]

Hint: Always declare variables with var in positional patterns [OK]

Common Mistakes:

• Omitting var keyword for variables in patterns
• Thinking records can't be used in switch
• Confusing named arguments with pattern variables

5.

Given the record Person(string Name, int Age), write a switch expression using positional patterns that returns:

• "Child" if Age < 13
• "Teen" if Age is between 13 and 19 inclusive
• "Adult" otherwise

Which of the following switch expressions correctly implements this?

hard

A. person switch {
Person(_, var age) when age < 13 => "Child",
Person(_, var age) when age > 13 && age <= 19 => "Teen",
Person(_, _) => "Adult"
};

B. person switch {
Person(var name, var age) when age < 13 => "Child",
Person(var name, var age) when age > 13 && age < 19 => "Teen",
_ => "Adult"
};

C. person switch {
Person(var name, var age) when age <= 13 => "Child",
Person(var name, var age) when age >= 13 && age <= 19 => "Teen",
Person(var name, var age) => "Adult"
};

D. person switch {
Person(var name, var age) when age < 13 => "Child",
Person(var name, var age) when age >= 13 && age <= 19 => "Teen",
Person(var name, var age) => "Adult"
};

Solution

1. Step 1: Check age ranges and conditions

   Child: age < 13, Teen: 13 ≤ age ≤ 19, Adult: otherwise.

2. Step 2: Analyze each option's conditions

   person switch { Person(var name, var age) when age < 13 => "Child", Person(var name, var age) when age >= 13 && age <= 19 => "Teen", Person(var name, var age) => "Adult" }; correctly uses age < 13 for Child, age >= 13 && age <= 19 for Teen, and default Adult case. person switch { Person(_, var age) when age < 13 => "Child", Person(_, var age) when age > 13 && age <= 19 => "Teen", Person(_, _) => "Adult" }; misses age=13 (falls to Adult) because Teen condition uses > 13. person switch { Person(var name, var age) when age < 13 => "Child", Person(var name, var age) when age > 13 && age < 19 => "Teen", _ => "Adult" }; excludes age == 13 and 19 for Teen. person switch { Person(var name, var age) when age <= 13 => "Child", Person(var name, var age) when age >= 13 && age <= 19 => "Teen", Person(var name, var age) => "Adult" }; overlaps Child and Teen at age 13.

3. Step 3: Confirm the correct implementation

   person switch { Person(var name, var age) when age < 13 => "Child", Person(var name, var age) when age >= 13 && age <= 19 => "Teen", Person(var name, var age) => "Adult" }; matches all conditions correctly and clearly.

4. Final Answer:

   Option D code correctly implements the age groups -> Option D

5. Quick Check:

   Check age ranges carefully in when clauses [OK]

Hint: Check boundary conditions carefully in when clauses [OK]

Common Mistakes:

• Overlapping or missing age boundaries
• Using _ wildcard instead of variables when needed
• Incorrect logical operators in conditions