Eigenschaps- en positionele patronen

Tip

Dit artikel maakt deel uit van de sectie Grondbeginselen voor ontwikkelaars die al ten minste één programmeertaal kennen en C# leren. Begin met het overzicht van patroonkoppeling als patronen nieuw voor u zijn. Zie eigenschapspatronen en positionele patronen in de taalreferentie voor volledige taalregels.

Eigenschapspatronen en positionele patronen testen beide delen van een waarde. Het verschil is hoe deze onderdelen worden geïdentificeerd:

  • Een eigenschapspatroon noemt de eigenschappen of velden die moeten worden getest.
  • Een positioneel patroon identificeert waarden op basis van hun volgorde.

Een deconstructie geeft een geordende set onderdeelwaarden weer. Een tuple heeft al een elementvolgorde; zie deconstruct tuples. Voor een ander type definieert een Deconstruct methode welke onderdeelwaarden worden weergegeven en de volgorde ervan.

Namen en posities vergelijken

Met het volgende eigenschapspatroon worden twee benoemde eigenschappen van een weersleespatroon getest, met temperatuurwaarden in graden Celsius:

static bool IsHotAndHumid(WeatherReading reading) =>
    reading is { TemperatureC: > 30, HumidityPercent: > 70 };

sealed record WeatherReading(int TemperatureC, int HumidityPercent);

Met het volgende positionele patroon wordt een signaalwaarde getest, gevolgd door een Booleaanse waarde:

static string GetCrossingInstruction(
    PedestrianSignal signal, bool crossingIsClear) =>
    (signal, crossingIsClear) switch
    {
        (PedestrianSignal.Walk, true) => "Cross now",
        (PedestrianSignal.Walk, false) => "Wait for the crossing to clear",
        _ => "Wait for the walk signal"
    };

enum PedestrianSignal
{
    Stop,
    Walk
}

Het eigenschapspatroon identificeert de invoer door de namen TemperatureC en HumidityPercent. De kruisingscode maakt een tuple van de afzonderlijke signal waarden en crossingIsClear waarden. Het tuple-patroon identificeert deze waarden vervolgens op volgorde: signal eerste en crossingIsClear tweede. Een positioneel patroon is hier zeer geschikt, omdat deze nieuw aangemaakte tuple slechts twee waarden heeft en de volgorde ervan een duidelijke betekenis heeft voor de beslissing over de kruising.

Kies een eigenschapspatroon wanneer ledennamen helpen de test uit te leggen. Eigenschapspatronen zijn meestal duidelijker voor klassen, structs en records. Kies een positioneel patroon wanneer de volgorde de waarden al een duidelijke betekenis geeft. Positionele patronen zijn het handigst bij tuples, die meerdere gerelateerde waarden combineren in één waarde met een vaste volgorde.

Geneste invoer volgen in recursieve patronen

Eigenschaps- en positionele patronen zijn recursieve patronen: ze passen een ander patroon toe op elke eigenschap, elk veld of de positie die ze selecteren. De geselecteerde waarde dient als invoer voor dat geneste patroon.

In IsHotAndHumidis de reading expressie de invoer voor het eigenschapspatroon. C# evalueert die expressie voordat deze overeenkomt. Het patroon haalt twee waarden op uit het resulterende object:

  • Het relationele patroon > 30 test de waarde van TemperatureC.
  • Het relationele patroon > 70 test de waarde van HumidityPercent.

Een buitenste typetest is optioneel en recursieve patroonclausules kunnen leeg zijn. Het lege eigenschapspatroon { } komt bijvoorbeeld overeen met een niet-null geëvalueerde waarde.

Eigenschaps- en positiepatronen komen alleen overeen met niet-null geëvalueerde waarden. Wanneer null deel uitmaakt van het invoerdomein, kies dan een recursief patroon dat eerst op een niet-null-waarde controleert:

static string DescribeNullableInput(object? value)
{
    if (value is not { } nonNullValue)
    {
        return "No value";
    }

    return nonNullValue switch
    {
        DateTime => "Date",
        string => "Text",
        _ => "Another type"
    };
}

De invoerexpressie is value. C# evalueert het en het { } eigenschapspatroon test de resulterende waarde voor niet-null voordat u deze toewijst aan nonNullValue. Met de volgende switchexpressie kunt u vervolgens meerdere mogelijke runtimetypen testen. De typepatronen DateTime en string hebben geen naam, omdat de methode elk type alleen hoeft te identificeren en de waarde ervan niet hoeft vast te leggen.

Wanneer recursieve patroonclausules geneste patronen bevatten, wordt elke geselecteerde eigenschap, elk veld of elke positie de invoer voor het geneste patroon.

U kunt een typetest toevoegen vóór de accolades wanneer de invoerexpressie verschillende typen kan produceren. U kunt ook een memberpad gebruiken om een geneste eigenschap te testen:

static string DescribeDate(object? value) =>
    value switch
    {
        DateTime { Date.DayOfWeek:
            DayOfWeek.Saturday or DayOfWeek.Sunday } => "Weekend date",
        DateTime => "Weekday date",
        null => "No date",
        _ => "Not a date"
    };

value is de invoerexpressie. C# evalueert dit eerst en controleert of de resulterende waarde een DateTime is. De Date eigenschapswaarde wordt vervolgens de invoer voor de toegang tot het DayOfWeek lid. Ten slotte wordt de DayOfWeek waarde de invoer voor het logische patroon waarmee twee constanten worden getest. De overeenkomst is geslaagd wanneer de buitenste waarde het opgegeven type heeft en elk object dat nodig is langs het ledenpad niet null is.

Patronen vergelijken met vertakkingsinstructies

Met de eerdere DescribeDate methode worden vier resultaten weergegeven als patronen:

static string DescribeDate(object? value) =>
    value switch
    {
        DateTime { Date.DayOfWeek:
            DayOfWeek.Saturday or DayOfWeek.Sunday } => "Weekend date",
        DateTime => "Weekday date",
        null => "No date",
        _ => "Not a date"
    };

De volgende methode produceert dezelfde resultaten met een reeks imperatieve vertakkingsinstructies:

static string DescribeDateWithBranches(object? value)
{
    if (value is DateTime date)
    {
        if (date.DayOfWeek == DayOfWeek.Saturday ||
            date.DayOfWeek == DayOfWeek.Sunday)
        {
            return "Weekend date";
        }

        return "Weekday date";
    }

    if (value is null)
    {
        return "No date";
    }

    return "Not a date";
}

De op patronen gebaseerde versie houdt de mogelijke resultaten bij elkaar wanneer verschillende vertakkingen het type en de vorm van een waarde testen. De imperatieve versie maakt elke test en retourstap expliciet. Voor één voorwaarde kan elk formulier er ongeveer als volgt uitzien. Naarmate het aantal gerelateerde vertakkingen groeit, kunnen patronen de alternatieven gemakkelijker te vergelijken maken.

Zie ook

  • Laatst bijgewerkt om