Delen via

11 Patronen en patroonkoppeling

11.1 Algemeen

Een patroon is een syntactische vorm die kan worden gebruikt met de is operator (§12.14.12), in een switch_statement (§13.8.3) en in een switch_expression (§12.11) om de vorm van gegevens uit te drukken waarmee binnenkomende gegevens moeten worden vergeleken. Patronen kunnen recursief zijn, zodat delen van de gegevens kunnen worden vergeleken met subpatronen.

Een patroon wordt getest op basis van een waarde in een aantal contexten:

  • In een switch-instructie wordt het patroon van een caselabel getest op basis van de expressie van de switch-instructie .
  • In een is-pattern-operator wordt het patroon aan de rechterkant getest op de expressie aan de linkerkant.
  • In een switchexpressie wordt het patroon van een switch_expression_arm getest op basis van de expressie aan de linkerkant van de switch-expressie.
  • In geneste contexten wordt het subpatroon getest op waarden die zijn opgehaald uit eigenschappen, velden of geïndexeerd van andere invoerwaarden, afhankelijk van het patroonformulier.

De waarde waarmee een patroon wordt getest, wordt de invoerwaarde van het patroon genoemd.

11.2 Patroonformulieren

11.2.1 Algemeen

Een patroon kan een van de volgende vormen hebben:

pattern
    : declaration_pattern
    | constant_pattern
    | var_pattern
    | positional_pattern
    | property_pattern
    | discard_pattern
    ;

Sommige patronenkunnen resulteren in de declaratie van een lokale variabele.

Elk patroonformulier definieert de set typen voor invoerwaarden waarop het patroon kan worden toegepast. Een patroon P is van toepassing op een type T als T het een van de typen is waarvan de waarden overeenkomen met het patroon. Het is een compilatiefout als een patroon P wordt weergegeven in een programma dat overeenkomt met een patrooninvoerwaarde (§11.1) van het type T als P dit niet van toepassing is op T.

Voorbeeld: In het volgende voorbeeld wordt een compilatiefout gegenereerd omdat het type v compileertijd is TextReader. Een variabele van het type TextReader kan nooit een waarde hebben die compatibel is met string:

TextReader v = Console.In; // compile-time type of 'v' is 'TextReader'
if (v is string) // compile-time error
{
    // code assuming v is a string
}

Het volgende genereert echter geen compilatietijdfout omdat het type v compileertijd is object. Een variabele van het type object kan een waarde hebben die compatibel is met string:

object v = Console.In;
if (v is string s)
{
    // code assuming v is a string
}

eindvoorbeeld

Elk patroonformulier definieert de set waarden waarvoor het patroon overeenkomt met de waarde tijdens runtime.

De volgorde van evaluatie van bewerkingen en bijwerkingen tijdens patroonkoppeling (aanroepen naar Deconstruct, eigenschapstoegang en aanroepen van methoden in System.ITuple) is niet opgegeven.

11.2.2 Declaratiepatroon

Een declaration_pattern wordt gebruikt om te testen of een waarde een bepaald type heeft en, als de test slaagt, om desgewenst de waarde in een variabele van dat type op te geven.

declaration_pattern
    : type simple_designation
    ;
simple_designation
    : discard_designation
    | single_variable_designation
    ;
discard_designation
    : '_'
    ;
single_variable_designation
    : identifier
    ;

Een simple_designation met het token _ wordt beschouwd als een discard_designation in plaats van een single_variable_designation.

Het runtimetype van de waarde wordt getest op basis van het type in het patroon met behulp van dezelfde regels die zijn opgegeven in de operator is-type (§12.14.12.1). Als de test slaagt, komt het patroon overeen met die waarde. Het is een compilatiefout als het type een type nullable waarde is (§8.3.12) of een nullable verwijzingstype (§8.9.3). Dit patroonformulier komt nooit overeen met een null waarde.

Opmerking: De is-type-expressie e is T en het declaratiepatroon e is T _ zijn equivalent wanneer T het geen null-type is. eindnotitie

Gezien een patrooninvoerwaarde (§11.1) e, als de simple_designationis discard_designation, wordt een verwijdering aangegeven (§9.2.9.2) en de waarde van e is niet gebonden aan iets. (Hoewel een gedeclareerde variabele met de naam _ op dat moment mogelijk binnen het bereik valt, wordt die benoemde variabele niet gezien in deze context.) Als de simple_designationsingle_variable_designation is, wordt een lokale variabele (§9.2.9) van het opgegeven type met de opgegeven id geïntroduceerd. Aan die lokale variabele wordt de waarde van de invoerwaarde van het patroon toegewezen wanneer het patroon overeenkomt met de waarde.

Bepaalde combinaties van het statische type van de patrooninvoerwaarde en het opgegeven type worden beschouwd als niet compatibel en resulteren in een compilatiefout. Een waarde van het statische type E wordt geacht een patroon te zijn dat compatibel is met het type T als er een identiteitsconversie bestaat, een impliciete of expliciete verwijzingsconversie, een boksconversie of een conversie van boksen opheffen vanE, Tof als E het een T open type is (§8.4.3). Een declaratiepatroon met de naam van een type T is van toepassing op elk type E waarvoor E een patroon compatibel is met T.

Opmerking: de ondersteuning voor open typen kan het handigst zijn bij het controleren van typen die struct- of klassetypen kunnen zijn, en boksen moet worden vermeden. eindnotitie

Voorbeeld: Het declaratiepatroon is handig voor het uitvoeren van runtime-typetests van referentietypen en vervangt het idioom

var v = expr as Type;
if (v != null) { /* code using v */ }

met de iets beknopter

if (expr is Type v) { /* code using v */ }

eindvoorbeeld

Voorbeeld: Het declaratiepatroon kan worden gebruikt om waarden van null-typen te testen: een waarde van het type Nullable<T> (of een vakken T) komt overeen met een typepatroon T2 id als de waarde niet null is en T2 of Teen basistype of interface van T. Bijvoorbeeld in het codefragment

int? x = 3;
if (x is int v) { /* code using v */ }

De voorwaarde van de if instructie is true tijdens runtime en de variabele v bevat de waarde 3 van het type int in het blok. Nadat het blok is bereikt, is de variabele v binnen het bereik, maar niet zeker toegewezen. eindvoorbeeld

11.2.3 Constant patroon

Een constant_pattern wordt gebruikt om de waarde van een patrooninvoerwaarde (§11.1) te testen op basis van de opgegeven constante waarde.

constant_pattern
    : constant_expression
    ;

Een constant patroon P is van toepassing op een type T als er een impliciete conversie van de constante expressie van P het type Tis.

Voor een constant patroon Pis de geconverteerde waarde

  • als het type van de patrooninvoerwaarde een integraal type of een opsommingstype is, wordt de constante waarde van het patroon geconverteerd naar dat type; anders
  • als het type van de invoerwaarde van het patroon de null-versie van een integraal type of een enumtype is, wordt de constante waarde van het patroon geconverteerd naar het onderliggende type; anders
  • de waarde van de constante waarde van het patroon.

Gegeven een patrooninvoerwaarde e en een constant patroon P met geconverteerde waarde v,

  • als e een integraal type of opsommingstype of een null-vorm van een van deze heeft en v een integraal type heeft, komt het patroon P overeen met de waarde e als het resultaat van de expressie e == v istrue; anders
  • het patroon Povereenkomt met de waarde e als object.Equals(e, v) deze retourneert true.

Voorbeeld: De switch instructie in de volgende methode maakt gebruik van vijf constante patronen in de caselabels.

static decimal GetGroupTicketPrice(int visitorCount)
{
    switch (visitorCount) 
    {
        case 1: return 12.0m;
        case 2: return 20.0m;
        case 3: return 27.0m;
        case 4: return 32.0m;
        case 0: return 0.0m;
        default: throw new ArgumentException(...);
    }
}

eindvoorbeeld

11.2.4 Var pattern

Een var_patternkomt overeen met elke waarde. Dat wil gezegd, een patroonkoppelingsbewerking met een var_pattern altijd slaagt.

Een var_pattern is van toepassing op elk type.

var_pattern
    : 'var' designation
    ;
designation
    : simple_designation
    | tuple_designation
    ;
tuple_designation
    : '(' designations? ')'
    ;
designations
    : designation (',' designation)*
    ;

Uitgaande van een patrooninvoerwaarde (§11.1) e, als aanduidingis discard_designation, wordt een verwijdering aangegeven (§9.2.9.2) en de waarde van e is niet gebonden aan iets. (Hoewel op dat moment een gedeclareerde variabele met die naam mogelijk binnen het bereik valt, wordt die benoemde variabele niet gezien in deze context.) Als de aanduidingsingle_variable_designation is, is de waarde van e tijdens runtime gebonden aan een nieuw geïntroduceerde lokale variabele (§9.2.9) van die naam waarvan het type het statische type e is en de invoerwaarde van het patroon wordt toegewezen aan die lokale variabele.

Dit is een fout als de naam var zou binden aan een type waarbij een var_pattern wordt gebruikt.

Als aanduiding een tuple_designation is, is het patroon gelijk aan een positional_pattern (§11.2.5) van de vormaanduiding(var, ... ) indien de aanduidingenin de tuple_designation worden gevonden. Het patroon var (x, (y, z)) is bijvoorbeeld gelijk aan (var x, (var y, var z)).

11.2.5 Positioneel patroon

Een positional_pattern controleert of de invoerwaarde niet nullis, roept een geschikte Deconstruct methode aan (§12.7) en voert verdere patroonkoppelingen uit op de resulterende waarden. Het ondersteunt ook een tuple-achtige patroonsyntaxis (zonder het type dat wordt opgegeven) wanneer het type van de invoerwaarde hetzelfde is als het type dat Deconstructhet type invoerwaarde bevat, of als het type van de invoerwaarde een tupletype is, of als het type van de invoerwaarde is object of System.ITuple als het runtimetype van de expressie wordt System.ITuplegeïmplementeerd.

positional_pattern
    : type? '(' subpatterns? ')' property_subpattern? simple_designation?
    ;
subpatterns
    : subpattern (',' subpattern)*
    ;
subpattern
    : pattern
    | identifier ':' pattern
    ;

Gezien een overeenkomst van een invoerwaarde met desubpatronen) van het patroontype(, wordt een methode geselecteerd door in het type te zoeken naar toegankelijke declaraties van Deconstruct en er een te selecteren met dezelfde regels als voor de deconstructiedeclaratie. Het is een fout als een positional_pattern het type weglaat, één subpatroon zonder id heeft, geen property_subpattern heeft en geen simple_designation heeft. Dit onderscheidt zich tussen een constant_pattern die haakjes en een positional_pattern is. Als u de waarden wilt extraheren die overeenkomen met de patronen in de lijst,

  • Als u het type invoerexpressie weglaat en het type van de invoerexpressie een tupletype is, moet het aantal subpatronen gelijk zijn aan de kardinaliteit van de tuple. Elk tuple-element wordt vergeleken met het bijbehorende subpatroon en de overeenkomst slaagt als dit allemaal lukt. Als een subpatroon een id heeft, noemt die een tuple-element op de bijbehorende positie in het tupletype.
  • Als er anders een geschikt Deconstruct lid van het type bestaat, is het een compilatiefout als het type invoerwaarde niet compatibel is met het type. Tijdens runtime wordt de invoerwaarde getest op basis van het type. Als dit mislukt, mislukt de positionele patroonovereenkomst. Als dit lukt, wordt de invoerwaarde geconverteerd naar dit type en Deconstruct wordt deze aangeroepen met nieuwe door compiler gegenereerde variabelen om de uitvoerparameters te ontvangen. Elke waarde die is ontvangen, wordt vergeleken met het bijbehorende subpatroon en de overeenkomst slaagt als al deze waarden slagen. Als een subpatroon een id heeft, wordt dan een parameter op de bijbehorende positie van Deconstruct.
  • Als het type wordt weggelaten en de invoerwaarde van het type object is of een type waarnaar kan worden geconverteerd System.ITuple door een impliciete verwijzingsconversie en er geen id wordt weergegeven onder de subpatronen, wordt de overeenkomst gebruikt System.ITuple.
  • Anders is het patroon een compilatiefout.

De volgorde waarin subpatronen tijdens runtime worden vergeleken, is niet opgegeven en een mislukte overeenkomst probeert mogelijk niet alle submappen te vinden.

Voorbeeld: Hier wordt een expressieresultaat gedeconstrueerd en worden de resulterende waarden vergeleken met de bijbehorende geneste patronen:

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

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

eindvoorbeeld

Voorbeeld: De namen van tuple-elementen en Deconstruct-parameters kunnen als volgt worden gebruikt in een positioneel patroon:

var numbers = new List<int> { 10, 20, 30 };
if (SumAndCount(numbers) is (Sum: var sum, Count: var count))
{
    Console.WriteLine($"Sum of [{string.Join(" ", numbers)}] is {sum}");
}

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

De geproduceerde uitvoer is

Sum of [10 20 30] is 60

eindvoorbeeld

11.2.6 Eigenschapspatroon

Een property_pattern controleert of de invoerwaarde niet nullis en komt recursief overeen met waarden die zijn geëxtraheerd door het gebruik van toegankelijke eigenschappen of velden.

property_pattern
    : type? property_subpattern simple_designation?
    ;
property_subpattern
    : '{' '}'
    | '{' subpatterns ','? '}'
    ;

Dit is een fout als een subpatroon van een property_pattern geen id bevat.

Het is een compilatiefout als het type een type nullable waarde is (§8.3.12) of een nullable verwijzingstype (§8.9.3).

Opmerking: een null-controlepatroon valt buiten een triviaal eigenschapspatroon. Als u wilt controleren of de tekenreeks s niet null is, kunt u een van de volgende formulieren schrijven:

#nullable enable
string s = "abc";
if (s is object o) ...  // o is of type object
if (s is string x1) ... // x1 is of type string
if (s is {} x2) ...     // x2 is of type string
if (s is {}) ...

eindnotitie Gezien een overeenkomst van een expressie e met het patroontype{property_pattern_list}, is het een compilatiefout als de expressie e niet compatibel is met het type T dat door het type is aangewezen. Als het type afwezig is, wordt ervan uitgegaan dat het type het statische type e is. Elk van de id's die aan de linkerkant van de property_pattern_list worden weergegeven, wijst een toegankelijk leesbaar eigendom of veld van T aan. Als de simple_designation van de property_pattern aanwezig is, declareert deze een patroonvariabele van het type T.

Tijdens runtime wordt de expressie getest op T. Als dit mislukt, mislukt de overeenkomst van het eigenschappenpatroon en is falsehet resultaat. Als dit lukt, wordt elk property_subpattern veld of eigenschap gelezen en wordt de waarde ervan vergeleken met het bijbehorende patroon. Het resultaat van de hele overeenkomst is false alleen als het resultaat van een van deze is false. De volgorde waarin subpatronen worden vergeleken, is niet opgegeven en een mislukte overeenkomst test mogelijk niet alle subpatronen tijdens runtime. Als de overeenkomst slaagt en de simple_designation van de property_pattern een single_variable_designation is, wordt aan de gedeclareerde variabele de overeenkomende waarde toegewezen.

De property_pattern kan worden gebruikt voor patroonovereenkomsten met anonieme typen.

Voorbeeld:

var o = ...;
if (o is string { Length: 5 } s) ...

eindvoorbeeld

Voorbeeld: Een controle van een runtimetype en een variabeledeclaratie kunnen als volgt worden toegevoegd aan een eigenschapspatroon:

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

De geproduceerde uitvoer is

Hello
Hi!
12345
abc

eindvoorbeeld

11.2.7 Patroon negeren

Elke expressie komt overeen met het verwijderingspatroon, wat resulteert in de waarde van de expressie die wordt verwijderd.

discard_pattern
    : '_'
    ;

Het is een compilatiefout voor het gebruik van een verwijderingspatroon in een relational_expression van het formulier relational_expressionispatroon of als het patroon van een switch_label.

Opmerking: In dergelijke gevallen gebruikt u een var_pattern met een verwijdering var _om een expressie te vinden. eindnotitie

Voorbeeld:

Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday));
Console.WriteLine(GetDiscountInPercent(null));
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10));

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

De geproduceerde uitvoer is

5.0
0.0
0.0

Hier wordt een verwijderingspatroon gebruikt om te verwerken null en een geheel getal dat niet het bijbehorende lid van de DayOfWeek opsomming heeft. Dit garandeert dat de switch expressie alle mogelijke invoerwaarden verwerkt. eindvoorbeeld

11.3 Patroonsubsumption

In een switch-instructie is het een fout als het patroon van een case wordt aangevuld met de voorgaande reeks niet-bewaakte zaken (§13.8.3). Informeel betekent dit dat elke invoerwaarde zou overeenkomen met een van de vorige gevallen. De volgende regels definiëren wanneer een set patronen een bepaald patroon samenvat:

Een patroon Pkomt overeen met een constante K als de specificatie voor het runtimegedrag van dat P patroon overeenkomt K.

Een set patronen Qbevat een patroon P als een van de volgende voorwaarden geldt:

  • P is een constant patroon en een van de patronen in de set Q komt overeen met Pde geconverteerde waarde
  • P is een var-patroon en de set patronen Q is volledig (§11.4) voor het type van de patrooninvoerwaarde (§11.1), en de patrooninvoerwaarde is niet van een null-type of een bepaald patroon komt Q overeen null.
  • P is een declaratiepatroon met type T en de set patronen Q is volledig voor het type T (§11.4).

11.4 Patroon volledigheid

Informeel is een set patronen volledig voor een type als, voor elke mogelijke waarde van dat type anders dan null, een bepaald patroon in de set van toepassing is. De volgende regels definiëren wanneer een set patronen volledig is voor een type:

Een reeks patronen Q is volledig voor een type T als een van de volgende voorwaarden geldt:

  1. T is een integraal of opsommingstype, of een null-versie van een van deze, en voor elke mogelijke waarde van Thet niet-nulle onderliggende type komt een bepaald patroon Q overeen met die waarde; of
  2. Een bepaald patroon is Q een var-patroon; of
  3. Een patroon in Q is een declaratiepatroon voor het type Den er is een identiteitsconversie, een impliciete verwijzingsconversie of een boksconversie van T naar D.

Voorbeeld:

static void M(byte b)
{
    switch (b) {
        case 0: case 1: case 2: ... // handle every specific value of byte
            break;
        // error: the pattern 'byte other' is subsumed by the (exhaustive)
        // previous cases
        case byte other: 
            break;
    }
}

eindvoorbeeld

  • Last updated on