Tuple<T1,T2,T3,T4> Klas

Definitie

Naamruimte:

System

Assembly's:

netstandard.dll, System.Runtime.dll

Bron:

Tuple.cs

Vertegenwoordigt een 4-tuple of viervoudige.

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

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

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

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

Type parameters

T1

Het type van het eerste onderdeel van de tuple.

T2

Het type van het tweede onderdeel van de tuple.

T3

Het type van het derde onderdeel van de tuple.

T4

Het type van het vierde onderdeel van de tuple.

Overname

Object

Tuple<T1,T2,T3,T4>

Implementeringen

IStructuralComparable IStructuralEquatable IComparable ITuple

Opmerkingen

Een tuple is een gegevensstructuur met een specifiek aantal en een bepaalde reeks waarden. De Tuple<T1,T2,T3,T4> klasse vertegenwoordigt een 4-tuple of viervoudige, een tuple met vier componenten.

U kunt een Tuple<T1,T2,T3,T4> object instantiëren door de Tuple<T1,T2,T3,T4> constructor of de statische Tuple.Create<T1,T2,T3,T4>(T1, T2, T3, T4) methode aan te roepen. U kunt de waarde van de onderdelen van de tuple ophalen met behulp van de eigenschappen alleen-lezenItem1Item2Item3, en Item4 exemplaareigenschappen.

Tuples worden op vier verschillende manieren gebruikt:

• Eén set gegevens weergeven. Een tuple kan bijvoorbeeld een databaserecord vertegenwoordigen en de bijbehorende onderdelen kunnen afzonderlijke velden van de record vertegenwoordigen.

• Om eenvoudig toegang te bieden tot en manipulatie van een gegevensset. In het volgende voorbeeld wordt een matrix gedefinieerd met Tuple<T1,T2,T3,T4> objecten die de namen van honkbalwerpers bevatten, het aantal innings dat ze hebben gegooid en het aantal verdiende runs (punten die zonder veldfouten scoren) en treffers die ze hebben opgegeven. De matrix wordt doorgegeven aan de ComputeStatistics methode, waarmee het verdiende uitvoeringsgemiddelde van elke pitcher wordt berekend (het gemiddelde aantal runs dat is opgegeven in een negen-inning-game) en het gemiddelde aantal treffers dat per inning is opgegeven. De methode gebruikt deze twee gemiddelden ook om een hypothetisch effectiviteitsmiddel te berekenen.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        Tuple<string, decimal, int, int>[] pitchers  =  
             { Tuple.Create("McHale, Joe", 240.1m, 221, 96),
               Tuple.Create("Paul, Dave", 233.1m, 231, 84), 
               Tuple.Create("Williams, Mike", 193.2m, 183, 86),
               Tuple.Create("Blair, Jack", 168.1m, 146, 65), 
               Tuple.Create("Henry, Walt", 140.1m, 96, 30),
               Tuple.Create("Lee, Adam", 137.2m, 109, 45),
               Tuple.Create("Rohr, Don", 101.0m, 110, 42) };
        Tuple<string, double, double, double>[] results= ComputeStatistics(pitchers);
  
        // Display the results.
        Console.WriteLine("{0,-20} {1,9} {2,11} {3,15}\n", 
                          "Pitcher", "ERA", "Hits/Inn.", "Effectiveness");
        foreach (var result in results)
           Console.WriteLine("{0,-20} {1,9:F2} {2,11:F2} {3,15:F2}",  
                          result.Item1, result.Item2, result.Item3, result.Item4);
     }
  
     private static Tuple<string, double, double, double>[] ComputeStatistics(Tuple<string, decimal, int, int>[] pitchers)
     {    
        var list = new List<Tuple<string, double, double, double>>();
        Tuple<string, double, double, double> result;
  
        foreach (var pitcher in pitchers)
        {
           // Decimal portion of innings pitched represents 1/3 of an inning
           double innings = (double) Math.Truncate(pitcher.Item2);
           innings = innings + (((double)pitcher.Item2 - innings) * .33);
           
           double ERA = pitcher.Item4/innings * 9;
           double hitsPerInning = pitcher.Item3/innings;
           double EI = (ERA * 2 + hitsPerInning * 9)/3;
           result = new Tuple<string, double, double, double>
                             (pitcher.Item1, ERA, hitsPerInning, EI);
           list.Add(result);
        }
        return list.ToArray();
     }
  }
  // The example displays the following output;
  //       Pitcher                    ERA   Hits/Inn.   Effectiveness
  //       
  //       McHale, Joe               3.60        0.92            5.16
  //       Paul, Dave                3.24        0.99            5.14
  //       Williams, Mike            4.01        0.95            5.52
  //       Blair, Jack               3.48        0.87            4.93
  //       Henry, Walt               1.93        0.69            3.34
  //       Lee, Adam                 2.95        0.80            4.36
  //       Rohr, Don                 3.74        1.09            5.76
  

  open System
  
  let computeStatistics (pitchers: Tuple<string, decimal, int, int>[]) =
      [| for pitcher in pitchers do
          // Decimal portion of innings pitched represents 1/3 of an inning
          let innings =  truncate (double pitcher.Item2) |> double
          let innings = innings + (double pitcher.Item2 - innings) * 0.33
          
          let ERA = double pitcher.Item4 / innings * 9.
          let hitsPerInning = double pitcher.Item3 / innings
          let EI = (ERA * 2. + hitsPerInning * 9.) / 3.
          Tuple<string, double, double, double>(pitcher.Item1, ERA, hitsPerInning, EI)|]
  
  let pitchers  =  
      [| Tuple.Create("McHale, Joe", 240.1m, 221, 96)
         Tuple.Create("Paul, Dave", 233.1m, 231, 84)
         Tuple.Create("Williams, Mike", 193.2m, 183, 86)
         Tuple.Create("Blair, Jack", 168.1m, 146, 65) 
         Tuple.Create("Henry, Walt", 140.1m, 96, 30)
         Tuple.Create("Lee, Adam", 137.2m, 109, 45)
         Tuple.Create("Rohr, Don", 101.0m, 110, 42) |]
  
  let results = computeStatistics pitchers
  
  // Display the results.
  printfn "%-20s %9s %11s %15s\n" "Pitcher" "ERA" "Hits/Inn." "Effectiveness"
  for result in results do
      printfn $"{result.Item1,-20} {result.Item2,9:F2} {result.Item3,11:F2} {result.Item4,15:F2}"
  
  // The example displays the following output
  //       Pitcher                    ERA   Hits/Inn.   Effectiveness
  //       
  //       McHale, Joe               3.60        0.92            5.16
  //       Paul, Dave                3.24        0.99            5.14
  //       Williams, Mike            4.01        0.95            5.52
  //       Blair, Jack               3.48        0.87            4.93
  //       Henry, Walt               1.93        0.69            3.34
  //       Lee, Adam                 2.95        0.80            4.36
  //       Rohr, Don                 3.74        1.09            5.76
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim pitchers() =  
                 { Tuple.Create("McHale, Joe", 240.1d, 221, 96),
                   Tuple.Create("Paul, Dave", 233.1d, 231, 84), 
                   Tuple.Create("Williams, Mike", 193.2d, 183, 86),
                   Tuple.Create("Blair, Jack", 168.1d, 146, 65), 
                   Tuple.Create("Henry, Walt", 140.1d, 96, 30),
                   Tuple.Create("Lee, Adam", 137.2d, 109, 45),
                   Tuple.Create("Rohr, Don", 101.0d, 110, 42) }
        Dim results() = ComputeStatistics(pitchers)
  
        ' Display the results.
        Console.WriteLine("{0,-20} {1,9} {2,11} {3,15}", "Pitcher", "ERA", "Hits/Inn.", "Effectiveness")
        Console.WriteLine()
        For Each result In results
           Console.WriteLine("{0,-20} {1,9:F2} {2,11:F2} {3,15:F2}",  
                          result.Item1, result.Item2, result.Item3, result.Item4)
        Next
     End Sub
     
     Private Function ComputeStatistics(pitchers() As Tuple(Of String, Decimal, Integer, Integer)) _ 
                                  As Tuple(Of String, Double, Double, Double)()
        Dim list As New List(Of Tuple(Of String, Double, Double, Double))
        Dim result As Tuple(Of String, Double, Double, Double)
  
        For Each pitcher As Tuple(Of String, Decimal, Integer, Integer) In pitchers
           ' Decimal portion of innings pitched represents 1/3 of an inning
           Dim innings As Double = CDbl(Math.Truncate(pitcher.Item2))
           innings = innings + ((pitcher.Item2 - innings) * .33)
           
           Dim ERA As Double = pitcher.Item4/innings * 9
           Dim hitsPerInning As Double = pitcher.Item3/innings
           Dim EI As Double = (ERA * 2 + hitsPerInning * 9)/3
           result = New Tuple(Of String, Double, Double, Double) _
                             (pitcher.Item1, ERA, hitsPerInning, EI)
           list.Add(result) 
        Next
        Return list.ToArray()
     End Function
  End Module
  ' The example displays the following output:
  '       Pitcher                    ERA   Hits/Inn.   Effectiveness
  '       
  '       McHale, Joe               3.60        0.92            5.16
  '       Paul, Dave                3.24        0.99            5.14
  '       Williams, Mike            4.01        0.95            5.52
  '       Blair, Jack               3.48        0.87            4.93
  '       Henry, Walt               1.93        0.69            3.34
  '       Lee, Adam                 2.95        0.80            4.36
  '       Rohr, Don                 3.74        1.09            5.76
  

• Als u meerdere waarden wilt retourneren uit een methode zonder gebruik te maken van out parameters (in C#) of ByRef parameters (in Visual Basic). Het vorige voorbeeld retourneert bijvoorbeeld de berekende statistieken, samen met de naam van de pitcher, in een matrix met Tuple<T1,T2,T3,T4> objecten.

• Meerdere waarden doorgeven aan een methode via één parameter. De Thread.Start(Object) methode heeft bijvoorbeeld één parameter waarmee u één waarde kunt opgeven voor de methode die de thread tijdens het opstarten uitvoert. Als u een Tuple<T1,T2,T3,T4> object opgeeft als het methodeargument, kunt u de opstartroutine van de thread opgeven met vier gegevensitems.

Constructors

Name	Description
Tuple<T1,T2,T3,T4>(T1, T2, T3, T4)	Initialiseert een nieuw exemplaar van de Tuple<T1,T2,T3,T4> klasse.

Eigenschappen

Name	Description
Item1	Hiermee haalt u de waarde op van het eerste onderdeel van het huidige Tuple<T1,T2,T3,T4> object.
Item2	Hiermee haalt u de waarde op van het tweede onderdeel van het huidige Tuple<T1,T2,T3,T4> object.
Item3	Hiermee haalt u de waarde op van het derde onderdeel van het huidige Tuple<T1,T2,T3,T4> object.
Item4	Hiermee haalt u de waarde op van het vierde onderdeel van het huidige Tuple<T1,T2,T3,T4> object.

Methoden

Name	Description
Equals(Object)	Retourneert een waarde die aangeeft of het huidige Tuple<T1,T2,T3,T4> object gelijk is aan een opgegeven object.
GetHashCode()	Retourneert de hashcode voor het huidige Tuple<T1,T2,T3,T4> object.
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
ToString()	Retourneert een tekenreeks die de waarde van dit Tuple<T1,T2,T3,T4> exemplaar vertegenwoordigt.

Expliciete interface-implementaties

Name	Description
IComparable.CompareTo(Object)	Vergelijkt het huidige Tuple<T1,T2,T3,T4> object met een opgegeven object en retourneert een geheel getal dat aangeeft of het huidige object zich vóór, na of op dezelfde positie bevindt als het opgegeven object in de sorteervolgorde.
IStructuralComparable.CompareTo(Object, IComparer)	Vergelijkt het huidige Tuple<T1,T2,T3,T4> object met een opgegeven object met behulp van een opgegeven vergelijking en retourneert een geheel getal dat aangeeft of het huidige object zich vóór, na of op dezelfde positie bevindt als het opgegeven object in de sorteervolgorde.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Retourneert een waarde die aangeeft of het huidige Tuple<T1,T2,T3,T4> object gelijk is aan een opgegeven object op basis van een opgegeven vergelijkingsmethode.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Berekent de hashcode voor het huidige Tuple<T1,T2,T3,T4> object met behulp van een opgegeven berekeningsmethode.
ITuple.Item[Int32]	Hiermee haalt u de waarde van het opgegeven Tuple element op.
ITuple.Length	Hiermee wordt het aantal elementen in de Tuple.

Extensiemethoden

Name	Description
Deconstruct<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>, T1, T2, T3, T4)	Hiermee wordt een tuple met vier elementen in afzonderlijke variabelen gedeconstrueerd.
ToValueTuple<T1,T2,T3,T4>(Tuple<T1,T2,T3,T4>)	Converteert een exemplaar van de Tuple klasse naar een exemplaar van de ValueTuple structuur.

Zie ook

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