C# Pattern Matching: is, תבניות ב-switch, תבניות מאפיינים ורשימות

Pattern matching בודק ערך מול צורה: "האם זה Circle?", "האם זה null?", "האם ה-Status שלו הוא "paid" וה-Total שלו מעל 100?". כשהבדיקה מצליחה, התבנית יכולה גם לחלץ חלקים מהערך למשתנים חדשים. זה התחיל בקטן ב-C# 7 עם האופרטור is וגדל בכל גרסה מאז, ולכן הדף הזה מציין את הגרסה של כל צורה.

תבנית הטיפוס עם is (C# 7)

לפני C# 7, בדיקת טיפוס ושימוש בו דרשו שני צעדים: as ועוד בדיקת null, או is ועוד המרה. תבנית הטיפוס עושה את שניהם בבת אחת ונותנת לכם משתנה מהטיפוס הנכון:

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));
    }
}

פלט:

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

p is CardPayment card נכון רק כש-p הוא CardPayment שאינו null (או מחלקה שנגזרת ממנו), ואז card מחזיק אותו עם הטיפוס הסטטי הנכון. ערך null אף פעם לא מתאים לתבנית טיפוס, ולכן התשלום שהוא null ממשיך הלאה עד לבדיקת ה-null.

טווח והשמה ודאית

משתנה התבנית קיים בבלוק העוטף, אבל הקומפיילר מאפשר לכם לקרוא אותו רק היכן שידוע שההתאמה הצליחה. זה מה שמאפשר את צורת "סעיף השמירה", שבה יוצאים מוקדם ומשתמשים במשתנה אחר כך:

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);
        }
    }
}

פלט:

19.99
42 is over 40
price must be text

boxed is int n && n > 40 מראה את הצורה הנפוצה השנייה: המשתנה שמיש מימין ל-&&, כי הצד הזה רץ רק כשההתאמה הצליחה. מימין ל-|| הוא לא מוגדר, והקומפיילר אומר את זה (CS0165).

תבניות גם מבצעות unboxing: boxed is int n מצליח עבור int ארוז ונותן לכם את הערך בלי המרה שעלולה לזרוק חריגה. בטיפוסי ערך nullable, maybe is int n מצליח בדיוק כשיש ב-maybe ערך.

תבניות קבוע ו-null

גם קבוע הוא תבנית. x is null היא הנפוצה ביותר, ו-C# 7 מתירה גם x is 0, status is "paid" או איבר של enum:

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

צוותים רבים מעדיפים את is null על פני == null כי העמסת אופרטור על הטיפוס לא יכולה להסיט אותו. C# 9 מוסיפה את הצורה השלילית, is not null.

תבניות בהוראות switch (C# 7)

אותן תבניות טיפוס יכולות לשמש תוויות של case, וסעיף when מוסיף תנאי. ה-cases נבדקים מלמעלה למטה, אז סדרו אותם מהספציפי לכללי:

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

הקומפיילר בודק את הסדר: case שלעולם לא יכול להתאים כי case קודם מכסה אותו הוא שגיאה CS8120. default תמיד נבדק אחרון, לא משנה איפה הוא מופיע. אותה לוגיקה כשהיא כתובה עם שרשראות if/is, כמו בדוגמת התשלומים למעלה, עובדת בכל גרסה של C# מ-7 והלאה.

ביטויי switch (C# 8)

ביטוי switch הוא הצורה הקומפקטית ל"חישוב ערך אחד מכמה מקרים". הערך בא קודם, אחריו switch, ואחריו זרועות של pattern => result מופרדות בפסיקים, עם _ כתופס הכול:

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

אם אף זרוע לא מתאימה בזמן ריצה, נזרקת SwitchExpressionException, והקומפיילר מזהיר (CS8509) כשהוא יכול לראות שקלט כלשהו לא מטופל. הדף על switch expression מסביר את התחביר עצמו; שאר הדף הזה עוסק בתבניות שאפשר לשים בזרועות.

תבניות מאפיינים (C# 8, הורחבו ב-C# 10)

תבנית מאפיינים מתאימה את המאפיינים של אובייקט לתבניות מקוננות, בתוך סוגריים מסולסלים. האובייקט חייב גם להיות לא null, כך ש-{ } לבדו אומר "לא null":

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 ו-9 נדרשת הצורה המקוננת: { ShipTo: { Country: "PT" } }. C# 10 מתירה את הקיצור עם הנקודה שבדוגמה. תבניות מאפיינים עובדות גם עם is, וזה הופך בדיקות עם כמה תנאים לקריאות כמו תיאור: if (order is { Status: "paid", Items: > 0 }).

תבניות יחס ותבניות לוגיות (C# 9)

C# 9 הוסיפה השוואות (<, <=, >, >=) ואת הצירופים and, or ו-not, שהופכים טווחים לתבניות:

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 היא שרשרת if/else if או switch עם סעיפי when (case int s when s >= 90:).

תבניות tuple ותבניות מיקום (C# 8)

switch על כמה ערכים בבת אחת נעשה באמצעות switch על tuple:

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

תבנית מיקום עושה את אותו הדבר לכל טיפוס עם מתודת Deconstruct, כולל records: case Point(0, 0): או p is Rectangle(var w, var h) && w == h.

תבניות רשימה (C# 11)

תבניות רשימה מתאימות מערכים ורשימות לפי האיברים שלהם. .. מתאים לכל מספר של איברים ("פרוסה"), וכל מיקום של איבר יכול להכיל כל תבנית אחרת:

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

איזו גרסה הוסיפה מה

טעויות נפוצות

• סידור cases מהכללי לספציפי. case Payment p: לפני case CardPayment c: הופך את השני לבלתי ניתן להגעה (CS8120). הספציפי קודם.
• ציפייה שתבנית טיפוס תתאים ל-null. null is string s הוא false. טפלו ב-null עם case משלו או עם is null.
• קריאה של משתנה התבנית היכן שההתאמה אולי נכשלה. אחרי a is int n || ..., n לא מוגדר (CS0165).
• switch ארוכים על טיפוסים במקום מתודות וירטואליות. אם כל תת-מחלקה חדשה מחייבת לערוך את אותו switch בחמישה מקומות, ההתנהגות שייכת להיררכיית המחלקות. תבניות מצטיינות בנתונים שמגיעים מבחוץ (מבני JSON, הודעות, tuples של קלטים) ובקבוצות סגורות של טיפוסים שבשליטתכם.
• שכחה של תופס הכול בביטוי switch. קלט שלא הותאם זורק חריגה בזמן ריצה; שימו לב לאזהרה CS8509.