.Net 3.5 ondersteunt geen tuples. Jammer, maar weet je niet zeker of de toekomstige versie van .net tupels zal ondersteunen of niet?
Antwoord 1, autoriteit 100%
Ik heb zojuist dit artikel uit MSDN Magazine gelezen: Tuple bouwen
Hier zijn fragmenten:
De aanstaande 4.0 release van Microsoft
.NET Framework introduceert een nieuw type
genaamd System.Tuple. System.Tuple is een
vaste grootte collectie van
heterogeen getypte gegevens.
Net als een array heeft een tuple een vaste
maat die niet meer kan worden gewijzigd als hij eenmaal is
gecreëerd. In tegenstelling tot een array, is elk
element in een tupel kan een andere zijn
type, en een tuple kan garanderen:
sterke typering voor elk element.
Er is al een voorbeeld van a
tupel zwevend rond de Microsoft
.NET Framework, in de
System.Collections.Generic naamruimte:
Sleutelwaardepaar. Hoewel KeyValuePair als hetzelfde kan worden beschouwd
als Tuple, aangezien ze beide zijn
typen die twee dingen bevatten,
KeyValuePair voelt anders aan dan
Tuple omdat het een relatie oproept
tussen de twee waarden die het opslaat (en
met een goede reden, want het ondersteunt de
Woordenboekklas).Bovendien kunnen tupels willekeurig zijn
formaat, terwijl KeyValuePair alleen geldt
twee dingen: een sleutel en een waarde.
Hoewel sommige talen, zoals F#, een speciale syntaxis hebben voor tupels, kun je het nieuwe algemene tupeltype uit elke taal gebruiken. Als we het eerste voorbeeld opnieuw bekijken, kunnen we zien dat, hoewel nuttig, tupels overdreven uitgebreid kunnen zijn in talen zonder syntaxis voor een tuple:
class Program {
static void Main(string[] args) {
Tuple<string, int> t = new Tuple<string, int>("Hello", 4);
PrintStringAndInt(t.Item1, t.Item2);
}
static void PrintStringAndInt(string s, int i) {
Console.WriteLine("{0} {1}", s, i);
}
}
Met behulp van het var-sleutelwoord uit C# 3.0 kunnen we de typesignatuur van de tuple-variabele verwijderen, waardoor de code iets beter leesbaar is.
var t = new Tuple<string, int>("Hello", 4);
We hebben ook enkele fabrieksmethoden toegevoegd aan een statische Tuple-klasse, waardoor het gemakkelijker wordt om tuples te bouwen in een taal die type-inferentie ondersteunt, zoals C#.
var t = Tuple.Create("Hello", 4);
Antwoord 2, autoriteit 95%
#region tuples
public class Tuple<T>
{
public Tuple(T first)
{
First = first;
}
public T First { get; set; }
}
public class Tuple<T, T2> : Tuple<T>
{
public Tuple(T first, T2 second)
: base(first)
{
Second = second;
}
public T2 Second { get; set; }
}
public class Tuple<T, T2, T3> : Tuple<T, T2>
{
public Tuple(T first, T2 second, T3 third)
: base(first, second)
{
Third = third;
}
public T3 Third { get; set; }
}
public class Tuple<T, T2, T3, T4> : Tuple<T, T2, T3>
{
public Tuple(T first, T2 second, T3 third, T4 fourth)
: base(first, second, third)
{
Fourth = fourth;
}
public T4 Fourth { get; set; }
}
#endregion
En om verklaringen mooier te maken:
public static class Tuple
{
//Allows Tuple.New(1, "2") instead of new Tuple<int, string>(1, "2")
public static Tuple<T1, T2> New<T1, T2>(T1 t1, T2 t2)
{
return new Tuple<T1, T2>(t1, t2);
}
//etc...
}
Antwoord 3, autoriteit 21%
Er is een correct (niet snel) c # tuple implementatie in Lokad gedeelde bibliotheken (open-source, natuurlijk) met de volgende vereiste functies:
- 2-5 onveranderlijke tuple implementaties
- juiste debuggerdisplayattribute
- juiste hashing en gelijkheidscontroles
- Helpers voor het genereren van tuples uit de meegeleverde parameters (generiek worden afgeleid door compiler) en extensies voor op verzameling gebaseerde operaties.
- productie-getest.
Antwoord 4, Autoriteit 19%
Implementatie van tuple-klassen of hergebruik F # -klassen in C # is slechts de helft van het verhaal – deze geven u het vermogen om tuples met relatief gemak te creëren, maar niet echt de syntactische suiker die ze zo leuk maakt in talen zoals F #.
Bijvoorbeeld in F # U kunt Pattern Matching gebruiken om beide delen van een tuple binnen een laatafvatting te halen, bijvoorbeeld
let (a, b) = someTupleFunc
Helaas om hetzelfde te doen met behulp van de F # -klassen van C # zou veel minder elegant zijn:
Tuple<int,int> x = someTupleFunc();
int a = x.get_Item1();
int b = x.get_Item2();
Tuples vertegenwoordigen een krachtige methode voor het retourneren van meerdere waarden van een functie-oproep zonder de noodzaak om uw code te naderen met wegwerpklassen, of toevlucht nemen tot lelijke ref- of outparameters. Naar mijn mening, zonder enige syntactische suiker om hun creatie te maken en meer eleganter te zijn, zijn ze van beperkt gebruik.
Antwoord 5, Autoriteit 16%
Naar mijn mening is de functie Anonieme types geen tuple, maar een zeer vergelijkbaar construct. De uitvoer van sommige LINQ-query’s zijn collecties van anonieme types, die zich als tuples gedragen.
Hier is een verklaring, die een typed tuple maakt 🙂 on the fly:
var p1 = new {a = "A", b = 3};
Zie: http://www.developer.com/net/csharp/ Article.php / 3589916
Antwoord 6, Autoriteit 7%
C # 7 ondersteunt TUPELS natief:
var unnamedTuple = ("Peter", 29);
var namedTuple = (Name: "Peter", Age: 29);
(string Name, double Age) typedTuple = ("Peter", 29);
Antwoord 7, Autoriteit 4%
My Open Source .Net SASA-bibliotheek heeft al jaren tuples (samen met veel andere functionaliteit , net als volledige mime-parsering). Ik heb het nu een paar jaar in productiecode gebruikt.
Antwoord 8, Autoriteit 4%
C # Ondersteunt eenvoudige tuples via generics vrij gemakkelijk (volgens een eerder antwoord), en met “Mumble typen” (een van de vele mogelijke C # taalverbeteringen) om het type inferentie te verbeteren, kunnen ze heel erg krachtig zijn.
Voor wat het waard is, F # ondersteunt het tuples natief, en heb ermee gespeeld, ik weet niet zeker of dat (anoniem) tuples veel toevoegen … wat je in de bekwaamheid wint, verlies je erg snel in codehelderheid.
Voor code binnen een enkele methode zijn er anonieme types; Voor de code die buiten een methode gaat, denk ik dat ik vast blijft aan eenvoudige genoemde typen. Natuurlijk, als een toekomst C # het gemakkelijker maakt om dit onveranderlijk te maken (terwijl ik nog steeds gemakkelijk kunnen werken), ben ik blij.
Antwoord 9, Autoriteit 3%
Hier is mijn set tuples, ze worden autogogenerated door een python-script, dus ik heb misschien een beetje overboord gegaan:
Link naar Subversion Repository
U hebt een gebruikersnaam / wachtwoord nodig, ze zijn beide gast
Ze zijn gebaseerd op erfenis, maar Tuple<Int32,String>zal niet vergelijken met Tuple<Int32,String,Boolean>zelfs als ze het hebben dezelfde waarden voor de twee eerste leden.
Ze implementeren ook GetHashCode en ToString enzovoort, en veel kleine hulpmethoden.
Voorbeeld van gebruik:
Tuple<Int32, String> t1 = new Tuple<Int32, String>(10, "a");
Tuple<Int32, String, Boolean> t2 = new Tuple<Int32, String, Boolean>(10, "a", true);
if (t1.Equals(t2))
Console.Out.WriteLine(t1 + " == " + t2);
else
Console.Out.WriteLine(t1 + " != " + t2);
Zal uitvoeren:
10, a != 10, a, True
Antwoord 10
Als ik me mijn computerwetenschappen-lessen goed herinner, zijn tuples alleen maar gegevens.
Als u gegroepeerde gegevens wilt: maak klassen die eigenschappen bevatten.
Als je iets nodig hebt als de KeyValuePair, dan is het daar.
Antwoord 11
Het zou me verbazen – C# is een sterk getypeerde taal, terwijl tupels geschikt zijn voor meer dynamisch getypeerde talen. C# is met het verstrijken van de tijd dynamischer geworden, maar dat is syntactische suiker, geen echte verschuiving in de onderliggende gegevenstypen.
Als u twee waarden in één instantie wilt, kan een KeyValuePair<> is een fatsoenlijke vervanger, zij het onhandig. Je kunt ook een struct of een klasse maken die hetzelfde doet en uitbreidbaar is.
Antwoord 12
Om deze bruikbaar te maken in een hashtabel of woordenboek, wil je waarschijnlijk overloads voor GetHashCode en Equals gebruiken.