C# Pattern Matching: is, switch Desenleri, Property ve Liste Desenleri

Pattern matching bir değeri bir şekle karşı test eder: "bir Circle mı?", "null mı?", "Status'u "paid" ve Total'ı 100'ün üzerinde mi?". Test başarılı olduğunda desen, değerin parçalarını yeni değişkenlere de çıkarabilir. C# 7'de is operatörüyle küçük başladı ve o zamandan beri her sürümde büyüdü, bu yüzden bu sayfa her biçimin sürümünü belirtir.

is tip deseni (C# 7)

C# 7'den önce bir tipi kontrol edip kullanmak iki adım sürüyordu: as artı bir null kontrolü ya da is artı bir cast. Tip deseni ikisini aynı anda yapar ve size tipli bir değişken verir:

using System;
using System.Collections.Generic;

class Payment { public decimal Amount; }
class CardPayment : Payment { public string Last4; }
class BankTransfer : Payment { public string Iban; }

class Program
{
    static string Describe(Payment p)
    {
        if (p is CardPayment card)
            return $"card ending {card.Last4}: {card.Amount}";
        if (p is BankTransfer bank)
            return $"transfer from {bank.Iban.Substring(0, 4)}...: {bank.Amount}";
        if (p == null)
            return "no payment";
        return $"other payment: {p.Amount}";
    }

    static void Main()
    {
        var payments = new List<Payment>
        {
            new CardPayment { Amount = 49.90m, Last4 = "4242" },
            new BankTransfer { Amount = 1200m, Iban = "PT50000201231234567890154" },
            null,
            new Payment { Amount = 5m },
        };

        foreach (var p in payments)
            Console.WriteLine(Describe(p));
    }
}

Çıktı:

card ending 4242: 49.90
transfer from PT50...: 1200
no payment
other payment: 5

p is CardPayment card yalnızca p null olmayan bir CardPayment (ya da ondan türeyen bir sınıf) olduğunda doğrudur ve o zaman card onu doğru statik tiple tutar. Null bir değer bir tip deseniyle asla eşleşmez; null ödemenin null kontrolüne düşmesinin nedeni budur.

Kapsam ve kesin atama

Desen değişkeni çevreleyen blokta vardır, ama derleyici onu yalnızca eşleşmenin başarılı olduğunun bilindiği yerde okumanıza izin verir. Bu, erken çıkıp değişkeni sonrasında kullandığınız "koruma cümlesi" şeklinin çalışmasını sağlar:

using System;

class Program
{
    static decimal ParsePrice(object input)
    {
        if (!(input is string text))
            throw new ArgumentException("price must be text");

        // text is definitely assigned here: the only way past the if is a match.
        return decimal.Parse(text.Trim().TrimStart('$'), System.Globalization.CultureInfo.InvariantCulture);
    }

    static void Main()
    {
        Console.WriteLine(ParsePrice(" $19.99 "));

        object boxed = 42;
        if (boxed is int n && n > 40)
            Console.WriteLine($"{n} is over 40");

        try
        {
            ParsePrice(19.99m);
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Çıktı:

19.99
42 is over 40
price must be text

boxed is int n && n > 40 diğer yaygın şekli gösterir: değişken &&'nin sağında kullanılabilir, çünkü o taraf yalnızca eşleşme başarılı olduğunda çalışır. ||'nin sağında atanmamıştır ve derleyici bunu söyler (CS0165).

Desenler unbox da yapar: boxed is int n box'lanmış bir int için başarılı olur ve size istisna fırlatabilecek bir cast olmadan değeri verir. Nullable değer tipleri için maybe is int n tam olarak maybe'nin bir değeri olduğunda başarılı olur.

Sabit ve null desenleri

Bir sabit de bir desendir. x is null en çok kullanılanıdır ve C# 7 ayrıca x is 0, status is "paid" ya da bir enum üyesine izin verir:

if (customer is null) return;          // null check that ignores any == overload
if (count is 0) Console.WriteLine("empty");
if (level is LogLevel.Error) Alert();

Birçok ekip is null'ı == null'a tercih eder, çünkü tipteki bir operatör aşırı yüklemesiyle yönlendirilemez. C# 9 olumsuz biçimi ekler: is not null.

switch ifadelerinde desenler (C# 7)

Aynı tip desenleri case'leri etiketleyebilir ve bir when cümlesi bir koşul ekler. Case'ler yukarıdan aşağıya denenir, bu yüzden onları özelden genele sıralayın:

static string Describe(object o)
{
    switch (o)
    {
        case null:                           return "nothing";
        case int n when n < 0:               return "negative number";
        case int n:                          return $"number {n}";
        case string s when s.Length == 0:    return "empty text";
        case string s:                       return $"text of {s.Length} chars";
        case IEnumerable<int> list:          return "a sequence of numbers";
        default:                             return o.GetType().Name;
    }
}

Describe(-4);                 // negative number
Describe("");                 // empty text
Describe(new List<int>());    // a sequence of numbers
Describe(2.5);                // Double

Derleyici sırayı kontrol eder: daha önceki bir case onu kapsadığı için asla eşleşemeyecek bir case CS8120 hatasıdır. default, nerede görünürse görünsün her zaman en son değerlendirilir. Yukarıdaki ödeme örneğinde olduğu gibi if/is zincirleriyle yazılan aynı mantık, 7'den itibaren her C# sürümünde çalışır.

Switch expression'lar (C# 8)

Bir switch expression, "birkaç durumdan tek bir değer hesapla"nın kompakt biçimidir. Önce değer, sonra switch, sonra virgülle ayrılmış pattern => result kolları gelir ve _ hepsini yakalayandır:

public abstract record Shape;
public record Circle(double Radius) : Shape;
public record Rectangle(double Width, double Height) : Shape;

static double Area(Shape shape) => shape switch
{
    Circle c => Math.PI * c.Radius * c.Radius,
    Rectangle { Width: var w, Height: var h } => w * h,
    _ => throw new ArgumentException("Unknown shape", nameof(shape)),
};

Area(new Rectangle(3, 4));   // 12

Çalışma zamanında hiçbir kol eşleşmezse SwitchExpressionException fırlatır ve derleyici bazı girdilerin ele alınmadığını görebildiğinde uyarır (CS8509). Switch expression sayfası sözdizimini ayrıca ele alır; bu sayfanın geri kalanı kollara koyabileceğiniz desenlerle ilgilidir.

Property desenleri (C# 8, C# 10'da genişletildi)

Bir property deseni bir nesnenin property'lerini süslü parantez içindeki iç içe desenlere karşı eşleştirir. Nesne de null olmamalıdır, bu yüzden tek başına { } "null değil" demektir:

public record Address(string City, string Country);
public record Order(decimal Total, string Status, Address ShipTo, int Items);

static string Shipping(Order order) => order switch
{
    { Status: "cancelled" }                   => "no shipment",
    { ShipTo.Country: "PT", Total: >= 50m }   => "free, domestic",     // C# 10 dotted form
    { ShipTo.Country: "PT" }                  => "4.90, domestic",
    { Total: > 200m }                         => "free, international",
    _                                         => "12.00, international",
};

Shipping(new Order(60m, "paid", new Address("Porto", "PT"), 2));    // free, domestic
Shipping(new Order(260m, "paid", new Address("Lyon", "FR"), 2));    // free, international

C# 8 ve 9'da iç içe biçim gereklidir: { ShipTo: { Country: "PT" } }. C# 10 yukarıda kullanılan noktalı kısaltmaya izin verir. Property desenleri is ile de çalışır; bu da çok koşullu kontrolleri bir tanım gibi okunur yapar: if (order is { Status: "paid", Items: > 0 }).

İlişkisel ve mantıksal desenler (C# 9)

C# 9 karşılaştırmaları (<, <=, >, >=) ve aralıkları desenlere çeviren and, or ve not birleştiricilerini ekledi:

static string Grade(int score) => score switch
{
    < 0 or > 100      => "invalid",
    >= 90             => "A",
    >= 75 and < 90    => "B",
    >= 50             => "C",
    _                 => "F",
};

Grade(82);    // B
Grade(101);   // invalid

if (input is not null and not "") { ... }
if (c is >= 'a' and <= 'z' or >= 'A' and <= 'Z') { ... }   // and binds tighter than or

C# 7'deki karşılığı bir if/else if zinciri ya da when cümleli bir switch'tir (case int s when s >= 90:).

Tuple ve konumsal desenler (C# 8)

Aynı anda birkaç değer üzerinde switch yapmak bir tuple üzerinde switch yaparak gerçekleştirilir:

static string Quadrant(int x, int y) => (x, y) switch
{
    (0, 0)       => "origin",
    (> 0, > 0)   => "I",
    (< 0, > 0)   => "II",
    (< 0, < 0)   => "III",
    (> 0, < 0)   => "IV",
    _            => "on an axis",
};

Quadrant(-2, 5);   // II

Bir konumsal desen, record'lar dahil Deconstruct metodu olan her tip için aynısını yapar: case Point(0, 0): ya da p is Rectangle(var w, var h) && w == h.

Liste desenleri (C# 11)

Liste desenleri dizileri ve listeleri elemanlarına göre eşleştirir. .. herhangi sayıda elemanla eşleşir (bir "dilim") ve her eleman konumu başka herhangi bir deseni tutabilir:

static string Route(string[] args) => args switch
{
    []                         => "help",
    ["add", var item]          => $"add {item}",
    ["remove", var item, ..]   => $"remove {item}",
    [var cmd, ..]              => $"unknown command {cmd}",
};

Route(new[] { "add", "milk" });             // add milk
Route(new[] { "remove", "milk", "now" });   // remove milk

int[] nums = { 1, 2, 3, 4 };
if (nums is [1, .., var last]) Console.WriteLine(last);   // 4

Hangi sürüm neyi ekledi

Yaygın hatalar

• Case'leri genelden özele sıralamak. case CardPayment c:'den önce case Payment p: ikincisini ulaşılamaz yapar (CS8120). Önce özel olan.
• Bir tip deseninin null ile eşleşmesini beklemek. null is string s false'tur. null'ı kendi case'iyle ya da is null ile ele alın.
• Desen değişkenini eşleşmenin başarısız olmuş olabileceği yerde okumak. a is int n || ...'den sonra n atanmamıştır (CS0165).
• Virtual metotlar yerine uzun tip switch'leri. Her yeni alt sınıf aynı switch'i beş yerde düzenlemek anlamına geliyorsa, davranış sınıf hiyerarşisine aittir. Desenler dışarıdan gelen veriler (JSON şekilleri, mesajlar, girdi tuple'ları) ve kontrol ettiğiniz kapalı tip kümeleri için parlar.
• Bir switch expression'da hepsini yakalayan kolu unutmak. Eşleşmeyen bir girdi çalışma zamanında istisna fırlatır; CS8509 uyarısını okuyun.