C'è un trucco nella creazione di un elenco generico di tipo anonimo?

Question

volte ho bisogno di usare una tupla, per esempio io ho la lista dei carri armati e dei loro carri armati di destinazione (che inseguono dopo di loro o qualcosa di simile):

List<Tuple<Tank,Tank>> mylist = new List<Tuple<Tank,Tank>>(); 

e poi quando ho iterare la lista che ho accedervi da

mylist[i].item1 ... 
mylist[i].item2 ... 

e 'molto confusa e mi dimentico sempre ciò che è e ciò che è item1 item2, se potessi accedere da:

mylist[i].AttackingTank... 
mylist[i].TargetTank... 

sarebbe molto più chiaro, c'è un modo per farlo senza definire una classe:

MyTuple 
{ 
public Tank AttackingTank; 
public Tank TargetTank; 
} 

voglio evitare di definire questa classe, perché poi avrei dovuto definire molte classi differenti in diversi scenari, posso fare qualche "trucco" e renderlo anonimo

Qualcosa di simile:

var k = new {Name = "me", phone = 123}; 
mylist.Add(k); 

Il problema, naturalmente, che non ho un tipo da passare a elenco quando ho definisco

Answer 1

È possibile creare una lista vuota per i tipi anonimi e poi usarlo, che godono di piena intelisence e in fase di compilazione controlli:

var list = Enumerable.Empty<object>() 
      .Select(r => new {A = 0, B = 0}) // prototype of anonymous type 
      .ToList(); 

list.Add(new { A = 4, B = 5 }); // adding actual values 

Console.Write(list[0].A); 

Answer 2

si potrebbe usare un List<dynamic>.

var myList = new List<dynamic>(); 
myList.Add(new {Tank = new Tank(), AttackingTank = new Tank()}); 

Console.WriteLine("AttackingTank: {0}", myList[0].AttackingTank); 

Answer 3

Che ne dici di ExpandoObject?

dynamic tuple = new ExpandoObject(); 
tuple.WhatEverYouWantTypeOfTank = new Tank(); // Value of any type 

Modifiche:

dynamic tuple = new ExpandoObject(); 
tuple.AttackingTank = new Tank(); 
tuple.TargetTank = new Tank(); 

var mylist = new List<dynamic> { tuple }; 

//access to items 
Console.WriteLine(mylist[0].AttackingTank); 

Answer 4

Ecco un hack:

var myList = Enumerable.Empty<int>() 
    .Select(dummy => new { AttackingTank = default(Tank), TargetTank = default(Tank), }) 
    .ToList(); 

Se Tank è un tipo di classe, è possibile scrivere (Tank)null anziché default(Tank). Puoi anche utilizzare qualche istanza di Tank che hai a portata di mano.

---

EDIT:

Oppure:

var myList = Enumerable.Repeat(
    new { AttackingTank = default(Tank), TargetTank = default(Tank), }, 
    0).ToList(); 

---

Se si commette un metodo generico, non sarà necessario utilizzare Enumerable.Empty.Si potrebbe andare in questo modo:

static List<TAnon> GetEmptyListWithAnonType<TAnon>(TAnon dummyParameter) 
{ 
    return new List<TAnon>(); 
} 

Si deve essere chiamato con il TAnon dedurre dal loro utilizzo, naturalmente, come in:

var myList = GetEmptyListWithAnonType(new { AttackingTank = default(Tank), TargetTank = default(Tank), }); 

Answer 5

Si potrebbe semplicemente avere un metodo generico che prende un params e lo restituisce:

public static IList<T> ToAnonymousList<T>(params T[] items) 
{ 
    return items; 
} 

Così ora si può dire:

var list=ToAnonymousList 
(
    new{A=1, B=2}, 
    new{A=2, B=2} 
); 

Answer 6

O ancora più semplice

 var tupleList = (
      new[] { 
       new { fruit = "Tomato", colour = "red"}, 
       new { fruit = "Tomato", colour = "yellow"}, 
       new { fruit = "Apple", colour = "red"}, 
       new { fruit = "Apple", colour = "green"}, 
       new { fruit = "Medlar", colour = "russet"} 
      }).ToList(); 

che perde la funzione statica.

Answer 7

Solo per aggiungere un altro bit utile qui. Io uso la risposta di Alex a volte, ma mi fa un po 'matto cercando di rintracciarlo quando ne ho bisogno, dato che non è ovvio (mi trovo a cercare "new {").

Così ho aggiunto il seguente metodo statico poco (Vorrei poter rendere un metodo di estensione, ma di che tipo?):

public static List<T> CreateEmptyListOf<T>(Func<T> itemCreator) 
{ 
    return Enumerable 
     .Empty<object>() 
     .Select(o => itemCreator()) 
     .ToList(); 
} 

Questa isola la parte che è diverso ogni volta che ho bisogno di questo modello da quelli che sono uguali. Lo chiamo in questo modo:

var emptyList = Ext.CreateEmptyListOf(() => new { Name = default(string), SomeInt = default(int) }); 

Answer 8

Vale la pena notare che, infine, esiste la possibilità di utilizzare tale sintassi. È stato introdotto in C# 7.0

var tanks = new List<(Tank AttackingTank, Tank TargetTank)>(); 

(Tank, Tank) tTank = (new Tank(), new Tank()); 
tanks.Add(tTank); 

var a = tanks[0].AttackingTank; 
var b = tanks[0].TargetTank;