Pattern matching (diperluaskan dengan ketara dalam versi C# terkini) membolehkan anda menguji bentuk, jenis, dan properties sesuatu nilai secara ringkas, dan mengekstrak data — menjadikan logik bersyarat yang kompleks jauh lebih bersih berbanding rantaian if-else bersarang. Ia digunakan dengan switch expressions, is, dan banyak lagi.
// type pattern — test type AND capture in one step
if (obj is string s)
Console.WriteLine(s.Length); // s is typed as string here (no separate cast)
if (obj is int n and > 0) // combine: type + condition
Console.WriteLine("positive int");
Operator is dengan type pattern menguji jenis dan menangkap nilai (ditaip) dalam satu langkah — lebih bersih daripada semakan-kemudian-cast yang berasingan.
string Describe(object obj) => obj switch
{
int n when n > 0 => "positive int", // type + condition (when)
int => "non-positive int",
string { Length: > 10 } => "long string", // property pattern
null => "null",
_ => "other", // default
};
Switch expressions menyokong patterns yang kaya: type patterns, syarat (when), dan property patterns ({ Length: > 10 } — memadankan pada properties objek) — menyatakan percabangan kompleks secara ringkas.
// property pattern — match on properties
var discount = customer switch
{
{ IsVip: true, Orders: > 100 } => 0.2, // multiple property conditions
{ Orders: > 50 } => 0.1,
_ => 0.0,
};
// relational + logical patterns (C# 9)
string Size(int n) => n switch
{
< 0 => "negative",
0 => "zero",
> 0 and < 100 => "small", // relational (< >) + logical (and/or/not)
_ => "large",
};
var (x, y) = point; // positional/deconstruction
int[] arr = { 1, 2, 3 };
if (arr is [1, .., 3]) { } // list pattern (C# 11) — starts with 1, ends with 3
Pattern matching ialah ciri C# moden yang penting dan semakin penting — ia telah diperluaskan dengan ketara merentas versi terkini, mengubah cara C# mengendalikan logik bersyarat dan semakan jenis, jadi memahaminya bernilai untuk menulis dan membaca kod C# semasa.
Nilai terasnya ialah menyatakan logik bersyarat yang kompleks secara ringkas dan boleh dibaca: berbanding rantaian if-else bersarang dengan semakan jenis, casts, dan akses property yang berasingan, pattern matching membolehkan anda menguji jenis, syarat, properties, dan struktur sesuatu nilai — serta mengekstrak data — dalam ekspresi yang bersih dan deklaratif (terutamanya dengan switch expressions).
Keluasan patterns — type patterns (uji dan tangkap jenis dalam satu langkah melalui is), property patterns (padankan pada properties objek), relational dan logical patterns (< 100 and > 0, not), dan list/positional patterns — meliputi pelbagai logik percabangan secara elegan.
Ini mencerminkan evolusi C# moden ke arah kod yang lebih berfungsi dan ekspresif, dan pattern matching muncul secara meluas dalam codebase semasa (terutamanya dengan switch expressions dan records).
Memahami pelbagai patterns dan bagaimana menggunakannya (dengan is, switch expressions, klausa when) adalah penting untuk menulis C# moden yang ringkas dan boleh dibaca serta untuk membaca kod yang menggunakan ciri-ciri ini.
Memandangkan pattern matching menggantikan logik bersyarat yang berjela-jela dengan ekspresi yang bersih dan deklaratif — meningkatkan kebolehbacaan dan mengurangkan pepijat — dan kerana ia ciri tersendiri C# moden yang terus berkembang, menguasainya adalah pengetahuan bernilai yang kerap digunakan yang membezakan C# moden yang fasih daripada gaya lama yang lebih berjela-jela, serta merupakan topik temu duga yang semakin biasa.