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

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

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

• is ifade
• switch deyimi
• switch ifadesi

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 olduğunu 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ştiklerini 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: Bir öğe dizisinin ilgili iç içe desenlere uygun olduğunu 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ü GetSourceLabel türünden türetildiği için int[] 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 .

• İfade sonucunun çalışma zamanı türünden türüne bir kutulama veya T 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ü önceki koşullardan herhangi birini karşıladığında tür deseni bir ifadeyle eşleşir.

Null olmayanları denetlemek için, aşağıdaki örnekte gösterildiği gibi olumsuzlanmış null 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 Span<char> eşleştirilebilen bir ifadeReadOnlySpan<char>.

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

if (input is null)
{
    return;
}

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

Aşağıdaki örnekte gösterildiği gibi null olmayanları denetlemek için negatifleştirilmiş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 <=>=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 , notve and desen birleştiricilerini kullanırsınızor:

• Olumsuzlanan desen ifadeyle eşleşmediğinde bir ifadeyle eşleşen olumsuzlamanot deseni. Aşağıdaki örnekte, bir ifadenin null olmayan olup olmadığını denetlemek için bir sabitnull 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 konjonktifand 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, ifadelerin bağlama sırasına göre aşağıdaki gibi sıralanır:

• not
• and
• or

Desen önce not işlenenine bağlanır. Desen and , herhangi bir not desen ifadesi bağlamasının ardından bağlanır. Desen or , tümünden not sonra bağlanır ve and desenler işlenenlere bağlıdır. Aşağıdaki örnek, küçük harf a - zolmayan tüm karakterlerle eşleşmeye çalışır. Desen, desenden önce bağlandığından not bir hata oluştu and :

// Incorrect pattern. `not` binds before `and`
static bool IsNotLowerCaseLetter(char c) => c is not >= 'a' and <= 'z';

Varsayılan bağlama, önceki örneğin aşağıdaki örnek olarak ayrıştırılmış olduğu anlamına gelir:

// The default binding without parentheses is shows in this method. `not` binds before `and`
static bool IsNotLowerCaseLetterDefaultBinding(char c) => c is ((not >= 'a') and <= 'z');

Bunu düzeltmek için ifadesinin ifadeye not bağlanmasını >= 'a' and <= 'z' istediğinizi belirtmeniz gerekir:

// Correct pattern. Force `and` before `not`
static bool IsNotLowerCaseLetterParentheses(char c) => c is not (>= 'a' and <= 'z');

Desenleriniz daha karmaşık hale geldikçe parantez eklemek daha önemli hale gelir. Genel olarak, aşağıdaki örnekte gösterildiği gibi diğer geliştiricilere yönelik desenlerinizi netleştirmek için parantez kullanın:

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

Not

Aynı bağlama sırasına sahip desenlerin denetlenme sırası tanımlanmamıştır. Çalışma zamanında, önce birden çok desenin ve birden çok orand desenin sağ iç içe desenleri 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.

Bir özellik deseni içinde 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.

Önemli

Konumsal desendeki üyelerin sırası yöntemindeki parametrelerin sırasıyla Deconstruct eşleşmelidir. Bunun nedeni, konumsal desen için oluşturulan kodun yöntemini çağırmasıdır Deconstruct .

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 konumsal kayıtlarıDeconstruct.

• 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 vartüm ifadeleri eşleştirmek ve sonucunu yeni bir yerel değişkene atamak için bir 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 tüm ifadeleri eşleştirmek için bir _null 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 is deyimde switch 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:

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:

• Özyinelemeli desen eşleştirme
• Desen eşleştirme güncelleştirmeleri
• Genişletilmiş özellik desenleri
• C# 11 - Liste desenleri
• C# 11 - Dize değişmez değeri üzerinde desen eşleşmesi Span<char>

Ayrıca bkz.

• C# işleçleri ve ifadeleri
• Desen eşleştirmeye genel bakış
• Öğretici: Tür temelli ve veri temelli algoritmalar oluşturmak için desen eşleştirmeyi kullanma