Tuple<T1,T2> Class

Definition

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

Type Parameters

Inheritance

Object

Tuple<T1,T2>

Attributes

SerializableAttribute

Implements

IStructuralComparable IStructuralEquatable IComparable ITuple

Remarks

A tuple is a data structure that has a specific number and sequence of values. The Tuple<T1,T2> class represents a 2-tuple, or pair, which is a tuple that has two components. A 2-tuple is similar to a KeyValuePair<TKey,TValue> structure.

You can instantiate a Tuple<T1,T2> object by calling either the Tuple<T1,T2> constructor or the static Tuple.Create<T1,T2>(T1, T2) method. You can retrieve the values of the tuple's components by using the read-only Item1 and Item2 instance properties.

Tuples are commonly used in four different ways:

• To represent a single set of data. For example, a tuple can represent a record in a database, and its components can represent that record's fields.

• To provide easy access to, and manipulation of, a data set. The following example defines an array of Tuple<T1,T2> objects that contain the names of students and their corresponding test scores. It then iterates the array to calculate the mean test score.

  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)
  

• To return multiple values from a method without the use of out parameters (in C#) or ByRef parameters (in Visual Basic). For example, the following example uses a Tuple<T1,T2> object to return the quotient and the remainder that result from integer division.

  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
  

• To pass multiple values to a method through a single parameter. For example, the Thread.Start(Object) method has a single parameter that lets you supply one value to the method that the thread executes at startup. If you supply a Tuple<T1,T2> object as the method argument, you can supply the thread's startup routine with two items of data.

See also

• Tuple
• Tuple<T1>
• Tuple<T1,T2,T3>
• Tuple<T1,T2,T3,T4>
• Tuple<T1,T2,T3,T4,T5>
• Tuple<T1,T2,T3,T4,T5,T6>
• Tuple<T1,T2,T3,T4,T5,T6,T7>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>