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

Определение

Представляет кортеж из шести компонентов.

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

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

T1

Тип первого компонента кортежа.

T2

Тип второго компонента кортежа.

T3

Тип третьего компонента кортежа.

T4

Тип четвертого компонента кортежа.

T5

Тип пятого компонента кортежа.

T6

Тип шестого компонента кортежа.

Наследование
Tuple<T1,T2,T3,T4,T5,T6>
Атрибуты
Реализации

Комментарии

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

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

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

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

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

    using System;
    
    public class Example
    {
       public static void Main()
       {
          // Get population data for New York City, 1960-2000.
          var population = 
               Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278);
          var rate = ComputePopulationChange(population);
          // Display results.
          Console.WriteLine("Population Change, {0}, 1960-2000\n", population.Item1);
          Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate");
          Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA");
          Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10);
          Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10);
          Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10);
          Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10);
          Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/50);
       }
    
       private static Tuple<string, double, double, double, double, double> ComputePopulationChange(
               Tuple<string, 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.Item6 - data.Item2)/data.Item2 );
          return rate;
       }           
    }
    // The example displays the following output:
    //       Population Change, New York, 1960-2000
    //       
    //       Year      Population Annual Rate
    //       1960       7,781,984          NA
    //       1970       7,894,862      0.15 %
    //       1980       7,071,639     -1.04 %
    //       1990       7,322,564      0.35 %
    //       2000       8,008,278      0.94 %
    //       1960-2000                 0.06 %
    
    open System
    
    let computePopulationChange (data: Tuple<string, int, int, int, int, int>) =  
        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.Item6 - data.Item2) / data.Item2))
    
    // Get population data for New York City, 1960-2000.
    let population = 
          Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278)
    let rate = computePopulationChange population
    // Display results.
    printfn $"Population Change, {population.Item1}, 1960-2000\n"
    printfn $"""Year      {"Population",10} {"Annual Rate",9}"""
    printfn $"""1960      {population.Item2,10:N0} {"NA",11}"""
    printfn $"1970      {population.Item3,10:N0} {rate.Item2 / 10.,11:P2}"
    printfn $"1980      {population.Item4,10:N0} {rate.Item3 / 10.,11:P2}"
    printfn $"1990      {population.Item5,10:N0} {rate.Item4 / 10.,11:P2}"
    printfn $"2000      {population.Item6,10:N0} {rate.Item5 / 10.,11:P2}"
    printfn $"""1960-2000 {"",10:N0} {rate.Item6 / 50.,11:P2}"""
    
    // The example displays the following output:
    //       Population Change, New York, 1960-2000
    //       
    //       Year      Population Annual Rate
    //       1960       7,781,984          NA
    //       1970       7,894,862      0.15 %
    //       1980       7,071,639     -1.04 %
    //       1990       7,322,564      0.35 %
    //       2000       8,008,278      0.94 %
    //       1960-2000                 0.06 %
    
    Module Example
       Public Sub Main()
          ' Get population data for New York City, 1960-2000.
          Dim population = Tuple.Create(
                         "New York", 7781984, 7894862, 7071639, 7322564, 8008278)
          Dim rate = ComputePopulationChange(population)      
          ' Display results.
          Console.WriteLine("Population Change, {0}, 1960-2000", population.Item1)
          Console.WriteLine()
          Console.WriteLine("Year      {0,10} {1,9}", "Population", "Annual Rate")
          Console.WriteLine("1960      {0,10:N0} {1,11}", population.Item2, "NA")
          Console.WriteLine("1970      {0,10:N0} {1,11:P2}", population.Item3, rate.Item2/10)
          Console.WriteLine("1980      {0,10:N0} {1,11:P2}", population.Item4, rate.Item3/10)
          Console.WriteLine("1990      {0,10:N0} {1,11:P2}", population.Item5, rate.Item4/10)
          Console.WriteLine("2000      {0,10:N0} {1,11:P2}", population.Item6, rate.Item5/10)
          Console.WriteLine("1960-2000 {0,10:N0} {1,11:P2}", "", rate.Item6/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)) _ 
               As Tuple(Of String, 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.Item6 - data.Item2)/data.Item2 )
          Return rate
       End Function           
    End Module
    ' The example displays the following output:
    '       Population Change, New York, 1960-2000
    '       
    '       Year      Population Annual Rate
    '       1960       7,781,984          NA
    '       1970       7,894,862      0.15 %
    '       1980       7,071,639     -1.04 %
    '       1990       7,322,564      0.35 %
    '       2000       8,008,278      0.94 %
    '       1960-2000                 0.06 %
    
  • Возврат нескольких значений out из метода без использования параметров (в C#) или ByRef параметров (в Visual Basic). Например, предыдущий пример возвращает вычисляемую статистику вместе с именем города в объекте Tuple<T1,T2,T3,T4,T5,T6> .

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

Конструкторы

Tuple<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)

Инициализирует новый экземпляр класса Tuple<T1,T2,T3,T4,T5,T6>.

Свойства

Item1

Получает значение первого компонента текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

Item2

Получает значение второго компонента текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

Item3

Получает значение третьего компонента текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

Item4

Получает значение четвертого компонента текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

Item5

Получает значение пятого компонента текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

Item6

Получает значение шестого компонента текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

Методы

Equals(Object)

Возвращает значение, показывающее, равен ли текущий объект Tuple<T1,T2,T3,T4,T5,T6> указанному объекту.

GetHashCode()

Возвращает хэш-код для текущего объекта Tuple<T1,T2,T3,T4,T5,T6>.

GetType()

Возвращает объект Type для текущего экземпляра.

(Унаследовано от Object)
MemberwiseClone()

Создает неполную копию текущего объекта Object.

(Унаследовано от Object)
ToString()

Возвращает строковое представление значения этого экземпляра Tuple<T1,T2,T3,T4,T5,T6>.

Явные реализации интерфейса

IComparable.CompareTo(Object)

Сравнивает текущий объект Tuple<T1,T2,T3,T4,T5,T6> с заданным объектом и возвращает целое число, указывающее, находится ли текущий объект в той же позиции, что и указанный объект, после него или перед ним в порядке сортировки.

IStructuralComparable.CompareTo(Object, IComparer)

Сравнивает текущий объект Tuple<T1,T2,T3,T4,T5,T6> с указанным объектом, используя заданный компаратор, и возвращает целое число, которое показывает положение текущего объекта относительно указанного объекта в порядке сортировки: перед объектом, после него или в той же позиции.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Возвращает значение, показывающее, равен ли текущий атрибут Tuple<T1,T2,T3,T4,T5,T6> указанному объекту при использовании заданного метода сравнения.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Вычисляет хэш-код для текущего объекта Tuple<T1,T2,T3,T4,T5,T6>, используя заданный метод вычисления.

ITuple.Item[Int32]

Получает значение указанного элемента Tuple.

ITuple.Length

Возвращает количество элементов в Tuple.

Методы расширения

Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)

Разбивает кортеж с 6 элементами на отдельные переменные.

ToValueTuple<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>)

Преобразует экземпляр класса Tuple в экземпляр структуры ValueTuple.

Применяется к

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