Desen eşleştirme - `is` ve `switch` ifadeleri, işleçleri `andor` ve `not` desenler içinde

Makale
11/14/2023

Bir giriş ifadesini herhangi bir sayıda özelliğe göre eşleştirmek için ifadeyi, switch deyimini ve switch ifadesini kullanırsınızis. C# bildirim, tür, sabit, ilişkisel, özellik, liste, var ve atma dahil olmak üzere birden çok deseni destekler. Desenler, , orve notBoole mantıksal anahtar sözcükleri andkullanılarak birleştirilebilir.

Aşağıdaki C# ifadeleri ve deyimleri desen eşleştirmeyi destekler:

Bu yapılarda, bir giriş ifadesini aşağıdaki desenlerden herhangi biriyle eşleştirebilirsiniz:

Bildirim deseni: bir ifadenin çalışma zamanı türünü denetlemek ve eşleşme başarılı olursa bildirilen değişkene bir ifade sonucu atamak için.
Tür deseni: bir ifadenin çalışma zamanı türünü denetlemek için.
Sabit desen: bir ifade sonucunun belirtilen sabite eşit olup olmadığını test etmek için.
İlişkisel desenler: bir ifade sonucunu belirtilen sabitle karşılaştırmak için.
Mantıksal desenler: bir ifadenin desenlerin mantıksal bileşimiyle eşleşip eşleşmediğini test etmek için.
Özellik deseni: bir ifadenin özelliklerinin veya alanlarının iç içe desenlere uygun olup olmadığını test etmek için.
Konumsal desen: bir ifade sonucunun yapısını çözmek ve sonuçta elde edilen değerlerin iç içe desenlerle eşleşip eşleşmediğini test etmek için.
var pattern: herhangi bir ifadeyi eşleştirmek ve sonucunu bildirilen bir değişkene atamak için.
At deseni: herhangi bir ifadeyi eşleştirmek için.
Liste desenleri: Dizi öğelerinin karşılık gelen iç içe desenlere uygun olup olmadığını test etmek için. C# 11'de tanıtıldı.

Mantıksal, özellik, konumsal ve liste desenleri özyinelemeli desenlerdir. Yani iç içe desenler içerebilirler.

Veri temelli algoritma oluşturmak için bu desenlerin nasıl kullanılacağına ilişkin örnek için bkz . Öğretici: Tür temelli ve veri temelli algoritmalar oluşturmak için desen eşleştirmeyi kullanma.

Bildirim ve tür desenleri

Bir ifadenin çalışma zamanı türünün belirli bir türle uyumlu olup olmadığını denetlemek için bildirim ve tür desenleri kullanırsınız. Bildirim deseniyle, yeni bir yerel değişken de bildirebilirsiniz. Bildirim deseni bir ifadeyle eşleştiğinde, aşağıdaki örnekte gösterildiği gibi bu değişkene dönüştürülmüş bir ifade sonucu atanır:

object greeting = "Hello, World!";
if (greeting is string message)
{
    Console.WriteLine(message.ToLower());  // output: hello, world!
}

Türe sahip bir bildirim deseni , ifade sonucu null olmadığında ve aşağıdaki koşullardan herhangi biri doğru olduğunda ifadeyle T eşleşir:

İfade sonucunun çalışma zamanı türü olur T.
bir ifade sonucunun çalışma zamanı türü, türünden Ttüretilir, arabirimini Tuygular veya başka bir örtük başvuru dönüştürmesi ondan 'a Tvar olur. Aşağıdaki örnekte, bu koşulun doğru olduğu iki durum gösterilmektedir:
```
var numbers = new int[] { 10, 20, 30 };
Console.WriteLine(GetSourceLabel(numbers));  // output: 1

var letters = new List<char> { 'a', 'b', 'c', 'd' };
Console.WriteLine(GetSourceLabel(letters));  // output: 2

static int GetSourceLabel<T>(IEnumerable<T> source) => source switch
{
    Array array => 1,
    ICollection<T> collection => 2,
    _ => 3,
};
```
Yukarıdaki örnekte, yöntemine yapılan ilk çağrıda, bağımsız değişkenin çalışma zamanı türü int[] türünden türetildiği için GetSourceLabel ilk desen bir bağımsız değişken değeriyle Array eşleşir. yöntemine GetSourceLabel yapılan ikinci çağrıda bağımsız değişkenin çalışma zamanı türü türünden List<T> Array türetilmez ancak arabirimini ICollection<T> uygular.
bir ifade sonucunun çalışma zamanı türü, temel türüne sahip null atanabilir bir değer türüdürT.
İfade sonucunun çalışma zamanı türünden türüne Tbir kutulama veya kutu açma dönüştürmesi var.

Aşağıdaki örnekte son iki koşul gösterilmektedir:

int? xNullable = 7;
int y = 23;
object yBoxed = y;
if (xNullable is int a && yBoxed is int b)
{
    Console.WriteLine(a + b);  // output: 30
}

Yalnızca bir ifadenin türünü denetlemek istiyorsanız, aşağıdaki örnekte gösterildiği gibi değişkenin adının yerine atma _ kullanabilirsiniz:

public abstract class Vehicle {}
public class Car : Vehicle {}
public class Truck : Vehicle {}

public static class TollCalculator
{
    public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
    {
        Car _ => 2.00m,
        Truck _ => 7.50m,
        null => throw new ArgumentNullException(nameof(vehicle)),
        _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
    };
}

Bu amaçla, aşağıdaki örnekte gösterildiği gibi bir tür deseni kullanabilirsiniz:

public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
{
    Car => 2.00m,
    Truck => 7.50m,
    null => throw new ArgumentNullException(nameof(vehicle)),
    _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};

Bildirim deseni gibi, bir ifade sonucu null olmadığında ve çalışma zamanı türü yukarıda listelenen koşullardan herhangi birini karşıladığında tür deseni ifadeyle eşleşir.

Null olmayanları denetlemek için, aşağıdaki örnekte gösterildiği gibi olumsuzlanmış null bir sabit desen kullanabilirsiniz:

if (input is not null)
{
    // ...
}

Daha fazla bilgi için özellik teklifi notlarının Bildirim düzeni ve Tür deseni bölümlerine bakın.

Sabit desen

Aşağıdaki örnekte gösterildiği gibi bir ifade sonucunun belirtilen sabite eşit olup olmadığını test etmek için sabit bir desen kullanırsınız:

public static decimal GetGroupTicketPrice(int visitorCount) => visitorCount switch
{
    1 => 12.0m,
    2 => 20.0m,
    3 => 27.0m,
    4 => 32.0m,
    0 => 0.0m,
    _ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
};

Sabit bir desende, aşağıdakiler gibi herhangi bir sabit ifadeyi kullanabilirsiniz:

tamsayı veya kayan nokta sayısal değişmez değeri
bir karakter
bir dize değişmez değeri.
Boole değeri true veya false
sabit listesi değeri
bildirilen bir const alanının veya yerel alanın adı
null

İfade, sabit türe dönüştürülebilir bir tür olmalıdır; tek bir özel durum vardır: Türü C# 11 ve sonraki sürümlerde sabit dizelerle eşleştirilebilen veya ReadOnlySpan<char> eşleştirilebilen bir ifadeSpan<char>.

Aşağıdaki örnekte gösterildiği gibi denetlemek için nullsabit bir desen kullanın:

if (input is null)
{
    return;
}

Derleyici, ifade x is null değerlendirildiğinde kullanıcı tarafından aşırı yüklenmiş eşitlik işlecinin == çağrılmadığını garanti eder.

Aşağıdaki örnekte gösterildiği gibi null olmayanları denetlemek için negatifleştirilmiş null sabit deseni kullanabilirsiniz:

if (input is not null)
{
    // ...
}

Daha fazla bilgi için özellik teklifi notunun Sabit desen bölümüne bakın.

İlişkisel desenler

Aşağıdaki örnekte gösterildiği gibi, bir ifade sonucunu sabitle karşılaştırmak için ilişkisel desen kullanırsınız:

Console.WriteLine(Classify(13));  // output: Too high
Console.WriteLine(Classify(double.NaN));  // output: Unknown
Console.WriteLine(Classify(2.4));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -4.0 => "Too low",
    > 10.0 => "Too high",
    double.NaN => "Unknown",
    _ => "Acceptable",
};

İlişkisel bir desende, , <=>veya >=ilişkisel işleçlerden < herhangi birini kullanabilirsiniz. İlişkisel desenin sağ tarafı sabit bir ifade olmalıdır. Sabit ifade bir tamsayı, kayan nokta, karakter veya numaralandırma türünde olabilir.

Bir ifade sonucunun belirli bir aralıkta olup olmadığını denetlemek için, aşağıdaki örnekte gösterildiği gibi bunu konjonktif and bir desenle eşleştirin:

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 3, 14)));  // output: spring
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 7, 19)));  // output: summer
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 2, 17)));  // output: winter

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    >= 3 and < 6 => "spring",
    >= 6 and < 9 => "summer",
    >= 9 and < 12 => "autumn",
    12 or (>= 1 and < 3) => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

İfade sonucu null null atanabilir veya kutulanmamış bir dönüştürmeyle sabit türüne dönüştürülmezse veya dönüştüremezse, ilişkisel desen bir ifadeyle eşleşmez.

Daha fazla bilgi için özellik teklifi notunun İlişkisel desenler bölümüne bakın.

Mantıksal desenler

Aşağıdaki mantıksal desenleri oluşturmak için , andve or desen birleştiricilerini kullanırsınıznot:

Olumsuzlanan desen ifadeyle eşleşmediğinde bir ifadeyle eşleşen olumsuzlama not deseni. Aşağıdaki örnekte, bir ifadenin null olmayan olup olmadığını denetlemek için bir sabit null deseni nasıl olumsuzlayabileceğiniz gösterilmektedir:
```
if (input is not null)
{
    // ...
}
```

her iki desen de ifadeyle eşleştiğinde ifadeyle eşleşen konjonktif and desen. Aşağıdaki örnekte, bir değerin belirli bir aralıkta olup olmadığını denetlemek için ilişkisel desenleri nasıl birleştirebileceğiniz gösterilmektedir:

Console.WriteLine(Classify(13));  // output: High
Console.WriteLine(Classify(-100));  // output: Too low
Console.WriteLine(Classify(5.7));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -40.0 => "Too low",
    >= -40.0 and < 0 => "Low",
    >= 0 and < 10.0 => "Acceptable",
    >= 10.0 and < 20.0 => "High",
    >= 20.0 => "Too high",
    double.NaN => "Unknown",
};

or Aşağıdaki örnekte gösterildiği gibi, iki desenden biri ifadeyle eşleştiğinde ifadeyle eşleşen ayrık desen:

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 1, 19)));  // output: winter
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 10, 9)));  // output: autumn
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 5, 11)));  // output: spring

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    3 or 4 or 5 => "spring",
    6 or 7 or 8 => "summer",
    9 or 10 or 11 => "autumn",
    12 or 1 or 2 => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Yukarıdaki örnekte gösterildiği gibi, desen birleştiricilerini bir desende tekrar tekrar kullanabilirsiniz.

Öncelik ve denetim sırası

Desen birleştiricileri en yüksek önceliğe ve en düşük önceliğe aşağıdaki gibi sıralanır:

not
and
or

Mantıksal desen bir is ifadenin deseni olduğunda, mantıksal desen birleştiricilerinin önceliği mantıksal işleçlerin (bit düzeyinde mantıksal ve Boole mantıksal işleçleri) önceliği daha yüksektir. Aksi takdirde, mantıksal desen birleştiricilerinin önceliği, mantıksal ve koşullu mantıksal işleçlerin önceliğinden daha düşüktür . Öncelik düzeyine göre sıralanmış C# işleçlerinin tam listesi için C# işleçleri makalesinin İşleç önceliği bölümüne bakın.

Önceliği açıkça belirtmek için aşağıdaki örnekte gösterildiği gibi parantezleri kullanın:

static bool IsLetter(char c) => c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z');

Not

Desenlerin denetlenme sırası tanımlanmamıştır. Çalışma zamanında, sağ iç içe desenleri ve and desenleri or önce denetlenebilir.

Daha fazla bilgi için özellik teklifi notunun Desen birleştiricileri bölümüne bakın.

Özellik düzeni

Aşağıdaki örnekte gösterildiği gibi, bir ifadenin özelliklerini veya alanlarını iç içe desenlerle eşleştirmek için bir özellik deseni kullanırsınız:

static bool IsConferenceDay(DateTime date) => date is { Year: 2020, Month: 5, Day: 19 or 20 or 21 };

Bir ifade sonucu null olmadığında ve iç içe yerleştirilmiş her desen ifade sonucunun ilgili özelliği veya alanıyla eşleştiğinde bir özellik deseni bir ifadeyle eşleşir.

Aşağıdaki örnekte gösterildiği gibi bir özellik desenine bir çalışma zamanı türü denetimi ve değişken bildirimi de ekleyebilirsiniz:

Console.WriteLine(TakeFive("Hello, world!"));  // output: Hello
Console.WriteLine(TakeFive("Hi!"));  // output: Hi!
Console.WriteLine(TakeFive(new[] { '1', '2', '3', '4', '5', '6', '7' }));  // output: 12345
Console.WriteLine(TakeFive(new[] { 'a', 'b', 'c' }));  // output: abc

static string TakeFive(object input) => input switch
{
    string { Length: >= 5 } s => s.Substring(0, 5),
    string s => s,

    ICollection<char> { Count: >= 5 } symbols => new string(symbols.Take(5).ToArray()),
    ICollection<char> symbols => new string(symbols.ToArray()),

    null => throw new ArgumentNullException(nameof(input)),
    _ => throw new ArgumentException("Not supported input type."),
};

Özellik düzeni özyinelemeli bir desendir. Başka bir ifadeyle, herhangi bir deseni iç içe desen olarak kullanabilirsiniz. Aşağıdaki örnekte gösterildiği gibi, verilerin bölümlerini iç içe desenlerle eşleştirmek için bir özellik deseni kullanın:

public record Point(int X, int Y);
public record Segment(Point Start, Point End);

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start: { Y: 0 } } or { End: { Y: 0 } };

Yukarıdaki örnekte desen birleştiricisi or ve kayıt türleri kullanılır.

C# 10'da başlayarak, bir özellik deseni içindeki iç içe özelliklere veya alanlara başvurabilirsiniz. Bu özellik genişletilmiş özellik deseni olarak bilinir. Örneğin, önceki örnekteki yöntemi aşağıdaki eşdeğer koda yeniden düzenleyebilirsiniz:

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start.Y: 0 } or { End.Y: 0 };

Daha fazla bilgi için özellik teklifi notunun Özellik düzeni bölümüne ve Genişletilmiş özellik desenleri özellik teklifi notu'na bakın.

İpucu

Genişletilmiş özellik desenlerini kullanmak için yerler önererek kod okunabilirliğini geliştirmek için Özellik desenini basitleştirme (IDE0170) stil kuralını kullanabilirsiniz.

Konumsal desen

Aşağıdaki örnekte gösterildiği gibi, bir ifade sonucunun yapısını çözmek ve sonuçta elde edilen değerleri karşılık gelen iç içe desenlerle eşleştirmek için konumsal desen kullanırsınız:

public readonly struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y) => (X, Y) = (x, y);

    public void Deconstruct(out int x, out int y) => (x, y) = (X, Y);
}

static string Classify(Point point) => point switch
{
    (0, 0) => "Origin",
    (1, 0) => "positive X basis end",
    (0, 1) => "positive Y basis end",
    _ => "Just a point",
};

Yukarıdaki örnekte, ifade türü bir ifade sonucunun yapısını çözmek için kullanılan Deconstruct yöntemini içerir. Ayrıca tanımlama grubu türlerinin ifadelerini konumsal desenlerle eşleştirebilirsiniz. Bu şekilde, aşağıdaki örnekte gösterildiği gibi çeşitli desenlerle birden çok girişi eşleştirebilirsiniz:

static decimal GetGroupTicketPriceDiscount(int groupSize, DateTime visitDate)
    => (groupSize, visitDate.DayOfWeek) switch
    {
        (<= 0, _) => throw new ArgumentException("Group size must be positive."),
        (_, DayOfWeek.Saturday or DayOfWeek.Sunday) => 0.0m,
        (>= 5 and < 10, DayOfWeek.Monday) => 20.0m,
        (>= 10, DayOfWeek.Monday) => 30.0m,
        (>= 5 and < 10, _) => 12.0m,
        (>= 10, _) => 15.0m,
        _ => 0.0m,
    };

Yukarıdaki örnekte ilişkisel ve mantıksal desenler kullanılır.

Aşağıdaki örnekte gösterildiği gibi, tanımlama grubu öğelerinin ve Deconstruct parametrelerinin adlarını konumsal bir düzende kullanabilirsiniz:

var numbers = new List<int> { 1, 2, 3 };
if (SumAndCount(numbers) is (Sum: var sum, Count: > 0))
{
    Console.WriteLine($"Sum of [{string.Join(" ", numbers)}] is {sum}");  // output: Sum of [1 2 3] is 6
}

static (double Sum, int Count) SumAndCount(IEnumerable<int> numbers)
{
    int sum = 0;
    int count = 0;
    foreach (int number in numbers)
    {
        sum += number;
        count++;
    }
    return (sum, count);
}

Konumsal deseni aşağıdaki yollardan herhangi biriyle de genişletebilirsiniz:

Aşağıdaki örnekte gösterildiği gibi bir çalışma zamanı türü denetimi ve değişken bildirimi ekleyin:

public record Point2D(int X, int Y);
public record Point3D(int X, int Y, int Z);

static string PrintIfAllCoordinatesArePositive(object point) => point switch
{
    Point2D (> 0, > 0) p => p.ToString(),
    Point3D (> 0, > 0, > 0) p => p.ToString(),
    _ => string.Empty,
};

Yukarıdaki örnek, yöntemini örtük olarak sağlayan Deconstruct konumsal kayıtları kullanır.

Aşağıdaki örnekte gösterildiği gibi konumsal desen içinde bir özellik deseni kullanın:

public record WeightedPoint(int X, int Y)
{
    public double Weight { get; set; }
}

static bool IsInDomain(WeightedPoint point) => point is (>= 0, >= 0) { Weight: >= 0.0 };

Aşağıdaki örnekte gösterildiği gibi önceki iki kullanımı birleştirin:
```
if (input is WeightedPoint (> 0, > 0) { Weight: > 0.0 } p)
{
    // ..
}
```

Konumsal desen özyinelemeli bir desendir. Başka bir ifadeyle, herhangi bir deseni iç içe desen olarak kullanabilirsiniz.

Daha fazla bilgi için özellik teklifi notunun Konumsal desen bölümüne bakın.

`var` desen

Aşağıdaki örnekte gösterildiği gibi, dahil olmak üzere nulltüm ifadeleri eşleştirmek ve sonucunu yeni bir yerel değişkene atamak için bir var desen kullanırsınız:

static bool IsAcceptable(int id, int absLimit) =>
    SimulateDataFetch(id) is var results 
    && results.Min() >= -absLimit 
    && results.Max() <= absLimit;

static int[] SimulateDataFetch(int id)
{
    var rand = new Random();
    return Enumerable
               .Range(start: 0, count: 5)
               .Select(s => rand.Next(minValue: -10, maxValue: 11))
               .ToArray();
}

Ara var hesaplamaların sonucunu tutmak için Boole ifadesinde geçici bir değişkene ihtiyacınız olduğunda desen kullanışlıdır. Aşağıdaki örnekte gösterildiği gibi, bir var ifadenin veya deyimin korumaları durumunda daha fazla denetim when gerçekleştirmeniz gerektiğinde de bir switch desen kullanabilirsiniz:

public record Point(int X, int Y);

static Point Transform(Point point) => point switch
{
    var (x, y) when x < y => new Point(-x, y),
    var (x, y) when x > y => new Point(x, -y),
    var (x, y) => new Point(x, y),
};

static void TestTransform()
{
    Console.WriteLine(Transform(new Point(1, 2)));  // output: Point { X = -1, Y = 2 }
    Console.WriteLine(Transform(new Point(5, 2)));  // output: Point { X = 5, Y = -2 }
}

Yukarıdaki örnekte desen, var (x, y) bir konumsal desene (var x, var y)eşdeğerdir.

Bir var desende, bildirilen değişkenin türü, desenle eşleşen ifadenin derleme zamanı türüdür.

Daha fazla bilgi için özellik teklifi notunun Var deseni bölümüne bakın.

Atma düzeni

Aşağıdaki örnekte gösterildiği gibi, dahil olmak üzere nulltüm ifadeleri eşleştirmek için bir atma deseni _ kullanırsınız:

Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday));  // output: 5.0
Console.WriteLine(GetDiscountInPercent(null));  // output: 0.0
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10));  // output: 0.0

static decimal GetDiscountInPercent(DayOfWeek? dayOfWeek) => dayOfWeek switch
{
    DayOfWeek.Monday => 0.5m,
    DayOfWeek.Tuesday => 12.5m,
    DayOfWeek.Wednesday => 7.5m,
    DayOfWeek.Thursday => 12.5m,
    DayOfWeek.Friday => 5.0m,
    DayOfWeek.Saturday => 2.5m,
    DayOfWeek.Sunday => 2.0m,
    _ => 0.0m,
};

Yukarıdaki örnekte, numaralandırmanın karşılık gelen üyesi olmayan herhangi bir tamsayı değerini işlemek null için bir atma deseni DayOfWeek kullanılır. Bu, örnekteki bir switch ifadenin tüm olası giriş değerlerini işlemesini garanti eder. İfadede switch atma deseni kullanmazsanız ve ifadenin desenlerinden hiçbiri bir girişle eşleşmiyorsa, çalışma zamanı bir özel durum oluşturur. Bir ifade tüm olası giriş değerlerini işlemezse derleyici bir switch uyarı oluşturur.

Atma deseni bir ifadede veya switch deyimde is desen olamaz. Bu gibi durumlarda, herhangi bir ifadeyi eşleştirmek için atma ile bir var desen kullanın: var _. Atma deseni, ifadedeki bir switch desen olabilir.

Daha fazla bilgi için özellik teklifi notunun Deseni at bölümüne bakın.

Ayraçlı desen

Herhangi bir desenin etrafına parantezler koyabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi, mantıksal desenlerdeki önceliği vurgular veya değiştirmek için bunu yaparsınız:

if (input is not (float or double))
{
    return;
}

Liste desenleri

C# 11'le başlayarak, aşağıdaki örnekte gösterildiği gibi bir diziyi veya listeyi desen dizisiyle eşleştirebilirsiniz:

int[] numbers = { 1, 2, 3 };

Console.WriteLine(numbers is [1, 2, 3]);  // True
Console.WriteLine(numbers is [1, 2, 4]);  // False
Console.WriteLine(numbers is [1, 2, 3, 4]);  // False
Console.WriteLine(numbers is [0 or 1, <= 2, >= 3]);  // True

Yukarıdaki örnekte gösterildiği gibi, her iç içe desen bir giriş dizisinin ilgili öğesiyle eşleştiğinde bir liste deseni eşleştirilir. Liste deseni içindeki herhangi bir deseni kullanabilirsiniz. Herhangi bir öğeyi eşleştirmek için atma desenini kullanın veya aşağıdaki örnekte gösterildiği gibi öğeyi yakalamak istiyorsanız var desenini kullanın:

List<int> numbers = new() { 1, 2, 3 };

if (numbers is [var first, _, _])
{
    Console.WriteLine($"The first element of a three-item list is {first}.");
}
// Output:
// The first element of a three-item list is 1.

Yukarıdaki örnekler, bir giriş dizisinin tamamını bir liste düzeniyle eşleştirir. Öğeleri yalnızca giriş dizisinin başında veya/ve sonunda eşleştirmek için, aşağıdaki örnekte gösterildiği gibi dilim desenini ..kullanın:

Console.WriteLine(new[] { 1, 2, 3, 4, 5 } is [> 0, > 0, ..]);  // True
Console.WriteLine(new[] { 1, 1 } is [_, _, ..]);  // True
Console.WriteLine(new[] { 0, 1, 2, 3, 4 } is [> 0, > 0, ..]);  // False
Console.WriteLine(new[] { 1 } is [1, 2, ..]);  // False

Console.WriteLine(new[] { 1, 2, 3, 4 } is [.., > 0, > 0]);  // True
Console.WriteLine(new[] { 2, 4 } is [.., > 0, 2, 4]);  // False
Console.WriteLine(new[] { 2, 4 } is [.., 2, 4]);  // True

Console.WriteLine(new[] { 1, 2, 3, 4 } is [>= 0, .., 2 or 4]);  // True
Console.WriteLine(new[] { 1, 0, 0, 1 } is [1, 0, .., 0, 1]);  // True
Console.WriteLine(new[] { 1, 0, 1 } is [1, 0, .., 0, 1]);  // False

Dilim deseni sıfır veya daha fazla öğeyle eşleşir. Liste düzeninde en fazla bir dilim deseni kullanabilirsiniz. Dilim deseni yalnızca bir liste deseninde görünebilir.

Aşağıdaki örnekte gösterildiği gibi, bir alt kalıbı bir dilim deseninin içinde de iç içe yerleştirebilirsiniz:

void MatchMessage(string message)
{
    var result = message is ['a' or 'A', .. var s, 'a' or 'A']
        ? $"Message {message} matches; inner part is {s}."
        : $"Message {message} doesn't match.";
    Console.WriteLine(result);
}

MatchMessage("aBBA");  // output: Message aBBA matches; inner part is BB.
MatchMessage("apron");  // output: Message apron doesn't match.

void Validate(int[] numbers)
{
    var result = numbers is [< 0, .. { Length: 2 or 4 }, > 0] ? "valid" : "not valid";
    Console.WriteLine(result);
}

Validate(new[] { -1, 0, 1 });  // output: not valid
Validate(new[] { -1, 0, 0, 1 });  // output: valid

Daha fazla bilgi için Bkz . Liste desenleri özellik teklifi notu.

C# dili belirtimi

Daha fazla bilgi için C# dil belirtiminin Desenler ve desen eşleştirme bölümüne bakın.

C# 8 ve sonraki sürümlere eklenen özellikler hakkında bilgi için aşağıdaki özellik teklifi notlarını inceleyin:

Aracılığıyla paylaş

Desen eşleştirme - `is` ve `switch` ifadeleri, işleçleri `andor` ve `not` desenler içinde

Bildirim ve tür desenleri

Sabit desen

İlişkisel desenler

Mantıksal desenler

Öncelik ve denetim sırası

Özellik düzeni

Konumsal desen

`var` desen

Atma düzeni

Ayraçlı desen

Liste desenleri

C# dili belirtimi

Ayrıca bkz.

Ek kaynaklar

Aracılığıyla paylaş

Desen eşleştirme - is ve switch ifadeleri, işleçleri andor ve not desenler içinde

Bildirim ve tür desenleri

Sabit desen

İlişkisel desenler

Mantıksal desenler

Öncelik ve denetim sırası

Özellik düzeni

Konumsal desen

var desen

Atma düzeni

Ayraçlı desen

Liste desenleri

C# dili belirtimi

Ayrıca bkz.

Ek kaynaklar

Desen eşleştirme - `is` ve `switch` ifadeleri, işleçleri `andor` ve `not` desenler içinde

`var` desen