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

Ссылка

Определение

Пространство имен:: System

Сборка:: System.Runtime.dll

Сборка:: mscorlib.dll

Сборка:: netstandard.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

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

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

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

Наследование: Object
Tuple<T1,T2,T3,T4,T5,T6>

Атрибуты: SerializableAttribute

Реализации: IStructuralComparable IStructuralEquatable IComparable ITuple

Кортеж — это структура данных, которая имеет определенное число и последовательность значений. Класс 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) метод. Значение компонентов кортежа можно получить с помощью свойств экземпляра, доступных только Item1 Item2для чтения , , Item3, Item4и Item5 Item6 экземпляра.

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

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

Для обеспечения простого доступа к набору данных и управления ими. В следующем примере определяется 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`.

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

Поделиться через