Tuple<T1,T2,T3,T4,T5,T6,T7> Класс

Определение

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

generic <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
public ref class Tuple : IComparable, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable, System::Runtime::CompilerServices::ITuple

public class Tuple<T1,T2,T3,T4,T5,T6,T7> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

public class Tuple<T1,T2,T3,T4,T5,T6,T7> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Runtime.CompilerServices.ITuple

[System.Serializable]
public class Tuple<T1,T2,T3,T4,T5,T6,T7> : IComparable, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable

type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> = class
    interface IStructuralComparable
    interface IStructuralEquatable
    interface IComparable
    interface ITuple

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable

[<System.Serializable>]
type Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> = class
    interface IStructuralEquatable
    interface IStructuralComparable
    interface IComparable
    interface ITuple

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7)
Implements IComparable, IStructuralComparable, IStructuralEquatable

Public Class Tuple(Of T1, T2, T3, T4, T5, T6, T7)
Implements IComparable, IStructuralComparable, IStructuralEquatable, ITuple

Параметры типа

Наследование

Object

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

Атрибуты

SerializableAttribute

Реализации

IStructuralComparable IStructuralEquatable IComparable ITuple

Комментарии

Кортеж — это структура данных, которая имеет определенное число и последовательность значений. Класс Tuple<T1,T2,T3,T4,T5,T6,T7> представляет 7 кортежей или сепсет, который представляет собой кортеж, имеющий семь компонентов.

Можно создать экземпляр Tuple<T1,T2,T3,T4,T5,T6,T7> объекта, вызвав либо Tuple<T1,T2,T3,T4,T5,T6,T7> статический Tuple.Create<T1,T2,T3,T4,T5,T6,T7>(T1, T2, T3, T4, T5, T6, T7) метод. Значение компонентов кортежа можно получить с помощью свойств экземпляра, доступных только Item1для чтения , Item2, Item3, Item4, Item5Item6и Item7 экземпляров.

Кортежи обычно используются четырьмя разными способами:

• Представление одного набора данных. Например, кортеж может представлять запись базы данных, а ее компоненты могут представлять отдельные поля записи.

• Чтобы обеспечить простой доступ к набору данных и их обработке. В следующем примере определяется Tuple<T1,T2,T3,T4,T5,T6,T7> объект, содержащий данные о населении для Нью-йорка для каждой переписи с 1950 по 2000 год. Сеплей передается ComputePopulationChange методу, который вычисляет годовой показатель изменений между переписями, а также годовой показатель изменений в течение всего 60-летнего периода.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        // Get population data for New York City, 1950-2000.
        var population = Tuple.Create("New York", 7891957, 7781984, 
                                      7894862, 7071639, 7322564, 8008278);
        var rate = ComputePopulationChange(population);
        // Display results.
        Console.WriteLine("Population Change, {0}, 1950-2000\n", population.Item1);
        Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate");
        Console.WriteLine("1950      {0,10:N0} {1,11}", population.Item2, "NA");
        Console.WriteLine("1960      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10);
        Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10);
        Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10);
        Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10);
        Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item7, rate.Item6/10);
        Console.WriteLine("1950-2000 {0,10:N0} {1,11:P2}", "", rate.Item7/50);
     }
  
     private static Tuple<string, double, double, double, double, double, double> 
          ComputePopulationChange(
             Tuple<string, int, int, int, int, int, int> data)  
     {           
        var rate = Tuple.Create(data.Item1, 
                         (double)(data.Item3 - data.Item2)/data.Item2, 
                         (double)(data.Item4 - data.Item3)/data.Item3, 
                         (double)(data.Item5 - data.Item4)/data.Item4, 
                         (double)(data.Item6 - data.Item5)/data.Item5,
                         (double)(data.Item7 - data.Item6)/data.Item6,
                         (double)(data.Item7 - data.Item2)/data.Item2 );
        return rate;
     }           
  }
  // The example displays the following output:
  //       Population Change, New York, 1950-2000
  //       
  //       Year      Population Annual Rate
  //       1950       7,891,957          NA
  //       1960       7,781,984     -0.14 %
  //       1970       7,894,862      0.15 %
  //       1980       7,071,639     -1.04 %
  //       1990       7,322,564      0.35 %
  //       2000       8,008,278      0.94 %
  //       1950-2000                 0.03 %
  

  open System
  
  let computePopulationChange (data: Tuple<string, int, int, int, int, int, int>) =  
      Tuple.Create(data.Item1, 
                   double (data.Item3 - data.Item2) / double data.Item2, 
                   double (data.Item4 - data.Item3) / double data.Item3, 
                   double (data.Item5 - data.Item4) / double data.Item4, 
                   double (data.Item6 - data.Item5) / double data.Item5,
                   double (data.Item7 - data.Item6) / double data.Item6,
                   double (data.Item7 - data.Item2) / double data.Item2)
  
  // Get population data for New York City, 1950-2000.
  let population = 
      Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
  let rate = computePopulationChange population
  // Display results.
  printfn $"Population Change, {population.Item1}, 1950-2000\n"
  printfn $"""Year      {"Population",10} {"Annual Rate",9}"""
  printfn $"""1950      {population.Item2,10:N0} {"NA",11}"""
  printfn $"1960      {population.Item3,10:N0} {rate.Item2 / 10.,11:P2}"
  printfn $"1970      {population.Item4,10:N0} {rate.Item3 / 10.,11:P2}" 
  printfn $"1980      {population.Item5,10:N0} {rate.Item4 / 10.,11:P2}" 
  printfn $"1990      {population.Item6,10:N0} {rate.Item5 / 10.,11:P2}" 
  printfn $"2000      {population.Item7,10:N0} {rate.Item6 / 10.,11:P2}" 
  printfn $"""1950-2000 {"",10:N0} {rate.Item7 / 50.,11:P2}"""
  
  // The example displays the following output:
  //       Population Change, New York, 1950-2000
  //       
  //       Year      Population Annual Rate
  //       1950       7,891,957          NA
  //       1960       7,781,984     -0.14 %
  //       1970       7,894,862      0.15 %
  //       1980       7,071,639     -1.04 %
  //       1990       7,322,564      0.35 %
  //       2000       8,008,278      0.94 %
  //       1950-2000                 0.03 %
  

  Module Example
     Public Sub Main()
        ' Get population data for New York City, 1950-2000.
        Dim population = Tuple.Create("New York", 7891957, 7781984, 
                                      7894862, 7071639, 7322564, 8008278)
        Dim rate = ComputePopulationChange(population)      
        ' Display results.
        Console.WriteLine("Population Change, {0}, 1950-2000", population.Item1)
        Console.WriteLine()
        Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate")
        Console.WriteLine("1950      {0,10:N0} {1,11}", population.Item2, "NA")
        Console.WriteLine("1960      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10)
        Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10)
        Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10)
        Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10)
        Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item7, rate.Item6/10)
        Console.WriteLine("1950-2000 {0,10:N0} {1,11:P2}", "", rate.Item7/50)
     End Sub
     
        ' Compute rate of population change by decade and overall.
     Private Function ComputePopulationChange(data As Tuple(Of String, Integer, Integer, Integer, Integer, Integer, Integer)) _ 
             As Tuple(Of String, Double, Double, Double, Double, Double, Double)
        Dim rate = Tuple.Create( data.Item1, 
                         (data.Item3 - data.Item2)/data.Item2, 
                         (data.Item4 - data.Item3)/data.Item3, 
                         (data.Item5 - data.Item4)/data.Item4, 
                         (data.Item6 - data.Item5)/data.Item5,
                         (data.Item7 - data.Item6)/data.Item6,
                         (data.Item7 - data.Item2)/data.Item2 )
        Return rate
     End Function           
  End Module
  ' The example displays the following output:
  '       Population Change, New York, 1950-2000
  '       
  '       Year      Population Annual Rate
  '       1950       7,891,957          NA
  '       1960       7,781,984     -0.14 %
  '       1970       7,894,862      0.15 %
  '       1980       7,071,639     -1.04 %
  '       1990       7,322,564      0.35 %
  '       2000       8,008,278      0.94 %
  '       1950-2000                 0.03 %
  

• Чтобы вернуть несколько значений из метода без использования out параметров (в C#) или ByRef параметров (в Visual Basic). Например, предыдущий пример возвращает вычисляемую статистику вместе с именем города в объекте Tuple<T1,T2,T3,T4,T5,T6,T7> .

• Передача нескольких значений методу через один параметр. Например, метод Thread.Start(Object) имеет один параметр, который позволяет указать одно значение методу, который выполняется потоком при запуске. Если вы предоставляете Tuple<T1,T2,T3,T4,T5,T6,T7> объект в качестве аргумента метода, вы можете предоставить подпрограмму запуска потока с семью элементами данных.

См. также раздел

• Tuple
• Tuple<T1>
• Tuple<T1,T2>
• 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,TRest>