Tuples en andere typen deconstrueren

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.

Met een deconstructie worden de afzonderlijke onderdelen van een waarde — de componenten — toegewezen aan meerdere variabelen in één bewerking. De onderdelen van een tuple zijn de elementen, die toegankelijk zijn via hun positie. Een ander type kan onderdelen beschikbaar maken door een Deconstruct methode te definiëren. Positionele records, die hun eigenschappen als constructorachtige parameters declareren, krijgen automatisch een Deconstruct-methode.

Tuples deconstrueren

Stel dat een methode een tuple retourneert met plaatsgegevens. U kunt elk onderdeel één voor één lezen:

var cityData = QueryCityData("New York City");
var city = cityData.City;
var population = cityData.Population;
var area = cityData.Area;

Met een deconstructie worden deze onderdelen in één stap toegewezen:

(string city, int population, double area) = QueryCityData("New York City");

U kunt C# ook de variabeletypen laten afleiden:

var (city, population, area) = QueryCityData("New York City");

Een deconstructie kan bestaande variabelen, nieuw gedeclareerde variabelen en genegeerde variabelen in één toewijzing combineren:

(city, var population, _) = QueryCityData("New York City");

Kies de vorm waarmee de code het gemakkelijkst te lezen is. Een enkele var voor de haakjes is vaak de duidelijkste impliciete vorm. U kunt ook expliciete typen en var tussen haakjes combineren, maar die vorm is meestal moeilijker te scannen. Als u slechts enkele waarden nodig hebt, gebruikt u discards in plaats van posities weg te laten.

Overbodige waarden negeren met discards

Elke geproduceerde waarde moet worden uitgelijnd met een positie aan de linkerkant van de toekenning. Als u een of meer posities niet nodig hebt, gebruikt u _ als tijdelijke aanduiding om te negeren:

var (_, _, population1960, _, population2010) = QueryPopulationDataForYears(
    "New York City", 1960, 2010);

Hier retourneert de tuple de plaatsnaam, twee jaartallen en twee populatiewaarden. De deconstructie houdt alleen de populatiewaarden bij, omdat in de berekening alleen die onderdelen worden gebruikt.

Door de gebruiker gedefinieerde typen deconstrueren

Een klasse, struct of interface kan deconstructie ondersteunen door een Deconstruct methode te declareren. Elk onderdeel wordt een out parameter, waarmee de methode een waarde weer kan toewijzen aan de variabele van de aanroeper zonder deze te retourneren. Omdat elk onderdeel wordt geretourneerd via een out parameter, retourneert de methode zelf void:

public void Deconstruct(out string firstName, out string middleName, out string lastName)
{
    firstName = FirstName;
    middleName = MiddleName;
    lastName = LastName;
}

Vervolgens kunt u een exemplaar rechtstreeks destructureren:

var (firstName, middleName, lastName) = passenger;

Een type kan meerdere Deconstruct overbelastingen met verschillende ariteit bieden, het aantal out parameters dat door de methode wordt gedeclareerd, zodat bellers kunnen kiezen hoeveel onderdelen moeten worden opgehaald:

public void Deconstruct(out string firstName, out string lastName)
{
    firstName = FirstName;
    lastName = LastName;
}

public void Deconstruct(out string firstName, out string middleName, out string lastName)
{
    firstName = FirstName;
    middleName = MiddleName;
    lastName = LastName;
}

public void Deconstruct(out string firstName, out string lastName, out string city, out string state)
{
    firstName = FirstName;
    lastName = LastName;
    city = City;
    state = State;
}

Twee overloads met hetzelfde aantal out parameters zijn dubbelzinnig. De compiler rapporteert een fout voor de dubbelzinnige aanroep, dus maak onderscheid tussen overbelastingen op basis van het aantal parameters, niet alleen op parametertypen.

Verwerpen werkt ook met door de gebruiker gedefinieerde deconstructie. Zie Negeringen en het negeringspatroon voor meer informatie over negeringen in het algemeen:

var (firstName, _, city, _) = passenger;

Records ontleden

Een positionele record of record struct record declareert de eigenschappen als parameters op de typedeclaratie zelf, vergelijkbaar met een constructor. De compiler genereert een Deconstruct methode voor u, met out parameters die overeenkomen met deze positionele parameters:

var (city, highTempC, lowTempC) = forecast;

Alleen de positionele parameters nemen deel aan die gegenereerde deconstructie. Aanvullende eigenschappen die u elders in de record declareert, worden niet automatisch toegevoegd.

Typen destructureren die niet van u zijn

Als u een type niet kunt wijzigen, kunt u deconstructie nog steeds ondersteunen door een extensiemethode te schrijven, een statische methode die een Deconstruct-methode toevoegt aan een type dat u niet bezit, alsof het een lid van dat type is. Nadat u de methode hebt toegevoegd, kan elke Uri waarde deconstructiesyntaxis gebruiken:

static class UriExtensions
{
    public static void Deconstruct(this Uri uri, out string scheme, out string host, out int port)
    {
        scheme = uri.Scheme;
        host = uri.Host;
        port = uri.Port;
    }
}

Dezelfde dubbelzinnigheidsregel is hier van toepassing: twee Deconstruct uitbreidingsmethoden met dezelfde arity zijn dubbelzinnig. Dubbelzinnigheid kan zich ook voordoen tussen een instantiemethode Deconstruct en een uitbreidingsmethode van dezelfde arity. In beide gevallen rapporteert de compiler een fout voor de dubbelzinnige aanroep.

Ingebouwde deconstructie voor systeemtypen

Sommige systeemtypen definiëren al een Deconstruct methode, met behulp van hetzelfde mechanisme dat u voor uw eigen typen zou gebruiken. Zo ondersteunt System.Collections.Generic.KeyValuePair<TKey,TValue> deconstructie, waardoor iteratie over woordenboeken beknopt is:

foreach (var (repo, commitCount) in repoCommitCounts)
{
    Console.WriteLine($"{repo} had {commitCount:N0} commits in this snapshot.");
}

Deconstructie en patroonovereenkomst

Een Deconstruct methode maakt ook positionele patronen voor dat type mogelijk. Een positioneel patroon test en deconstructeert een waarde in één stap, met behulp van dezelfde haakjes syntaxis als een deconstructie: person is ("Alice", 30) komt overeen met een Person waarvan de gedeconstructeerde onderdelen gelijk zijn aan die waarden. Dit verschilt van een eigenschapspatroon, waarmee benoemde eigenschappen rechtstreeks worden getest, zoals person is { Name: "Alice", Age: 30 }. Eigenschapspatronen zijn meestal duidelijker voor objectshapes, omdat ledennamen de test uitleggen. Positionele patronen zijn het sterkst wanneer volgorde al de betekenis heeft, zoals met tuples of andere kleine geordende waarden.

Zie ook

  • Laatst bijgewerkt om