Condividi tramite


Tuple<T1,T2> Classe

Definizione

Rappresenta una tupla con 2 elementi, ovvero una coppia.

generic <typename T1, typename T2>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
generic <typename T1, typename T2>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple
public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple
[System.Serializable]
public class Tuple<T1,T2> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Tuple<'T1, 'T2> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
type Tuple<'T1, 'T2> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple
[<System.Serializable>]
type Tuple<'T1, 'T2> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
[<System.Serializable>]
type Tuple<'T1, 'T2> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface ITuple
Public Class Tuple(Of T1, T2)
Implements IComparable, IStructuralComparable, IStructuralEquatable
Public Class Tuple(Of T1, T2)
Implements IComparable, IStructuralComparable, IStructuralEquatable, ITuple

Parametri di tipo

T1

Tipo del primo componente della tupla.

T2

Tipo del secondo componente della tupla.

Ereditarietà
Tuple<T1,T2>
Attributi
Implementazioni

Commenti

Una tupla è una struttura di dati con un numero e una sequenza specifici di valori. La Tuple<T1,T2> classe rappresenta una tupla a 2 o una coppia, che è una tupla con due componenti. Una tupla a 2 è simile a una KeyValuePair<TKey,TValue> struttura.

È possibile creare un'istanza di un Tuple<T1,T2> oggetto chiamando il costruttore o il Tuple<T1,T2> metodo statico Tuple.Create<T1,T2>(T1, T2) . È possibile recuperare i valori dei componenti della tupla usando le proprietà di sola lettura Item1 e Item2 istanza.

Le tuple vengono comunemente usate in quattro modi diversi:

  • Per rappresentare un singolo set di dati. Ad esempio, una tupla può rappresentare un record in un database e i relativi componenti possono rappresentare i campi del record.

  • Per consentire l'accesso semplice e la manipolazione di, un set di dati. Nell'esempio seguente viene definita una matrice di oggetti che contengono i nomi degli Tuple<T1,T2> studenti e i relativi punteggi di test corrispondenti. Esegue quindi l'iterazione della matrice per calcolare il punteggio di test medio.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Tuple<string, Nullable<int>>[] scores = 
                        { new Tuple<string, Nullable<int>>("Jack", 78),
                          new Tuple<string, Nullable<int>>("Abbey", 92), 
                          new Tuple<string, Nullable<int>>("Dave", 88),
                          new Tuple<string, Nullable<int>>("Sam", 91), 
                          new Tuple<string, Nullable<int>>("Ed", null),
                          new Tuple<string, Nullable<int>>("Penelope", 82),
                          new Tuple<string, Nullable<int>>("Linda", 99),
                          new Tuple<string, Nullable<int>>("Judith", 84) };
          int number;
          double mean = ComputeMean(scores, out number);
          Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number);
       }
    
       private static double ComputeMean(Tuple<string, Nullable<int>>[] scores, out int n) 
       {
          n = 0;      
          int sum = 0;
          foreach (var score in scores)
          {
             if (score.Item2.HasValue)
             { 
                n += 1;
                sum += score.Item2.Value;
             }
          }     
          if (n > 0)
             return sum / (double) n;
          else
             return 0;
       }
    }
    // The example displays the following output:
    //       Average test score: 87.71 (n=7)
    
    open System
    
    let scores = 
        [| Tuple<string, Nullable<int>>("Jack", 78)
           Tuple<string, Nullable<int>>("Abbey", 92) 
           Tuple<string, Nullable<int>>("Dave", 88)
           Tuple<string, Nullable<int>>("Sam", 91) 
           Tuple<string, Nullable<int>>("Ed", Nullable())
           Tuple<string, Nullable<int>>("Penelope", 82)
           Tuple<string, Nullable<int>>("Linda", 99)
           Tuple<string, Nullable<int>>("Judith", 84) |]
    
    let computeMean (scores: Tuple<string, Nullable<int>>[]) (n: int outref) = 
        n <- 0      
        let mutable sum = 0
        for _, score in scores do
            if score.HasValue then
                n <- n + 1
                sum <- sum + score.Value
        if n > 0 then
            double sum / double n
        else
            0
    
    let mutable number = 0
    let mean = computeMean scores &number
    printfn $"Average test score: {mean:N2} (n={number})"
    // The example displays the following output:
    //       Average test score: 87.71 (n=7)
    
    Module Example
       Public Sub Main()
          Dim scores() As Tuple(Of String, Nullable(Of Integer)) = 
                          { New Tuple(Of String, Nullable(Of Integer))("Jack", 78),
                            New Tuple(Of String, Nullable(Of Integer))("Abbey", 92), 
                            New Tuple(Of String, Nullable(Of Integer))("Dave", 88),
                            New Tuple(Of String, Nullable(Of Integer))("Sam", 91), 
                            New Tuple(Of String, Nullable(Of Integer))("Ed", Nothing),
                            New Tuple(Of String, Nullable(Of Integer))("Penelope", 82),
                            New Tuple(Of String, Nullable(Of Integer))("Linda", 99),
                            New Tuple(Of String, Nullable(Of Integer))("Judith", 84) }
          Dim number As Integer
          Dim mean As Double = ComputeMean(scores, number)
          Console.WriteLine("Average test score: {0:N2} (n={1})", mean, number)
       End Sub
       
       Private Function ComputeMean(scores() As Tuple(Of String, Nullable(Of Integer)), 
                                    ByRef n As Integer) As Double
          n = 0      
          Dim sum As Integer
          For Each score In scores
             If score.Item2.HasValue Then 
                n += 1
                sum += score.Item2.Value
             End If
          Next     
          If n > 0 Then
             Return sum / n
          Else
             Return 0
          End If             
       End Function
    End Module
    ' The example displays the following output:
    '       Average test score: 87.71 (n=7)
    
  • Per restituire più valori da un metodo senza l'uso di out parametri (in C#) o ByRef parametri (in Visual Basic). L'esempio seguente, ad esempio, usa un Tuple<T1,T2> oggetto per restituire il quoziente e il resto risultante dalla divisione integer.

    using System;
    
    public class Class1
    {
       public static void Main()
       {
          int dividend, divisor;
          Tuple<int, int> result;
          
          dividend = 136945; divisor = 178;
          result = IntegerDivide(dividend, divisor);
          if (result != null)
             Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                               dividend, divisor, result.Item1, result.Item2);
          else
             Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
                            
          dividend = Int32.MaxValue; divisor = -2073;
          result = IntegerDivide(dividend, divisor);
          if (result != null)
             Console.WriteLine(@"{0} \ {1} = {2}, remainder {3}", 
                               dividend, divisor, result.Item1, result.Item2);
          else
             Console.WriteLine(@"{0} \ {1} = <Error>", dividend, divisor);
       }
    
       private static Tuple<int, int> IntegerDivide(int dividend, int divisor)
       {
          try {
             int remainder;
             int quotient = Math.DivRem(dividend, divisor, out remainder);
             return new Tuple<int, int>(quotient, remainder);
          }   
          catch (DivideByZeroException) {
             return null;
          }      
       }
    }
    // The example displays the following output:
    //       136945 \ 178 = 769, remainder 63
    //       2147483647 \ -2073 = -1035930, remainder 757
    
    open System
    
    let integerDivide (dividend: int) divisor =
        try
            let quotient, remainder = Math.DivRem(dividend, divisor)
            Tuple<int, int>(quotient, remainder)
        with :? DivideByZeroException ->
            Unchecked.defaultof<Tuple<int, int>>
    
    [<EntryPoint>]
    let main _ =
        let dividend = 136945 
        let divisor = 178
        let result = integerDivide dividend divisor
        if box result <> null then
            printfn $@"{dividend} \ {divisor} = {result.Item1}, remainder {result.Item2}" 
        else
            printfn $@"{dividend} \ {divisor} = <Error>"
                        
        let dividend = Int32.MaxValue 
        let divisor = -2073
        let result = integerDivide dividend divisor
        if box result <> null then
            printfn $@"{dividend} \ {divisor} = {result.Item1}, remainder {result.Item2}" 
        else
            printfn $@"{dividend} \ {divisor} = <Error>"
        0
    // The example displays the following output:
    //       136945 \ 178 = 769, remainder 63
    //       2147483647 \ -2073 = -1035930, remainder 757
    
    Module modMain
       Public Sub Main()
          Dim dividend, divisor As Integer
          Dim result As Tuple(Of Integer, Integer)
          
          dividend = 136945 : divisor = 178
          result = IntegerDivide(dividend, divisor)
          If result IsNot Nothing Then
             Console.WriteLine("{0} \ {1} = {2}, remainder {3}", 
                               dividend, divisor, result.Item1, result.Item2)
          Else
             Console.WriteLine("{0} \ {1} = <Error>", dividend, divisor)
          End If
                            
          dividend = Int32.MaxValue : divisor = -2073
          result = IntegerDivide(dividend, divisor)
          If result IsNot Nothing Then
             Console.WriteLine("{0} \ {1} = {2}, remainder {3}", 
                               dividend, divisor, result.Item1, result.Item2)
          Else
             Console.WriteLine("{0} \ {1} = <Error>", dividend, divisor)
          End If
       End Sub
       
       Private Function IntegerDivide(dividend As Integer, divisor As Integer) As Tuple(Of Integer, Integer)
          Try
             Dim remainder As Integer
             Dim quotient As Integer = Math.DivRem(dividend, divisor, remainder)
             Return New Tuple(Of Integer, Integer)(quotient, remainder)
          Catch e As DivideByZeroException
             Return Nothing
          End Try      
       End Function
    End Module
    ' The example displays the following output:
    '       136945 \ 178 = 769, remainder 63
    '       2147483647 \ -2073 = -1035930, remainder 757
    
  • Per passare più valori a un metodo tramite un singolo parametro. Ad esempio, il Thread.Start(Object) metodo ha un singolo parametro che consente di specificare un valore al metodo eseguito dal thread all'avvio. Se si specifica un Tuple<T1,T2> oggetto come argomento del metodo, è possibile fornire la routine di avvio del thread con due elementi di dati.

Costruttori

Tuple<T1,T2>(T1, T2)

Inizializza una nuova istanza della classe Tuple<T1,T2>.

Proprietà

Item1

Ottiene il valore del primo componente dell'oggetto Tuple<T1,T2> corrente.

Item2

Ottiene il valore del secondo componente dell'oggetto Tuple<T1,T2> corrente.

Metodi

Equals(Object)

Restituisce un valore che indica se l'oggetto Tuple<T1,T2> corrente è uguale a un oggetto specificato.

GetHashCode()

Restituisce il codice hash per l'oggetto Tuple<T1,T2> corrente.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta il valore di questa istanza di Tuple<T1,T2>.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta l'oggetto Tuple<T1,T2> corrente con un oggetto specificato e restituisce un intero che indica se l'oggetto corrente precede, segue o si trova nella stessa posizione dell'oggetto specificato nell'ordinamento.

IStructuralComparable.CompareTo(Object, IComparer)

Confronta l'oggetto Tuple<T1,T2> corrente con un oggetto specificato mediante un operatore di confronto specificato e restituisce un Integer che indica se l'oggetto corrente precede, segue o si trova nella stessa posizione dell'oggetto specificato all'interno dell'ordinamento.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Restituisce un valore che indica se l'oggetto Tuple<T1,T2> corrente è uguale a un oggetto specificato in base a un metodo di confronto specificato.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Calcola il codice hash per l'oggetto Tuple<T1,T2> corrente tramite un metodo di calcolo specificato.

ITuple.Item[Int32]

Ottiene il valore dell'elemento Tuple specificato.

ITuple.Length

Ottiene il numero di elementi in Tuple.

Metodi di estensione

Deconstruct<T1,T2>(Tuple<T1,T2>, T1, T2)

Decostruisce una tupla con 2 elementi in variabili separate.

ToValueTuple<T1,T2>(Tuple<T1,T2>)

Converte un'istanza della classe Tuple in un'istanza della struttura ValueTuple.

Si applica a

Vedi anche