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

Bir giriş ifadesini herhangi bir sayıdaki özelliklerle eşleştirmek için ifadeyi, switch deyimini ve switch ifadesini kullanın.is C# bildirim, tür, sabit, ilişkisel, özellik, liste, var ve atma dahil olmak üzere birden çok deseni destekler. , orve notBoole mantıksal anahtar sözcüklerini kullanarak desenleri andbirleştirebilirsiniz.

C# dili başvuru belgesi, C# dilinin en son yayımlanan sürümünü gösterir. Ayrıca, yaklaşan dil sürümü için genel önizlemelerdeki özelliklere yönelik ilk belgeleri içerir.

Belgelerde ilk olarak dilin son üç sürümünde veya geçerli genel önizlemelerde sunulan tüm özellikler tanımlanır.

İpucu

Bir özelliğin C# dilinde ilk tanıtıldığı zamanları bulmak için C# dil sürümü geçmişi makalesine bakın.

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ü denetleyin ve eşleşme başarılı olursa, bildirilen değişkene bir ifade sonucu atayın.
• Tür deseni: bir ifadenin çalışma zamanı türünü denetleyin.
• Sabit desen: bir ifade sonucunun belirtilen sabite eşit olduğunu test edin.
• İlişkisel desenler: bir ifade sonucunu belirtilen sabitle karşılaştırın.
• Mantıksal desenler: bir ifadenin desenlerin mantıksal bileşimiyle eşleştiklerini test edin.
• Özellik deseni: bir ifadenin özelliklerinin veya alanlarının iç içe desenlere uygun olup olmadığını test edin.
• Konumsal desen: bir ifade sonucunun yapısını kaldırın ve sonuçta elde edilen değerlerin iç içe desenlerle eşleşip eşleşmediğini test edin.
• var desen: herhangi bir ifadeyi eşleştirin ve sonucunu bildirilen değişkene atayın.
• Discard pattern: herhangi bir ifadeyle eşleşme.
• Liste desenleri: Bir öğe dizisinin ilgili iç içe desenlere uygun olduğunu test edin.

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 bir ö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 desenlerini kullanın. Bildirim deseniyle, yeni bir yerel değişken de bildirebilirsiniz. Bir bildirim deseni bir ifadeyle eşleştiğinde, aşağıdaki örnekte gösterildiği gibi değişken dönüştürülen ifade sonucuna 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:

• Bir ifade sonucunun çalışma zamanı türüne kimlik dönüşümü vardır: T.
• Tür T bir ref struct türdür ve ifadeden Töğesine bir kimlik dönüştürmesi vardır.
• 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. Bu koşul devralma ilişkilerini ve arabirim uygulamalarını kapsar. 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.
• İfade sonucunun çalışma zamanı türü, temel null atanabilir bir değer türüdür ve T'nın değeri Nullable<T>.HasValue olur.
• İfade bir örneği olmadığında, ifade sonucunun çalışma zamanı türünden türe bir T veya ref struct dönüştürmesi vardır.

Bildirim desenleri kullanıcı tanımlı dönüştürmeleri veya örtük aralık dönüştürmelerini dikkate almaz.

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
}

Bir ifadenin yalnızca türünü denetlemek için, aşağıdaki örnekte gösterildiği gibi değişkenin adının yerine bir atma _ kullanın:

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 kullanın:

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 negatifleştirilmişnullbir sabit desen kullanın:

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

Sabit desen, sağ işlenen sabit olduğunda kullanılan alternatif bir söz dizimidir==. 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ın:

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
• 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ü Span<char> sabit dizelerle eşleştirilebilen veya ReadOnlySpan<char> eşleştirilebilen bir ifade.

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ın:

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

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

• 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 şu sırayı izler:

• 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ğlanı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');

Hatayı düzeltmek için desenin not ifadeye bağlanmasını >= 'a' and <= 'z' istediğinizi belirtin:

// 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 özellik deseni kullanın:

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

İfade 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 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."),
};

Bu yapı, özellikle boş özellik deseninin is { } null olmayan her şeyle eşleşir ve bir değişken oluşturmak yerine is not null bunu kullanabileceğiniz anlamına gelir: somethingPossiblyNull is { } somethingDefinitelyNotNull.

if (GetSomeNullableStringValue() is { } nonNullValue) // Empty property pattern with variable creation
{
    Console.WriteLine("NotNull:" + nonNullValue);
}
else
{
    nonNullValue = "NullFallback"; // we can access the variable here.
    Console.WriteLine("it was null, here's the fallback: " + nonNullValue);
}

Özellik düzeni özyinelemeli bir desendir. 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

Kod okunabilirliğini geliştirmek için Özellik desenini basitleştirme (IDE0170) stil kuralını kullanın. Genişletilmiş özellik desenlerinin kullanılacağı yerleri önerir.

Konumsal desen

Aşağıdaki örnekte gösterildiği gibi, bir ifadenin yapısını çözmek ve sonuçta elde edilen değerleri ilgili iç içe desenlerle eşleştirmek için konumsal desen kullanın:

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ü, desenin bir ifade sonucunun yapısını çözmek için kullandığı Deconstruct yöntemini içerir.

Önemli

Konumsal desendeki üyelerin sırası yöntemindeki parametrelerin sırasıyla Deconstruct eşleşmelidir. Konumsal desen için oluşturulan kod yöntemini çağırır Deconstruct .

Ayrıca tanımlama grubu türlerinin ifadelerini konumsal desenlerle eşleştirebilirsiniz. Bu yaklaşımı kullanarak, aşağıdaki örnekte gösterildiği gibi birden çok girişi çeşitli desenlerle 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

var 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 desen kullanın:

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ü, desenin eşlediği 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ın:

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, atma deseni işleçlerini null ve numaralandırmanın ilgili üyesi DayOfWeek olmayan herhangi bir tamsayı değerini işler. Bu garanti, örnekteki bir switch ifadenin tüm olası giriş değerlerini işlemesini sağlar. İ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

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 karşılık gelen öğesiyle eşleştiğinde bir liste deseni eşleşir. Liste deseni içindeki herhangi bir deseni kullanabilirsiniz. Herhangi bir öğeyi eşleştirmek için atma desenini kullanın veya öğeyi yakalamak istiyorsanız, aşağıdaki örnekte gösterildiği gibi 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# 9 ve sonraki sürümlere eklenen özellikler hakkında bilgi için aşağıdaki özellik teklifi notlarını inceleyin:

• Desen eşleştirme güncelleştirmeleri
• Genişletilmiş özellik desenleri
• Liste desenleri
• 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