Your Quick Guide to Pattern Matching in C#

Last Updated on September 13, 2023 by Aram

Pattern matching in C# is a feature used to test expressions for some conditions while testing their types.

Generally, Pattern matching is a functional programming feature that already exists in other popular languages such as Scala, Rust, Python, Haskell, Prolog and many other languages.

Pattern Matching was introduced in C# 7, and ever since it has been receiving many updates over the subsequent major releases

This guide will help you learn more about the types of pattern matching with a usage example for each type.

Remember, you can only apply pattern matching within either ‘is’ expressions or switch expressions.

Benefits of Pattern matching in C#

Type-Testing

Nullable-type checking

Type casting and assignment

High readability

Concise syntax

Less convoluted code

So let’s get started with the different types of pattern matching in C#

C# 7

Type Pattern

Type-testing for the expression

public bool IsProductFood(object product)
{
    return product is FoodModel;
}

public bool IsProductFood(object product)

{

return product is FoodModel;

}

Declaration Pattern

Type-testing as well as assignment to variable after a successful match of the expression

public bool IsProductFoodThatRequiresRefrigeration(object product)
{
    return product is FoodModel food &&
           RequiresRefrigeration(food.StorageTemperature);
}

public bool IsProductFoodThatRequiresRefrigeration(object product)

{

return product is FoodModel food &&

RequiresRefrigeration(food.StorageTemperature);

}

Constant Pattern

Testing versus a constant value which can include int, float, char, string, bool, enum, field declared with const, null

public bool IsFreshProduce(FoodModel food)
{
    return food?.Category?.ID is (int) ProductCategoryEnum.FreshProduce;
}

public bool IsFreshProduce(FoodModel food)

{

return food?.Category?.ID is (int) ProductCategoryEnum.FreshProduce;

}

Null Pattern

Check if a reference or nullable type is null

public bool FoodDoesNotExist(FoodModel food)
{
    return food is null;
}

public bool FoodDoesNotExist(FoodModel food)

{

return food is null;

}

Var Pattern

Similar to the type pattern, the var pattern matches an expression and checks for null, as well as assigns a value to the variable.

The var type is declared based on the matched expression’s compile-time type.

public bool IsProductFoodThatRequiresRefrigeration(FoodModel food)
{
    return GetFoodStorageRequirements(food) is var storageRequirement &&
           storageRequirement is StorageRequirementEnum.Freezer;
}

public bool IsProductFoodThatRequiresRefrigeration(FoodModel food)

{

return GetFoodStorageRequirements(food) is var storageRequirement &&

storageRequirement is StorageRequirementEnum.Freezer;

}

C# 8

Property Pattern

It is a highly usable type of pattern matching where you can incorporate object members rather than variables to match the given conditions.

It can be easily used with the other pattern matching types, such as the relative pattern, pattern combinators and many other patterns to build flexible and powerful logical expressions.

public bool IsOrganicFood(FoodModel food)
{
    return food is
    {
        NonGMO: true,
        NoChemicalFertilizers: true,
        NoSyntheticPesticides: true
    };
}

public bool IsOrganicFood(FoodModel food)

{

return food is

{

NonGMO: true,

NoChemicalFertilizers: true,

NoSyntheticPesticides: true

};

}

Usage of nested properties was available in C# 8 along with C# 9, but implementing it was not the cleanest solution or the most concise syntax.

Discard Pattern

Pattern matching with the discard operator _ matches anything including null, its use shines in the new switch expressions, to match the default or else case. In the below example, if the food’s storage temperature was not provided or the number doesn’t match the below ranges, then a custom exception will be thrown:

public int GetFoodStorageTemperature(StorageRequirementEnum storageRequirement) => storageRequirement switch
{
    StorageRequirementEnum.Freezer => -18,
    StorageRequirementEnum.Refrigerator => 4,
    StorageRequirementEnum.RoomTemperature => 25,
    _ => throw new InvalidStorageRequirementException()
};

public int GetFoodStorageTemperature(StorageRequirementEnum storageRequirement) => storageRequirement switch

{

StorageRequirementEnum.Freezer => -18,

StorageRequirementEnum.Refrigerator => 4,

StorageRequirementEnum.RoomTemperature => 25,

_ => throw new InvalidStorageRequirementException()

};

Positional Pattern

Mainly used with struct types, leverages a type’s deconstrutor to match a pattern according to the values position in the deconstructor

Notice we are also using the discard pattern to ignore the value of currency, since anything that has zero value, regardlress of the currency, should be free.

public bool IsFreeFood(FoodModel food)
{
    return food.Price is (0, _);
}

public bool IsFreeFood(FoodModel food)

{

return food.Price is (0, _);

}

Tuple Pattern

A special derivation from the positional pattern where you can test multiple properties of a type in the same expression

public string GetFoodDescription(FoodModel food) => (food.NonGMO, food.Category.ID) switch
{
    (true, (int)ProductCategoryEnum.FreshProduce) => "Non-GMO Fresh Product",
    (true, (int)ProductCategoryEnum.Dairy) => "Non-GMO Dairy",
    (false, (int)ProductCategoryEnum.Meats) => "GMO Meats. Avoid!",
    (_, _) => "Invalid Food Group"
};

public string GetFoodDescription(FoodModel food) => (food.NonGMO, food.Category.ID) switch

{

(true, (int)ProductCategoryEnum.FreshProduce) => "Non-GMO Fresh Product",

(true, (int)ProductCategoryEnum.Dairy) => "Non-GMO Dairy",

(false, (int)ProductCategoryEnum.Meats) => "GMO Meats. Avoid!",

(_, _) => "Invalid Food Group"

};

C# 9

‘Enhanced’ Type Pattern

You can do type checking in switch expressions without using the discards with each type

public string CheckValueType(object value) => value switch
{
    int => "This is an integer number",
    decimal => "This is a decimal number",
    double => "This is a double number",
    _ => throw new InvalidNumberException(value)
};
public class InvalidNumberException : Exception
{
    public InvalidNumberException(object value) : base($"Invalid number {value}")
    { }
}

public string CheckValueType(object value) => value switch

{

int => "This is an integer number",

decimal => "This is a decimal number",

double => "This is a double number",

_ => throw new InvalidNumberException(value)

};

public class InvalidNumberException : Exception

{

public InvalidNumberException(object value) : base($"Invalid number {value}")

{ }

}

Relational Pattern

Introduced in C# 9, a relational pattern allows applying the relational operators > < >= <= to match patterns versus constants or enum values

public StorageRequirementEnum GetFoodStorageRequirements(FoodModel food) => food.StorageTemperature switch
{
    <= -18 => StorageRequirementEnum.Freezer,
    >= 2 and < 6 => StorageRequirementEnum.Refrigerator,
    > 6 and < 30 => StorageRequirementEnum.RoomTemperature,
    _ => throw new InvalidStorageRequirementException(food.StorageTemperature)
};

public StorageRequirementEnum GetFoodStorageRequirements(FoodModel food) => food.StorageTemperature switch

{

<= -18 => StorageRequirementEnum.Freezer,

>= 2 and < 6 => StorageRequirementEnum.Refrigerator,

> 6 and < 30 => StorageRequirementEnum.RoomTemperature,

_ => throw new InvalidStorageRequirementException(food.StorageTemperature)

};

Logical Pattern

This represents the set of negation, conjunctive, disjunctive; not, and, or respectively. Together these are called the pattern combinators

These are used to combine patterns and apply logical conditions on them

public bool RequiresRefrigeration(ProductCategoryEnum productType)
{
    return productType is ProductCategoryEnum.Dairy or ProductCategoryEnum.Meats;
}

public bool RequiresRefrigeration(ProductCategoryEnum productType)

{

return productType is ProductCategoryEnum.Dairy or ProductCategoryEnum.Meats;

}

Negated Null Constant Pattern

Checks expression for not null value

public bool BlogExists(BlogModel blog)
{
    return blog is not null;
}

public bool BlogExists(BlogModel blog)

{

return blog is not null;

}

Parenthesized Pattern

This allows the use of parenthesis to control the order of execution and to group logical expressions together. It can be used with any type of pattern, but its usage is mainly associated with the use of pattern combinators

public bool RequiresRefrigeration(int storageTemperature)
{
    return storageTemperature is > 1 and (< 6);
}

public bool RequiresRefrigeration(int storageTemperature)

{

return storageTemperature is > 1 and (< 6);

}

C# 10

Extended Property Pattern

In C# 10, the nested properties matching syntax issue was addressed.

With the introduction of the Extended Property Pattern, syntax to use nested properties in pattern matching is now clean and concise.

public bool RequiresRefrigeration(FoodModel food)
{
    return food is
    {
        Category.ID: (int)ProductCategoryEnum.Dairy or
                     (int)ProductCategoryEnum.Meats
    };
}

public bool RequiresRefrigeration(FoodModel food)

{

return food is

{

Category.ID: (int)ProductCategoryEnum.Dairy or

(int)ProductCategoryEnum.Meats

};

}

C# 11

List Pattern

The list matching pattern is the latest addition to the great set of pattern matching in C#, with list pattern you can match a list or an array with a set of sequential elements

You can mix it with discard, pattern combinators, range, var, type assignemnt patterns to build very flexible and powerful list pattern matching

public (int?, int?) FindNumberOneAndNumberFour()
{
    int[] numbers = { 1, 2, 3, 4, 5 };
    // Match if 2nd value is anything, 3rd is greater than or equal 3, fifth is 5
    if (numbers is [var numberOne, _, >= 3, int numberFour, 5])
    {
        return (numberOne, numberFour);
    }
    return (null, null);
}

public (int?, int?) FindNumberOneAndNumberFour()

{

int[] numbers = { 1, 2, 3, 4, 5 };

// Match if 2nd value is anything, 3rd is greater than or equal 3, fifth is 5

if (numbers is [var numberOne, _, >= 3, int numberFour, 5])

{

return (numberOne, numberFour);

}

return (null, null);

}

Too Long; Didn’t Read

Summary

During the recent few years, C# has been receiving lots of language features to help developers build solid and reliable application on a diverse range of platforms.

With the addition of the pattern matching features, C# has added a great functional programming capability that has been being used for decades throughout a multitude of programming languages.

Of course, you always need to remain cautious not to over-use the pattern matching.

Mainly if you are working on a large project with other team members, remember that not everyone would be aware about some or all of the pattern matching features, so you don’t want to suddenly introduce too many of these.

This article gave a quick and complete overview of all the pattern matching types added in C#.

Let me know if you found it useful and if you have any comment.

References

To learn more about Pattern Matching in C#, you can check these references:

https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/functional/pattern-matching

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns

https://code-maze.com/csharp-pattern-matching/

.NET Learning Resources

As part of my learning journey I always try to assign some time to write and share content with anyone who is interested to learn.

Please feel free to connect with me LinkedIn, I do regularly share content mainly in .NET and C#.

Also you can always read any of my tutorials in this blog, here are some examples:

Collaborations and Sponsorships

If you want to learn about the available opportunities to collaborate and work together, please check this page:

https://codingsonata.com/sponsorships-and-collaborations/

Bonus

Enjoy the romantic piano tunes of the brilliant classical/romantic era music virtuoso, Frédéric Chopin.

Chopin, Waltz in A minor, B 150, Op. Posth

4 Comments on “Your Quick Guide to Pattern Matching in C#”

Pingback: The Morning Brew - Chris Alcock » The Morning Brew #3778
Pingback: Guia rápido para correspondência de padrões em C# – linux-BR.org
Pingback: C＃模式匹配快速指南 - 偏执的码农
Igor says:

October 25, 2023 at 2:10 pm

Very nice article! One notice: var-pattern doesn’t check the null (o is var stillNullableValue), it does object-pattern (o is { } nonNullValue)

Your Quick Guide to Pattern Matching in C#

Benefits of Pattern matching in C#

So let’s get started with the different types of pattern matching in C#

C# 7

Type Pattern

Declaration Pattern

Constant Pattern

Null Pattern

Var Pattern

C# 8

Property Pattern

Discard Pattern

Positional Pattern

Tuple Pattern

C# 9

‘Enhanced’ Type Pattern

Relational Pattern

Logical Pattern

Negated Null Constant Pattern

Parenthesized Pattern

C# 10

Extended Property Pattern

C# 11

List Pattern

Too Long; Didn’t Read

Summary

References

.NET Learning Resources

Collaborations and Sponsorships

Bonus

Like this:

Related

4 Comments on “Your Quick Guide to Pattern Matching in C#”

Leave a ReplyCancel reply

Benefits of Pattern matching in C#

So let’s get started with the different types of pattern matching in C#

C# 7

Type Pattern

Declaration Pattern

Constant Pattern

Null Pattern

Var Pattern

C# 8

Property Pattern

Discard Pattern

Positional Pattern

Tuple Pattern

C# 9

‘Enhanced’ Type Pattern

Relational Pattern

Logical Pattern

Negated Null Constant Pattern

Parenthesized Pattern

C# 10

Extended Property Pattern

C# 11

List Pattern

Too Long; Didn’t Read

Summary

References

.NET Learning Resources

Collaborations and Sponsorships

Bonus

Share this:

Like this:

Related

4 Comments on “Your Quick Guide to Pattern Matching in C#”

Leave a ReplyCancel reply