Decostruzione di tuple e altri tipi

Una tupla è un metodo semplice per recuperare più valori da una chiamata a un metodo. Tuttavia dopo aver recuperato la tupla è necessario gestirne i singoli elementi. Lavorare elemento per elemento è complicato, come illustrato nell'esempio seguente. Il QueryCityData metodo restituisce una tupla a tre elementi e ognuno dei relativi elementi viene assegnato a una variabile in un'operazione separata.

public class Example
{
    public static void Main()
    {
        var result = QueryCityData("New York City");

        var city = result.Item1;
        var pop = result.Item2;
        var size = result.Item3;

         // Do something with the data.
    }

    private static (string, int, double) QueryCityData(string name)
    {
        if (name == "New York City")
            return (name, 8175133, 468.48);

        return ("", 0, 0);
    }
}

Il recupero di più valori di campo e di proprietà da un oggetto può essere altrettanto complicato: è necessario assegnare un valore di campo o di proprietà a una variabile membro per membro.

In C# 7.0 e versioni successive è possibile recuperare più elementi da una tupla o recuperare più campi, proprietà e valori calcolati da un oggetto in una singola operazione di decostruzione. Per decostruire una tupla, assegnare i relativi elementi a singole variabili. Quando si decostruisce un oggetto si assegnano valori selezionati a singole variabili.

Tuple

In C# è incluso il supporto per la decostruzione di tuple, che consente di decomprimere tutti gli elementi di una tupla in un'unica operazione. La sintassi generale per la decostruzione di una tupla è simile alla sintassi per la definizione della tupla: le variabili a cui va assegnato ogni elemento vengono racchiuse tra parentesi sul lato sinistro di un'istruzione di assegnazione. Ad esempio, l'istruzione seguente assegna gli elementi di una tupla a quattro variabili separate:

var (name, address, city, zip) = contact.GetAddressInfo();

Esistono tre modi per decostruire una tupla:

  • È possibile dichiarare in modo esplicito il tipo di ogni campo all'interno di parentesi. Nell'esempio seguente viene utilizzato questo approccio per decostruire la tupla a tre elementi restituita dal QueryCityData metodo .

    public static void Main()
    {
        (string city, int population, double area) = QueryCityData("New York City");
    
        // Do something with the data.
    }
    
  • È possibile usare la parola chiave var in modo che C# deduca il tipo di ogni variabile. Posizionare la parola chiave var all'esterno delle parentesi. Nell'esempio seguente viene utilizzata l'inferenza del tipo quando si decostruisce la tupla a tre elementi restituita dal QueryCityData metodo .

    public static void Main()
    {
        var (city, population, area) = QueryCityData("New York City");
    
        // Do something with the data.
    }
    

    È anche possibile usare la parola chiave var individualmente con una o con tutte le dichiarazioni di variabili all'interno delle parentesi.

    public static void Main()
    {
        (string city, var population, var area) = QueryCityData("New York City");
    
        // Do something with the data.
    }
    

    Questa operazione è complicata e non è consigliata.

  • Infine, è possibile decostruire la tupla in variabili che sono già state dichiarate.

    public static void Main()
    {
        string city = "Raleigh";
        int population = 458880;
        double area = 144.8;
    
        (city, population, area) = QueryCityData("New York City");
    
        // Do something with the data.
    }
    
  • A partire da C# 10, è possibile combinare la dichiarazione di variabile e l'assegnazione in una decostruzione.

    public static void Main()
    {
        string city = "Raleigh";
        int population = 458880;
    
        (city, population, double area) = QueryCityData("New York City");
    
        // Do something with the data.
    }
    

Non è possibile specificare un tipo specifico all'esterno delle parentesi anche se ogni campo nella tupla ha lo stesso tipo. In questo modo viene generato l'errore del compilatore CS8136, "La decostruzione del modulo 'var (...)' non consente un tipo specifico per 'var'".

È necessario assegnare ogni elemento della tupla a una variabile. Se si omettono elementi, il compilatore genera l'errore CS8132, "Can't deconstruct a tuple of 'x' elements into 'y' variables".

Elementi di tupla con discard

Spesso quando si decostruisce una tupla si è interessati solo ai valori di alcuni elementi. A partire da C# 7.0 è possibile avvalersi del supporto in C# delle variabili discard, variabili di sola scrittura delle quali si è scelto di ignorare i valori. Una discard viene scelta da un carattere di sottolineatura (" _ ") in un'assegnazione. È possibile rimuovere il numero di valori desiderato; tutti sono rappresentati dalla variabile discard singola _.

L'esempio seguente illustra l'uso delle tuple con le variabili discard. Il metodo restituisce una tupla a sei con il nome di una città, la relativa area, un anno, la popolazione della città per tale anno, un secondo anno e la popolazione della città per il secondo QueryCityDataForYears anno. L'esempio visualizza la variazione della popolazione tra questi due anni. Tra i dati resi disponibili dalla tupla non interessa l'area della città, mentre il nome della città e le due date sono già noti in fase di progettazione. Di conseguenza interessano soltanto i due valori di popolazione archiviati nella tupla, mentre gli altri valori possono essere gestiti come variabili discard.

using System;

public class ExampleDiscard
{
    public static void Main()
    {
        var (_, _, _, pop1, _, pop2) = QueryCityDataForYears("New York City", 1960, 2010);

        Console.WriteLine($"Population change, 1960 to 2010: {pop2 - pop1:N0}");
    }

    private static (string, double, int, int, int, int) QueryCityDataForYears(string name, int year1, int year2)
    {
        int population1 = 0, population2 = 0;
        double area = 0;

        if (name == "New York City")
        {
            area = 468.48;
            if (year1 == 1960)
            {
                population1 = 7781984;
            }
            if (year2 == 2010)
            {
                population2 = 8175133;
            }
            return (name, area, year1, population1, year2, population2);
        }

        return ("", 0, 0, 0, 0, 0);
    }
}
// The example displays the following output:
//      Population change, 1960 to 2010: 393,149

Tipi definiti dall'utente

C# non offre il supporto predefinito per la decostruzione di tipi non di tupla diversi da e record tipi DictionaryEntry. Tuttavia l'autore di una classe, uno struct o un'interfaccia può consentire la decostruzione di istanze del tipo implementando uno o più metodi Deconstruct. Il metodo restituisce un valore void e ogni valore da decostruire è indicato da un parametro out nella firma del metodo. Ad esempio il seguente metodo Deconstruct di una classe Person restituisce il nome, il secondo nome e il cognome:

public void Deconstruct(out string fname, out string mname, out string lname)

È quindi possibile decostruire un'istanza della Person classe denominata p con un'assegnazione simile al codice seguente:

var (fName, mName, lName) = p;

L'esempio che segue implementa l'overload del metodo Deconstruct per restituire varie combinazioni di proprietà di un oggetto Person. I singoli overload restituiscono:

  • Un nome e un cognome.
  • Nome, secondo e cognome.
  • Un nome, un cognome, un nome di città e un nome di stato.
using System;

public class Person
{
    public string FirstName { get; set; }
    public string MiddleName { get; set; }
    public string LastName { get; set; }
    public string City { get; set; }
    public string State { get; set; }

    public Person(string fname, string mname, string lname,
                  string cityName, string stateName)
    {
        FirstName = fname;
        MiddleName = mname;
        LastName = lname;
        City = cityName;
        State = stateName;
    }

    // Return the first and last name.
    public void Deconstruct(out string fname, out string lname)
    {
        fname = FirstName;
        lname = LastName;
    }

    public void Deconstruct(out string fname, out string mname, out string lname)
    {
        fname = FirstName;
        mname = MiddleName;
        lname = LastName;
    }

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

public class ExampleClassDeconstruction
{
    public static void Main()
    {
        var p = new Person("John", "Quincy", "Adams", "Boston", "MA");

        // Deconstruct the person object.
        var (fName, lName, city, state) = p;
        Console.WriteLine($"Hello {fName} {lName} of {city}, {state}!");
    }
}
// The example displays the following output:
//    Hello John Adams of Boston, MA!

Più Deconstruct metodi con lo stesso numero di parametri sono ambigui. È necessario prestare attenzione a definire Deconstruct metodi con un numero diverso di parametri, o "grado". Deconstruct I metodi con lo stesso numero di parametri non possono essere distinti durante la risoluzione dell'overload.

Tipo definito dall'utente con discard

Come per le tuple, è possibile usare le variabili discard per ignorare elementi selezionati restituiti da un metodo Deconstruct. Ogni variabile discard è definita da una variabile denominata _ e una singola operazione di decostruzione può includere diverse variabili discard.

L'esempio seguente esegue la decostruzione di un oggetto Person in quattro stringhe (nome, cognome, città e stato) ma rimuove il cognome e lo stato.

// Deconstruct the person object.
var (fName, _, city, _) = p;
Console.WriteLine($"Hello {fName} of {city}!");
// The example displays the following output:
//      Hello John of Boston!

Metodi di estensione per tipi definiti dall'utente

Anche un utente che non ha creato una classe, uno struct o un'interfaccia può eseguire la decostruzione di oggetti di questo tipo implementando uno o più Deconstruct metodi di estensione per restituire i valori che risultano di interesse.

L'esempio riportato di seguito illustra due metodi di estensione Deconstruct per la classe System.Reflection.PropertyInfo. Il primo metodo restituisce un set di valori che indicano le caratteristiche della proprietà: il tipo, se è statica o di istanza, se è di sola lettura e se è indicizzata. Il secondo indica l'accessibilità della proprietà. Dato che l'accessibilità delle funzioni di accesso get e set può essere diversa, i valori booleani indicano se la proprietà ha funzioni di accesso get e set separate e in questo caso se tali funzioni presentano la stessa accessibilità. Se è presente una sola funzione di accesso o entrambe le funzioni di accesso get e set hanno la stessa accessibilità, la variabile indica l'accessibilità della proprietà access nel suo complesso. In caso contrario l'accessibilità delle funzioni di accesso get e set è indicata dalle variabili getAccess e setAccess.

using System;
using System.Collections.Generic;
using System.Reflection;

public static class ReflectionExtensions
{
    public static void Deconstruct(this PropertyInfo p, out bool isStatic,
                                   out bool isReadOnly, out bool isIndexed,
                                   out Type propertyType)
    {
        var getter = p.GetMethod;

        // Is the property read-only?
        isReadOnly = ! p.CanWrite;

        // Is the property instance or static?
        isStatic = getter.IsStatic;

        // Is the property indexed?
        isIndexed = p.GetIndexParameters().Length > 0;

        // Get the property type.
        propertyType = p.PropertyType;
    }

    public static void Deconstruct(this PropertyInfo p, out bool hasGetAndSet,
                                   out bool sameAccess, out string access,
                                   out string getAccess, out string setAccess)
    {
        hasGetAndSet = sameAccess = false;
        string getAccessTemp = null;
        string setAccessTemp = null;

        MethodInfo getter = null;
        if (p.CanRead)
            getter = p.GetMethod;

        MethodInfo setter = null;
        if (p.CanWrite)
            setter = p.SetMethod;

        if (setter != null && getter != null)
            hasGetAndSet = true;

        if (getter != null)
        {
            if (getter.IsPublic)
                getAccessTemp = "public";
            else if (getter.IsPrivate)
                getAccessTemp = "private";
            else if (getter.IsAssembly)
                getAccessTemp = "internal";
            else if (getter.IsFamily)
                getAccessTemp = "protected";
            else if (getter.IsFamilyOrAssembly)
                getAccessTemp = "protected internal";
        }

        if (setter != null)
        {
            if (setter.IsPublic)
                setAccessTemp = "public";
            else if (setter.IsPrivate)
                setAccessTemp = "private";
            else if (setter.IsAssembly)
                setAccessTemp = "internal";
            else if (setter.IsFamily)
                setAccessTemp = "protected";
            else if (setter.IsFamilyOrAssembly)
                setAccessTemp = "protected internal";
        }

        // Are the accessibility of the getter and setter the same?
        if (setAccessTemp == getAccessTemp)
        {
            sameAccess = true;
            access = getAccessTemp;
            getAccess = setAccess = String.Empty;
        }
        else
        {
            access = null;
            getAccess = getAccessTemp;
            setAccess = setAccessTemp;
        }
    }
}

public class ExampleExtension
{
    public static void Main()
    {
        Type dateType = typeof(DateTime);
        PropertyInfo prop = dateType.GetProperty("Now");
        var (isStatic, isRO, isIndexed, propType) = prop;
        Console.WriteLine($"\nThe {dateType.FullName}.{prop.Name} property:");
        Console.WriteLine($"   PropertyType: {propType.Name}");
        Console.WriteLine($"   Static:       {isStatic}");
        Console.WriteLine($"   Read-only:    {isRO}");
        Console.WriteLine($"   Indexed:      {isIndexed}");

        Type listType = typeof(List<>);
        prop = listType.GetProperty("Item",
                                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
        var (hasGetAndSet, sameAccess, accessibility, getAccessibility, setAccessibility) = prop;
        Console.Write($"\nAccessibility of the {listType.FullName}.{prop.Name} property: ");

        if (!hasGetAndSet | sameAccess)
        {
            Console.WriteLine(accessibility);
        }
        else
        {
            Console.WriteLine($"\n   The get accessor: {getAccessibility}");
            Console.WriteLine($"   The set accessor: {setAccessibility}");
        }
    }
}
// The example displays the following output:
//       The System.DateTime.Now property:
//          PropertyType: DateTime
//          Static:       True
//          Read-only:    True
//          Indexed:      False
//
//       Accessibility of the System.Collections.Generic.List`1.Item property: public

record Tipi

Quando si dichiara un tipo di record usando due o più parametri posizionali, il compilatore crea un metodo con un parametro per ogni parametro Deconstruct out posizionale nella record dichiarazione. Per altre informazioni, vedere Sintassi posizionale per la definizione della proprietà e Comportamento del decostruttore nei record derivati.

Vedere anche