Porovnávání vzorů – výrazy isswitch a operátory and, ora not ve vzorech

is Použijte výraz, příkaz switch a výraz switch tak, aby odpovídal vstupnímu výrazu s libovolným počtem charakteristik. Jazyk C# podporuje více vzorů, včetně deklarace, typu, konstanty, relačního, vlastnosti, seznamu, var a zahození. Vzory můžete kombinovat pomocí logických andklíčových slov , ora not.

Referenční dokumentace jazyka C# dokumentuje naposledy vydané verze jazyka C#. Obsahuje také počáteční dokumentaci k funkcím ve verzi Public Preview pro nadcházející jazykovou verzi.

Dokumentace identifikuje všechny funkce, které byly poprvé představeny v posledních třech verzích jazyka nebo v aktuálních verzích Public Preview.

Návod

Informace o tom, kdy byla funkce poprvé představena v jazyce C#, najdete v článku o historii verzí jazyka C#.

Následující výrazy a příkazy jazyka C# podporují porovnávání vzorů:

• is výraz
• switch – příkaz
• výraz přepínače

Vtěchtoch

• Vzor deklarace: Zkontrolujte za běhu typ výrazu a při úspěšné shodě přiřaďte výsledek výrazu deklarované proměnné.
• Model typu: Zkontrolujte typ běhu výrazu.
• Konstantní vzor: otestujte, že výsledek výrazu se rovná zadané konstantě.
• Relační vzory: Porovnejte výsledek výrazu se zadanou konstantou.
• Logické vzory: Otestujte, že výraz odpovídá logické kombinaci vzorů.
• Vzor vlastnosti: Otestujte, jestli vlastnosti výrazu nebo pole odpovídají vnořeným vzorům.
• Poziční vzor: dekonstrukce výsledku výrazu a testování, jestli výsledné hodnoty odpovídají vnořeným vzorům.
• var pattern: spárujte libovolný výraz a přiřaďte jeho výsledek deklarované proměnné.
• Vzor zahození: odpovídá jakémukoli výrazu.
• Vzory seznamu: Otestujte, že posloupnost prvků odpovídá odpovídajícím vnořeným vzorům.

Logické, vlastnosti, poziční vzory a vzory seznamů jsou rekurzivní vzory. To znamená, že mohou obsahovat vnořené vzory.

Příklad použití těchto vzorů k sestavení algoritmu řízeného daty najdete v tématu Kurz: Použití porovnávání vzorů k sestavení algoritmů řízených typem a datových řízených algoritmy.

Vzory deklarací a typů

Pomocí deklarací a vzorů typů zkontrolujte, jestli je typ běhu výrazu kompatibilní s daným typem. Pomocí vzoru deklarace můžete také deklarovat novou místní proměnnou. Když vzor deklarace odpovídá výrazu, proměnná se přiřadí k výsledku převedeného výrazu, jak ukazuje následující příklad:

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

Vzor deklarace s typem T odpovídá výrazu, pokud je výsledek výrazu nenulový a platí některé z následujících podmínek:

• Typ běhu výsledku výrazu má převod identity na T.
• T Typ je ref struct typ a existuje převod identity z výrazu na T.
• Typ běhu výsledku výrazu je odvozen od typu T, implementuje rozhraní Tnebo jiný implicitní převod odkazu existuje z něj .T Tato podmínka zahrnuje vztahy dědičnosti a implementace rozhraní. Následující příklad ukazuje dva případy, kdy je tato podmínka pravdivá:

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

  V předchozím příkladu při prvním volání GetSourceLabel metody první vzor odpovídá hodnotě argumentu, protože typ int[] běhu argumentu Array je odvozen od typu. Při druhém volání GetSourceLabel metody typ runtime List<T> argumentu není odvozen od Array typu, ale implementuje ICollection<T> rozhraní.
• Výsledný typ při běhu výrazu je typ hodnoty s nulovými hodnotami s podkladovým typem T a Nullable<T>.HasValue je true.
• Boxování nebo unboxování existuje z běhového typu výsledku výrazu na typ T, pokud výraz není instancí ref struct.

Vzory deklarací nebere v úvahu převody definované uživatelem ani implicitní převody rozsahu.

Následující příklad ukazuje poslední dvě podmínky:

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

Pokud chcete zkontrolovat pouze typ výrazu, použijte místo názvu proměnné zahození _ , jak ukazuje následující příklad:

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

Pro tento účel použijte vzor typu, jak ukazuje následující příklad:

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

Podobně jako vzor deklarace odpovídá vzor typu výrazu, pokud je výsledek výrazu nenulový a jeho typ za běhu splňuje některou z předchozích podmínek.

Pokud chcete zkontrolovat nenulovou hodnotu, použijte negatednullkonstantní vzor, jak ukazuje následující příklad:

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

Další informace najdete v částech Vzor deklarace a Vzor typů v poznámkách k návrhu funkcí.

Konstantní vzor

Konstantní vzor je alternativní syntaxe, == pokud je pravý operand konstantou. Pomocí konstantního vzoru otestujte, jestli se výsledek výrazu rovná zadané konstantě, jak ukazuje následující příklad:

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

V konstantním vzoru můžete použít libovolný konstantní výraz, například:

• celočíselnánebo číselná literál s plovoucí desetinou čárkou
• znak
• řetězcový literál
• Logická hodnota true nebo false
• výčtová hodnota
• název deklarovaného pole const nebo místního
• null

Výraz musí být typ, který se konvertibilní na konstantní typ, s jednou výjimkou: Výraz, jehož typ je Span<char> nebo ReadOnlySpan<char> lze shodovat s konstantními řetězci.

Pomocí konstantního vzoru zkontrolujte null, jak ukazuje následující příklad:

if (input is null)
{
    return;
}

Kompilátor zaručuje, že se při vyhodnocení výrazu == nevyvolá žádný operátor x is null rovnosti přetížený uživatelem.

Ke kontrole nenulové konstanty můžete použít negovanýnull vzor, jak ukazuje následující příklad:

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

Další informace najdete v části Konstantní vzor návrhu funkce poznámky.

Relační vzory

Pomocí relačního vzoru můžete porovnat výsledek výrazu s konstantou, jak ukazuje následující příklad:

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",
};

V relačním vzoru můžete použít libovolný z relačních operátorů<, >, , <=nebo >=. Pravá část relačního vzoru musí být konstantní výraz. Konstantní výraz může být celé číslo, číslo s plovoucí desetinou čárkou, znak nebo typ výčtu.

Pokud chcete zkontrolovat, jestli je výsledek výrazu v určité oblasti, porovnáte ho se vzorem andkonjunktivu, jak ukazuje následující příklad:

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

Pokud je null výsledkem výrazu nebo se nepodaří převést na typ konstanty převodem s možnou hodnotou null nebo rozbalení, relační vzor neodpovídá výrazu.

Další informace naleznete v části Relační vzory návrhu funkce poznámka.

Logické vzory

notPomocí kombinátorů , anda orvzorů vytvořte následující logické vzory:

• Vzor negacenot, který odpovídá výrazu, pokud negovaný vzor neodpovídá výrazu. Následující příklad ukazuje, jak můžete negovat vzor konstantynull, abyste zkontrolovali, jestli je výraz nenulový:

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

• Vzor konjunktivyand, který odpovídá výrazu, když oba vzory odpovídají výrazu. Následující příklad ukazuje, jak můžete zkombinovat relační vzory a zkontrolovat, jestli je hodnota v určité oblasti:

  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",
  };
  

• Disjunktivníor vzor, který odpovídá výrazu, když některý ze vzorů odpovídá výrazu, jak ukazuje následující příklad:

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

Jak ukazuje předchozí příklad, můžete opakovaně používat kombinátory vzorů ve vzoru.

Priorita a pořadí kontroly

Kombinátory vzorů se řídí tímto pořadím na základě pořadí vazeb výrazů:

• not
• and
• or

Vzor not se nejprve sváže s operandem. Vzor and se sváže po jakékoli not vazbě vzorového výrazu. Vzor or se sváže po všech not vzorech a and vytvoří vazbu na operandy. Následující příklad se pokusí spárovat všechny znaky, které nejsou malými písmeny, a - z. Má chybu, protože not vzor se sváže před vzorem and :

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

Výchozí vazba znamená, že předchozí příklad se parsuje jako následující příklad:

// 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');

Pokud chcete chybu opravit, zadejte, že se not má vzor svázat s výrazem >= 'a' and <= 'z' :

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

Přidávání závorek je důležitější, protože vaše vzory jsou složitější. Obecně platí, že pomocí závorek objasněte vzory pro ostatní vývojáře, jak ukazuje následující příklad:

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

Poznámka:

Pořadí, ve kterém jsou kontrolovány vzory se stejným pořadím vazeb, není definováno. V době běhu je možné nejprve zkontrolovat pravé vnořené vzory více or vzorů a více and vzorů.

Další informace najdete v části Kombinátory vzorů v poznámce k návrhu funkce.

Vzor vlastností

Pomocí vzoru vlastnosti můžete shodovat vlastnosti výrazu nebo pole s vnořenými vzory, jak ukazuje následující příklad:

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

Vzor vlastnosti odpovídá výrazu, pokud je výsledek výrazu nenulový a každý vnořený vzor odpovídá odpovídající vlastnosti nebo poli výsledku výrazu.

Můžete přidat kontrolu typu za běhu a deklaraci proměnné do vzoru vlastnosti, jak ukazuje následující příklad:

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

Tento konstruktor konkrétně znamená, že prázdný vzor is { } vlastnosti odpovídá všemu, co není null, a můžete ho použít místo is not null k vytvoření proměnné: 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);
}

Vzor vlastnosti je rekurzivní vzor. Jako vnořený vzor můžete použít libovolný vzor. Pomocí vzoru vlastnosti můžete shodovat části dat s vnořenými vzory, jak ukazuje následující příklad:

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

Předchozí příklad používá kombinátoror a typy záznamů.

Můžete odkazovat na vnořené vlastnosti nebo pole v rámci vzoru vlastnosti. Tato funkce se označuje jako vzor rozšířených vlastností. Můžete například refaktorovat metodu z předchozího příkladu do následujícího ekvivalentního kódu:

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

Další informace naleznete v části Vzor vlastnosti návrhu funkce poznámky a rozšířené vzory vlastností návrhu návrhu.

Návod

Chcete-li zlepšit čitelnost kódu, použijte pravidlo stylu Zjednodušit vzor vlastností (IDE0170). Navrhuje místa pro použití vzorů rozšířených vlastností.

Poziční vzor

Pomocí pozičního vzoru dekonstrukujte výraz a shodujte výsledné hodnoty s odpovídajícími vnořenými vzory, jak ukazuje následující příklad:

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",
};

V předchozím příkladu typ výrazu obsahuje dekonstrukční metodu, kterou vzor používá k dekonstrukci výsledku výrazu.

Důležité

Pořadí členů v pozičním vzoru musí odpovídat pořadí parametrů v Deconstruct metodě. Kód vygenerovaný pro poziční vzor volá metodu Deconstruct .

Můžete také spárovat výrazy typů řazené kolekce členů proti pozičním vzorům. Pomocí tohoto přístupu můžete spárovat více vstupů s různými vzory, jak ukazuje následující příklad:

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

Předchozí příklad používá relační a logické vzory.

Názvy elementů řazené kolekce členů a Deconstruct parametrů můžete použít v pozičním vzoru, jak ukazuje následující příklad:

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

Poziční vzor můžete rozšířit také některým z následujících způsobů:

• Přidejte kontrolu typu za běhu a deklaraci proměnné, jak ukazuje následující příklad:

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

  Předchozí příklad používá poziční záznamy , které implicitně poskytují metodu Deconstruct .

• Použijte vzor vlastnosti v rámci pozičního vzoru, jak ukazuje následující příklad:

  public record WeightedPoint(int X, int Y)
  {
      public double Weight { get; set; }
  }
  
  static bool IsInDomain(WeightedPoint point) => point is (>= 0, >= 0) { Weight: >= 0.0 };
  

• Zkombinujte dvě předchozí použití, jak ukazuje následující příklad:

  if (input is WeightedPoint (> 0, > 0) { Weight: > 0.0 } p)
  {
      // ..
  }
  

Poziční vzor je rekurzivní vzor. To znamená, že jako vnořený vzor můžete použít libovolný vzor.

Další informace naleznete v části Poziční vzor návrhu návrhu.

var vzor

Vzor použijte ke shodě libovolného var výrazu, včetně nulla přiřazení výsledku k nové místní proměnné, jak ukazuje následující příklad:

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

Vzor var je užitečný v případě, že potřebujete dočasnou proměnnou v rámci logického výrazu k uložení výsledku průběžných výpočtů. Vzor můžete použít var také v případě, že potřebujete provádět další kontroly v when případě switch , že chrání výraz nebo příkaz, jak ukazuje následující příklad:

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

V předchozím příkladu je vzor var (x, y) ekvivalentní pozičnímu vzoru(var x, var y).

V modelu var je typem deklarované proměnné typ kompilace výrazu, který odpovídá vzoru.

Další informace naleznete v části Var vzor návrhu funkce poznámka.

Zahodit vzor

Vzor zahození_ použijte ke shodě libovolného výrazu, včetně null, jak ukazuje následující příklad:

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

V předchozím příkladu zpracovává null vzor zahození a jakákoli celočíselná hodnota, která nemá odpovídající člen výčtu DayOfWeek . Tato záruka zajistí, že switch výraz v příkladu zpracuje všechny možné vstupní hodnoty. Pokud ve výrazu switch nepoužíváte vzor zahození a žádný ze vzorů výrazu neodpovídá vstupu, modul runtime vyvolá výjimku. Kompilátor vygeneruje upozornění, pokud switch výraz nezpracuje všechny možné vstupní hodnoty.

Vzor zahození nemůže být vzorem ve is výrazu switch ani příkazu. V takových případech použijte vzor var s zahozením: . var _ Vzor zahození může být vzorem ve výrazu switch .

Další informace najdete v části Zahodit vzor návrhu funkce poznámky.

Vzor závorek

Závorky můžete umístit kolem libovolného vzoru. Obvykle to uděláte tak, že zvýrazníte nebo změníte prioritu v logických vzorech, jak ukazuje následující příklad:

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

Vzory seznamů

Můžete se shodovat s maticí nebo seznamem s posloupností vzorů, jak ukazuje následující příklad:

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

Jak ukazuje předchozí příklad, vzor seznamu odpovídá, když každý vnořený vzor odpovídá odpovídajícímu prvku vstupní sekvence. V rámci vzoru seznamu můžete použít libovolný vzor. Chcete-li spárovat jakýkoli prvek, použijte vzor zahození nebo, pokud chcete také zachytit element, použijte vzor var, jak ukazuje následující příklad:

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.

Předchozí příklady odpovídají celé vstupní sekvenci se vzorem seznamu. Pokud chcete shodovat prvky pouze na začátku nebo/a na konci vstupní sekvence, použijte vzor, jak ukazuje následující příklad:

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

Vzor řezu odpovídá nule nebo více prvků. V vzoru seznamu můžete použít maximálně jeden vzor řezu. Vzor řezu se může zobrazit jenom v vzoru seznamu.

Podpattern můžete také vnořit do vzoru řezu, jak ukazuje následující příklad:

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

Další informace najdete v poznámce k návrhu funkcí seznamu vzorů .

specifikace jazyka C#

Další informace najdete v části Vzory a porovnávání vzorů specifikace jazyka C#.

Informace o funkcích přidaných v jazyce C# 9 a novějších verzích najdete v následujících poznámkách k návrhu funkcí:

• Aktualizace porovnávání vzorů
• vzory rozšířených vlastností
• Vzory seznamů
• Shoda Span<char> vzorů u řetězcového literálu

Viz také

• Operátory a výrazy jazyka C#
• Přehled porovnávání vzorů
• Kurz: Použití porovnávání vzorů k vytváření algoritmů řízených typem a datových řízených algoritmy