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

Definisi

Ruang nama:: System

Rakitan:: mscorlib.dll, System.Runtime.dll

Rakitan:: netstandard.dll, System.Runtime.dll

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Sumber:: Tuple.cs

Sumber:: Tuple.cs

Sumber:: Tuple.cs

Sumber:: Tuple.cs

Sumber:: Tuple.cs

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Mewakili 6 tuple, atau sextuple.

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

Jenis parameter

T1

Jenis komponen pertama tuple.

T2

Jenis komponen kedua tuple.

T3

Jenis komponen ketiga tuple.

T4

Jenis komponen keempat tuple.

T5

Jenis komponen kelima tuple.

T6

Jenis komponen keenam tuple.

Warisan: Object
Tuple<T1,T2,T3,T4,T5,T6>

Atribut: SerializableAttribute

Penerapan: IStructuralComparable IStructuralEquatable IComparable ITuple

Keterangan

Tuple adalah struktur data yang memiliki angka dan urutan nilai tertentu. Kelas ini Tuple<T1,T2,T3,T4,T5,T6> mewakili 6 tuple, atau sextuple, yang merupakan tuple yang memiliki enam komponen.

Anda dapat membuat Tuple<T1,T2,T3,T4,T5,T6> instans objek dengan memanggil Tuple<T1,T2,T3,T4,T5,T6> metode statis Tuple.Create<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6) atau . Anda dapat mengambil nilai komponen tuple dengan menggunakan properti instans , , Item1, Item2 Item3, Item4, dan Item5 baca-sajaItem6.

Tuple umumnya digunakan dengan empat cara berbeda:

Untuk mewakili satu set data. Misalnya, tuple dapat mewakili rekaman database, dan komponennya dapat mewakili bidang rekaman individual.

Untuk menyediakan akses mudah ke, dan manipulasi, himpunan data. Contoh berikut mendefinisikan Tuple<T1,T2,T3,T4,T5,T6> objek yang berisi data populasi untuk Kota New York untuk setiap sensus dari 1960 hingga 2000. Sextuple diteruskan ke ComputePopulationChange metode , yang menghitung tingkat perubahan tahunan antara sensus, serta tingkat perubahan tahunan untuk seluruh periode 50 tahun.

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 %

Untuk mengembalikan beberapa nilai dari metode tanpa menggunakan out parameter (dalam C#) atau ByRef parameter (di Visual Basic). Misalnya, contoh sebelumnya mengembalikan statistik komputasinya, bersama dengan nama kota, dalam objek Tuple<T1,T2,T3,T4,T5,T6> .
Untuk meneruskan beberapa nilai ke metode melalui satu parameter. Misalnya, Thread.Start(Object) metode ini memiliki satu parameter yang memungkinkan Anda menyediakan satu nilai ke metode yang dijalankan utas saat startup. Jika Anda menyediakan Tuple<T1,T2,T3,T4,T5,T6> objek sebagai argumen metode, Anda dapat menyediakan rutinitas startup utas dengan enam item data.

Konstruktor

Nama	Deskripsi
Tuple<T1,T2,T3,T4,T5,T6>(T1, T2, T3, T4, T5, T6)	Menginisialisasi instans baru dari kelas Tuple<T1,T2,T3,T4,T5,T6>.

Properti

Nama	Deskripsi
Item1	Mendapatkan nilai komponen pertama objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .
Item2	Mendapatkan nilai komponen kedua objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .
Item3	Mendapatkan nilai komponen ketiga objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .
Item4	Mendapatkan nilai komponen keempat objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .
Item5	Mendapatkan nilai komponen kelima objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .
Item6	Mendapatkan nilai komponen keenam objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .

Metode

Nama	Deskripsi
Equals(Object)	Mengembalikan nilai yang menunjukkan apakah objek saat ini Tuple<T1,T2,T3,T4,T5,T6> sama dengan objek tertentu.
GetHashCode()	Mengembalikan kode hash untuk objek saat ini Tuple<T1,T2,T3,T4,T5,T6> .
GetType()	Mendapatkan Type instans saat ini. (Diperoleh dari Object)
MemberwiseClone()	Membuat salinan dangkal dari Objectsaat ini. (Diperoleh dari Object)
ToString()	Mengembalikan string yang mewakili nilai instans ini Tuple<T1,T2,T3,T4,T5,T6> .

Implementasi Antarmuka Eksplisit

Nama	Deskripsi
IComparable.CompareTo(Object)	Membandingkan objek saat ini Tuple<T1,T2,T3,T4,T5,T6> dengan objek tertentu dan mengembalikan bilangan bulat yang menunjukkan apakah objek saat ini sebelum, sesudah, atau dalam posisi yang sama dengan objek yang ditentukan dalam urutan pengurutan.
IStructuralComparable.CompareTo(Object, IComparer)	Membandingkan objek saat ini Tuple<T1,T2,T3,T4,T5,T6> dengan objek tertentu dengan menggunakan pembanding tertentu dan mengembalikan bilangan bulat yang menunjukkan apakah objek saat ini adalah sebelum, sesudah, atau dalam posisi yang sama dengan objek yang ditentukan dalam urutan pengurutan.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Mengembalikan nilai yang menunjukkan apakah objek saat ini Tuple<T1,T2,T3,T4,T5,T6> sama dengan objek tertentu berdasarkan metode perbandingan yang ditentukan.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Menghitung kode hash untuk objek saat ini Tuple<T1,T2,T3,T4,T5,T6> dengan menggunakan metode komputasi tertentu.
ITuple.Item[Int32]	Mendapatkan nilai elemen yang ditentukan `Tuple` .
ITuple.Length	Mendapatkan jumlah elemen dalam `Tuple`.

Metode Ekstensi

Nama	Deskripsi
Deconstruct<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>, T1, T2, T3, T4, T5, T6)	Mendekonstruksi tuple dengan 6 elemen ke dalam variabel terpisah.
ToValueTuple<T1,T2,T3,T4,T5,T6>(Tuple<T1,T2,T3,T4,T5,T6>)	Mengonversi instans `Tuple` kelas menjadi instans `ValueTuple` struktur.

Berlaku untuk

Lihat juga

Saran dan Komentar

Apakah halaman ini membantu?