C# 7 finally introduced a long-awaited feature called “pattern matching”. If you’re familiar with functional languages like F# you may be slightly disappointed with this feature in its current state, but even today it can simplify your code in a variety of different scenarios.<\/p>\n
Every new feature is fraught with danger for a developer working on a performance critical application. New levels of abstractions are good but in order to use them effectively, you should know what is happening under the hood. Today we’re going to explore pattern matching and look under the covers to understand how it is implemented.<\/p>\n
The C# language introduced the notion of a pattern that can be used in There are 3 types of patterns:<\/p>\n I’ve found few interesting aspects related to pattern matching in Let’s check the first two cases first:<\/p>\n The first The variable introduced in the The third aspect mentioned above is the most concerning one. Consider the following code:<\/p>\n In most cases the This code causes 2 boxing allocations that can reasonable affect performance if used in the application’s critical path. It used to be the case that If the The (*) It is not clear why the behavior is different in the Release mode only. But I think all the issues falls into the same bucket: the initial implementation of the feature is suboptimal. But based on this comment<\/a> by Neal Gafter, this is going to change: “The pattern-matching lowering code is being rewritten from scratch (to support recursive patterns, too). I expect most of the improvements you seek here will come for “free” in the new code. But it will be some time before that rewrite is ready for prime time.”.<\/p>\n The lack of There is another use case that I’ve found very useful. The type pattern matches the value only when the value is not Note, that the same pattern can be used for both – value types and reference types.<\/p>\n C# 7 extends the switch statement to use patterns in the case clauses:<\/p>\n The example shows the first set of changes to the switch statement.<\/p>\n (**) The very last case clause shows another feature added to C# 7 called “discard” pattern. The name The next snippet shows another feature of the switch-based pattern matching – an ability to use predicates:<\/p>\n This is a weird version of the FizzBuzz<\/a> problem that processes an A switch can have more than one case clause with the same type. If this happens the compiler groups together all type checks to avoid redundant computations:<\/p>\n But there are two things to keep in mind:<\/p>\n The compiler will translate it effectively to the following:<\/p>\n But compiler doesn’t know that one predicate is stronger than the other and effectively supersedes the next cases:<\/p>\n <\/p>\n Discussions on reddit<\/a> and hacker news<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":" C# 7 finally introduced a long-awaited feature called “pattern matching”. If you’re familiar with functional languages like F# you may be slightly disappointed with this feature in its current state, but even today it can simplify your code in a variety of different scenarios. Every new feature is fraught with danger for a developer working […]<\/p>\n","protected":false},"author":4004,"featured_media":37840,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[6699],"tags":[6695],"class_list":["post-1035","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c","tag-seteplia"],"acf":[],"blog_post_summary":" C# 7 finally introduced a long-awaited feature called “pattern matching”. If you’re familiar with functional languages like F# you may be slightly disappointed with this feature in its current state, but even today it can simplify your code in a variety of different scenarios. Every new feature is fraught with danger for a developer working […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/posts\/1035","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/users\/4004"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/comments?post=1035"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/posts\/1035\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/media\/37840"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/media?parent=1035"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/categories?post=1035"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/premier-developer\/wp-json\/wp\/v2\/tags?post=1035"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}is<\/code>-expression and inside a case<\/code> block of a switch<\/code> statement.<\/p>\n\n
var<\/code> pattern<\/li>\n<\/ul>\nPattern matching in
is<\/code>-expressions<\/h4>\npublic void IsExpressions(object o)\r\n{\r\n \/\/ Alternative way checking for null\r\n if (o is null) Console.WriteLine(\"o is null\");\r\n \r\n \/\/ Const pattern can refer to a constant value\r\n const double value = double.NaN;\r\n if (o is value) Console.WriteLine(\"o is value\");\r\n \r\n \/\/ Const pattern can use a string literal\r\n if (o is \"o\") Console.WriteLine(\"o is \\\"o\\\"\");\r\n \r\n \/\/ Type pattern\r\n if (o is int n) Console.WriteLine(n);\r\n \r\n \/\/ Type pattern and compound expressions\r\n if (o is string s && s.Trim() != string.Empty)\r\n Console.WriteLine(\"o is not blank\");\r\n}<\/pre>\nis<\/code>-expression can check if the value is equal to a constant and a type check can optionally specify the pattern variable<\/strong>.<\/p>\nis<\/code>-expressions:<\/p>\n\n
if<\/code> statement is lifted to the outer scope.<\/li>\nif<\/code> statement is definitely assigned only when the pattern is matched.<\/li>\nis<\/code>-expressions is not very efficient.<\/li>\n<\/ul>\npublic void ScopeAndDefiniteAssigning(object o)\r\n{\r\n if (o is string s && s.Length != 0)\r\n {\r\n Console.WriteLine(\"o is not empty string\");\r\n }\r\n \r\n \/\/ Can't use 's' any more. 's' is already declared in the current scope.\r\n if (o is int n || (o is string s2 && int.TryParse(s2, out n)))\r\n {\r\n Console.WriteLine(n);\r\n }\r\n}<\/pre>\nif<\/code> statement introduces a variable s<\/code> and the variable is visible inside the whole method. This is reasonable but will complicate the logic if the other if-statements in the same block will try to reuse the same name once again. In this case, you have<\/strong> to use another name to avoid the collision.<\/p>\nis<\/code>-expression is definitely assigned only when the predicate is true<\/code>. It means that the n<\/code> variable in the second if-statement is not assigned in the right operand but because the variable is already declared we can use it as the out<\/code> variable in the int.TryParse<\/code> method.<\/p>\npublic void BoxTwice(int n)\r\n{\r\n if (n is 42) Console.WriteLine(\"n is 42\");\r\n}<\/pre>\nis<\/code>-expression is translated to the object.Equals(constValue, variable)<\/code> (even though the spec says that operator==<\/code> should be used for primitive types):<\/p>\npublic void BoxTwice(int n)\r\n{\r\n if (object.Equals(42, n))\r\n {\r\n Console.WriteLine(\"n is 42\");\r\n }\r\n}<\/pre>\no is null<\/code>was causing the boxing allocation if o<\/code> is a nullable value type (see Suboptimal code for e is null<\/a>) so I really hope that this behavior will be fixed (here is an issue on github<\/a>).<\/p>\nn<\/code> variable is of type object<\/code> the o is 42<\/code> will cause one boxing allocation (for the literal 42<\/code>), even though the similar switch-based code would not cause any allocations.<\/p>\nThe
var<\/code> patterns in is<\/code>-expressions<\/h4>\nvar<\/code> pattern is a special case of the type pattern with one major distinction: the pattern will match any value, even if the value is null<\/code>.<\/p>\npublic void IsVar(object o)\r\n{\r\n if (o is var x) Console.WriteLine($\"x: {x}\");\r\n}<\/pre>\no is object<\/code> is true<\/code> when o<\/code> is not null<\/code>, but o is var x<\/code> is always true<\/code>. The compiler knows about that and in the Release mode (*), it removes the if-clause altogether and just leaves the Console<\/code> method call. Unfortunately, the compiler does not warn you that the code is unreachable in the following case: if (!(o is var x)) Console.WriteLine(\"Unreachable\")<\/code>. Hopefully, this will be fixed as well.<\/p>\nnull<\/code> check makes this case very special and potentially dangerous. But if you know what exactly is going on you may find this pattern useful. It can be used for introducing a temporary variable inside the expression:<\/p>\nIs<\/code>-expression meets “Elvis” operator<\/h4>\nnull<\/code>. We can use this “filtering” logic with the null-propagating operator to make a code easier to read:<\/p>\npublic void WithNullPropagation(IEnumerable<string> s)\r\n{\r\n if (s?.FirstOrDefault(str => str.Length > 10)?.Length is int length)\r\n {\r\n Console.WriteLine(length);\r\n }\r\n \r\n \/\/ Similar to\r\n if (s?.FirstOrDefault(str => str.Length > 10)?.Length is var length2 && length2 != null)\r\n {\r\n Console.WriteLine(length2);\r\n }\r\n \r\n \/\/ And similar to\r\n var length3 = s?.FirstOrDefault(str => str.Length > 10)?.Length;\r\n if (length3 != null)\r\n {\r\n Console.WriteLine(length3);\r\n }\r\n}<\/pre>\nPattern matching in the
case<\/code> blocks<\/h4>\npublic static int Count<T>(this IEnumerable<T> e)\r\n{\r\n switch (e)\r\n {\r\n case ICollection<T> c: return c.Count;\r\n case IReadOnlyCollection<T> c: return c.Count;\r\n \/\/ Matches concurrent collections\r\n case IProducerConsumerCollection<T> pc: return pc.Count;\r\n \/\/ Matches if e is not null\r\n case IEnumerable<T> _: return e.Count();\r\n \/\/ Default case is handled when e is null\r\n default: return 0;\r\n }\r\n}<\/pre>\n\n
null<\/code>.<\/li>\n<\/ol>\n_<\/code> is special and tells the compiler that the variable is not needed. The type pattern in a case clause requires an alias and if you don’t need it you can ignore it using _<\/code>.<\/p>\npublic static void FizzBuzz(object o)\r\n{\r\n switch (o)\r\n {\r\n case string s when s.Contains(\"Fizz\") || s.Contains(\"Buzz\"):\r\n Console.WriteLine(s);\r\n break;\r\n case int n when n % 5 == 0 && n % 3 == 0:\r\n Console.WriteLine(\"FizzBuzz\");\r\n break;\r\n case int n when n % 5 == 0:\r\n Console.WriteLine(\"Fizz\");\r\n break;\r\n case int n when n % 3 == 0:\r\n Console.WriteLine(\"Buzz\");\r\n break;\r\n case int n:\r\n Console.WriteLine(n);\r\n break;\r\n }\r\n}<\/pre>\nobject<\/code>instead of just a number.<\/p>\npublic static void FizzBuzz(object o)\r\n{\r\n \/\/ All cases can match only if the value is not null\r\n if (o != null)\r\n {\r\n if (o is string s &&\r\n (s.Contains(\"Fizz\") || s.Contains(\"Buzz\")))\r\n {\r\n Console.WriteLine(s);\r\n return;\r\n }\r\n \r\n bool isInt = o is int;\r\n int num = isInt ? ((int)o) : 0;\r\n if (isInt)\r\n {\r\n \/\/ The type check and unboxing happens only once per group\r\n if (num % 5 == 0 && num % 3 == 0)\r\n {\r\n Console.WriteLine(\"FizzBuzz\");\r\n return;\r\n }\r\n if (num % 5 == 0)\r\n {\r\n Console.WriteLine(\"Fizz\");\r\n return;\r\n }\r\n if (num % 3 == 0)\r\n {\r\n Console.WriteLine(\"Buzz\");\r\n return;\r\n }\r\n \r\n Console.WriteLine(num);\r\n }\r\n }\r\n}<\/pre>\n\n
switch (o)\r\n{\r\n \/\/ The generated code is less optimal:\r\n \/\/ If o is int, then more than one type check and unboxing operation\r\n \/\/ may happen.\r\n case int n when n == 1: return 1;\r\n case string s when s == \"\": return 2;\r\n case int n when n == 2: return 3;\r\n default: return -1;\r\n}<\/pre>\nif (o is int n && n == 1) return 1;\r\nif (o is string s && s == \"\") return 2;\r\nif (o is int n2 && n2 == 2) return 3;\r\nreturn -1;<\/pre>\n
\n
switch (o)\r\n{\r\n case int n: return 1;\r\n \/\/ Error: The switch case has already been handled by a previous case.\r\n case int n when n == 1: return 2;\r\n}<\/pre>\nswitch (o)\r\n{\r\n case int n when n > 0: return 1;\r\n \/\/ Will never match, but the compiler won't warn you about it\r\n case int n when n > 1: return 2;\r\n}<\/pre>\nPattern matching 101<\/h4>\n
\n
is<\/code>-expressions and in case blocks.<\/li>\nis<\/code>-expression for value types is far from perfect from the performance point of view.<\/li>\nvar<\/code>-pattern always match and you should be careful with them.<\/li>\nwhen<\/code> clauses.<\/li>\n<\/ul>\n