đź”§ C#: Fix a Deconstruct Method Never Matching a Pattern Switch
Positional pattern matching in a switch resolves against a type’s Deconstruct method using ordinary overload and extension-method lookup rules, which means a Deconstruct defined as an extension method only works for pattern matching where that extension’s namespace is actually in scope via a using directive. Leave the using out at the point the pattern appears, and the pattern doesn’t error — it simply never matches that shape, falling through to the next case or the default with no indication that the real problem is a missing import.
🔎 The Problem
namespace Geometry.Extensions
{
public static class PointExtensions
{
public static void Deconstruct(this Point p, out int x, out int y)
=> (x, y) = (p.X, p.Y);
}
}
// In a file WITHOUT "using Geometry.Extensions;":
string Describe(Point p) => p switch
{
(0, 0) => "origin", // never matches - Deconstruct not in scope
_ => "elsewhere" // every point, including (0,0), lands here
};
âś… Fix: Keep Deconstruct Discoverable Where the Pattern Is Used
- Add the exact
usingdirective for the extension method’s namespace in every file that uses a positional pattern depending on it — the pattern won’t error without it, so this has to be checked deliberately, not left to the compiler to flag. - Prefer an instance
Deconstructmethod over an extension-method one when a type’s values need to be reliably pattern-matchable, since instance members don’t carry the same scope-dependent risk. - Write a unit test that exercises the pattern match directly with a known-matching value and asserts the expected branch was taken, rather than trusting that code which compiles cleanly must also be matching correctly.
🚨 Why This Is Dangerous
- A pattern that silently never matches doesn’t just fail once — it fails identically for every input from that point forward, consistently routing every case to the fallback branch in a way that can look like intentional, working default behavior rather than a bug.
A missing
usingdirective doesn’t always cost you a compile error — sometimes it just quietly costs you the one case your switch was written to catch.

