Un elenco generico di classe anonima

Question

In C# 3.0 è possibile creare classe anonima con la seguente sintassi

var o = new { Id = 1, Name = "Foo" }; 

Esiste un modo per aggiungere questi classe anonima ad un elenco generico?

Esempio:

var o = new { Id = 1, Name = "Foo" }; 
var o1 = new { Id = 2, Name = "Bar" }; 

List<var> list = new List<var>(); 
list.Add(o); 
list.Add(o1); 

Un altro esempio:

List<var> list = new List<var>(); 

while (....) 
{ 
    .... 
    list.Add(new {Id = x, Name = y}); 
    .... 
} 

Answer 1

Si potrebbe fare:

var list = new[] { o, o1 }.ToList(); 

Ci sono molti modi di scuoiare questo gatto, ma in fondo saranno tutti di tipo utilizzo deduzione da qualche parte - il che significa che hai avuto modo di essere chiamata un metodo generico (possibilmente come metodo di estensione). Un altro esempio potrebbe essere:

public static List<T> CreateList<T>(params T[] elements) 
{ 
    return new List<T>(elements); 
} 

var list = CreateList(o, o1); 

si ottiene l'idea :)

Answer 2

Non esattamente, ma si può dire che List<object> e le cose funzioneranno. Tuttavia, list[0].Id non funzionerà.

Ciò funzionerà in fase di esecuzione in C# 4.0 avendo un List<dynamic>, ovvero non si otterrà IntelliSense.

Answer 3

Credo

List<T> CreateEmptyGenericList<T>(T example) { 
    return new List<T>(); 
} 

void something() { 
    var o = new { Id = 1, Name = "foo" }; 
    var emptyListOfAnonymousType = CreateEmptyGenericList(o); 
} 

funzionerà.

Si potrebbe anche non crei in questo modo:

void something() { 
    var String = string.Emtpy; 
    var Integer = int.MinValue; 
    var emptyListOfAnonymousType = CreateEmptyGenericList(new { Id = Integer, Name = String }); 
} 

Answer 4

si può fare in questo modo:

var o = new { Id = 1, Name = "Foo" }; 
var o1 = new { Id = 2, Name = "Bar" }; 

var array = new[] { o, o1 }; 
var list = array.ToList(); 

list.Add(new { Id = 3, Name = "Yeah" }); 

sembra un po ' "hacky" per me, ma funziona - se davvero bisogno di avere una lista e non può semplicemente usare la matrice anonima.

Answer 5

Ecco la risposta.

string result = String.Empty; 

var list = new[] 
{ 
    new { Number = 10, Name = "Smith" }, 
    new { Number = 10, Name = "John" } 
}.ToList(); 

foreach (var item in list) 
{ 
    result += String.Format("Name={0}, Number={1}\n", item.Name, item.Number); 
} 

MessageBox.Show(result); 

Answer 6

Invece di questo:

var o = new { Id = 1, Name = "Foo" }; 
var o1 = new { Id = 2, Name = "Bar" }; 

List <var> list = new List<var>(); 
list.Add(o); 
list.Add(o1); 

Si potrebbe fare questo:

var o = new { Id = 1, Name = "Foo" }; 
var o1 = new { Id = 2, Name = "Bar" }; 

List<object> list = new List<object>(); 
list.Add(o); 
list.Add(o1); 

Tuttavia, si otterrà un errore di compiletime se si tenta di fare qualcosa di simile in un altro campo di applicazione, anche se funziona in runtime:

private List<object> GetList() 
{ 
    List<object> list = new List<object>(); 
    var o = new { Id = 1, Name = "Foo" }; 
    var o1 = new { Id = 2, Name = "Bar" }; 
    list.Add(o); 
    list.Add(o1); 
    return list; 
} 

private void WriteList() 
{ 
    foreach (var item in GetList()) 
    { 
     Console.WriteLine("Name={0}{1}", item.Name, Environment.NewLine); 
    } 
} 

Il problema è che solo i membri di Object sono disponibili in fase di runtime, sebbene intellisense mostrerà le proprietà id e nome.

In .net 4.0 una soluzione è utilizzare la parola chiave dinamica nell'oggetto oggetto nel codice sopra.

Un'altra soluzione è quella di utilizzare la reflection per ottenere le proprietà

using System; 
using System.Collections.Generic; 
using System.Reflection; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Program p = new Program(); 
      var anonymous = p.GetList(new[]{ 
       new { Id = 1, Name = "Foo" },  
       new { Id = 2, Name = "Bar" } 
      }); 

      p.WriteList(anonymous); 
     } 

     private List<T> GetList<T>(params T[] elements) 
     { 
      var a = TypeGenerator(elements); 
      return a; 
     } 

     public static List<T> TypeGenerator<T>(T[] at) 
     { 
      return new List<T>(at); 
     } 

     private void WriteList<T>(List<T> elements) 
     { 
      PropertyInfo[] pi = typeof(T).GetProperties(); 
      foreach (var el in elements) 
      { 
       foreach (var p in pi) 
       { 
        Console.WriteLine("{0}", p.GetValue(el, null)); 
       } 
      } 
      Console.ReadLine(); 
     } 
    } 
} 

Answer 7

Qui è il mio tentativo.

List<object> list = new List<object> { new { Id = 10, Name = "Testing1" }, new {Id =2, Name ="Testing2" }}; 

L'ho trovato quando ho scritto qualcosa di simile per creare un elenco anonimo per un tipo personalizzato.

Answer 8

var list = new[]{ 
new{ 
FirstField = default(string), 
SecondField = default(int), 
ThirdField = default(double) 
} 
}.ToList(); 
list.RemoveAt(0); 

Answer 9

static void Main() 
{ 
    List<int> list = new List<int>(); 
    list.Add(2); 
    list.Add(3); 
    list.Add(5); 
    list.Add(7); 
} 

Answer 10

È possibile farlo nel codice.

var list = new[] { new { Id = 1, Name = "Foo" } }.ToList(); 
list.Add(new { Id = 2, Name = "Bar" }); 

Answer 11

Per il vostro secondo esempio, dove si deve inizializzare una nuova List<T>, un'idea è quella di creare un elenco anonimo, e quindi cancellarlo.

var list = new[] { o, o1 }.ToList(); 
list.Clear(); 

//and you can keep adding. 
while (....) 
{ 
    .... 
    list.Add(new { Id = x, Name = y }); 
    .... 
} 

O come un metodo di estensione, dovrebbe essere più facile:

public static List<T> GetEmptyListOfThisType<T>(this T item) 
{ 
    return new List<T>(); 
} 

//so you can call: 
var list = new { Id = 0, Name = "" }.GetEmptyListOfThisType(); 

O probabilmente ancora più breve,

var list = new int[0].Select(x => new { Id = 0, Name = "" }).Tolist(); 

Answer 12

Io di solito uso il seguente; principalmente perché tu "inizi" con una lista vuota.

var list = Enumerable.Range(0, 0).Select(e => new { ID = 1, Name = ""}).ToList(); 
list.Add(new {ID = 753159, Name = "Lamont Cranston"}); 
//etc. 

Ultimamente, ho scritto in questo modo invece:

var list = Enumerable.Repeat(new { ID = 1, Name = "" }, 0).ToList(); 
list.Add(new {ID = 753159, Name = "Lamont Cranston"}); 

Utilizzando il metodo di ripetizione consentirebbe anche di fare:

var myObj = new { ID = 1, Name = "John" }; 
var list = Enumerable.Repeat(myObj, 1).ToList(); 
list.Add(new { ID = 2, Name = "Liana" }); 

..che te la dà elenco iniziale con il primo elemento già aggiunto.

Answer 13

prova con questo:

var result = new List<object>(); 

foreach (var test in model.ToList()) { 
    result.Add(new {Id = test.IdSoc,Nom = test.Nom}); 
} 

Answer 14

Ecco un altro metodo di creazione di un elenco di tipi anonimi che permette di iniziare con una lista vuota, ma hanno ancora accesso a IntelliSense.

var items = "".Select(t => new {Id = 1, Name = "foo"}).ToList(); 

Se si desidera mantenere il primo elemento, inserire solo una lettera nella stringa.

var items = "1".Select(t => new {Id = 1, Name = "foo"}).ToList(); 

Answer 15

Ci sono molti modi per fare questo, ma alcune delle risposte qui stanno creando un elenco che contiene elementi della spazzatura, che richiede di cancellare l'elenco.

Se si sta cercando un elenco vuoto del tipo generico, utilizzare un Seleziona contro un elenco di tuple per creare l'elenco vuoto. Nessun elemento verrà istanziato.

Ecco l'one-liner per creare una lista vuota:

var emptyList = new List<Tuple<int, string>>() 
      .Select(t => new { Id = t.Item1, Name = t.Item2 }).ToList(); 

Quindi è possibile aggiungere ad esso utilizzando il vostro tipo generico:

emptyList.Add(new { Id = 1, Name = "foo" }); 
emptyList.Add(new { Id = 2, Name = "bar" }); 

In alternativa, si può fare qualcosa di simile qui sotto per creare la lista vuota (Ma preferisco il primo esempio perché puoi usarlo anche per una collezione popolata di Tuples):

var emptyList = new List<object>() 
      .Select(t => new { Id = default(int), Name = default(string) }).ToList(); 

Answer 16

Ho controllato l'IL su diverse risposte. Questo codice fornisce in modo efficiente una lista vuota:

using System.Linq; 
    … 
    var list = new[]{new{Id = default(int), Name = default(string)}}.Skip(1).ToList(); 

Answer 17

Questa è una domanda vecchia, ma ho pensato di inserire la risposta C# 6. Spesso devo impostare i dati di test che sono facilmente inseriti in codice come elenco di tuple. Con un paio di funzioni di estensione, è possibile avere questo formato piacevole e compatto, senza ripetere i nomi su ciascuna voce.

var people= new List<Tuple<int, int, string>>() { 
    {1, 11, "Adam"}, 
    {2, 22, "Bill"}, 
    {3, 33, "Carol"} 
}.Select(t => new { Id = t.Item1, Age = t.Item2, Name = t.Item3 }); 

Questo dà un IEnumerable - se si desidera un elenco che è possibile aggiungere a quel momento basta aggiungere ToList().

La magia viene dall'estensione personalizzata Aggiungi metodi per le tuple, come descritto a https://stackoverflow.com/a/27455822/4536527.

public static class TupleListExtensions { 
    public static void Add<T1, T2>(this IList<Tuple<T1, T2>> list, 
      T1 item1, T2 item2)  { 
     list.Add(Tuple.Create(item1, item2)); 
    } 

    public static void Add<T1, T2, T3>(this IList<Tuple<T1, T2, T3>> list, 
      T1 item1, T2 item2, T3 item3) { 
     list.Add(Tuple.Create(item1, item2, item3)); 
    } 

// and so on... 

}

L'unica cosa che non mi piace è che i tipi sono separati dai nomi, ma se davvero non si vuole fare una nuova classe, allora questo approccio sarà ancora permetterà di avere dati leggibili

Answer 18

Nella versione 4.0, può usare dinamico come di seguito

var list = new List<dynamic>(); 
     list.Add(new { 
      Name = "Damith" 
    }); 
     foreach(var item in list){ 
      Console.WriteLine(item.Name); 
     } 
    } 

Answer 19

È possibile creare un elenco di dinamica.

List<dynamic> anons=new List<dynamic>(); 
foreach (Model model in models) 
{ 
    var anon= new 
    { 
     Id = model.Id, 
     Name=model.Name 
    }; 
    anons.Add(anon); 
} 

"dinamico" viene inizializzato dal primo valore aggiunto.