Une liste générique de classe anonyme

En C # 3.0, vous pouvez créer une classe anonyme avec la syntaxe suivante

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

Existe-t-il un moyen d'ajouter ces classes anonymes à une liste générique?

Exemple:

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 autre exemple:

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

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

Vous pourriez faire:

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

Il existe de nombreuses façons de dépouiller ce chat, mais en gros, ils utiliseront tous l'inférence de type quelque part - ce qui signifie que vous devez appeler une méthode générique (éventuellement comme méthode d'extension). Un autre exemple pourrait être:

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

var list = CreateList(o, o1);

Vous avez eu l'idée :)

Voici la réponse.

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);

Il existe plusieurs façons de le faire, mais certaines des réponses ici créent une liste qui contient des éléments inutiles, ce qui vous oblige à effacer la liste.

Si vous recherchez une liste vide de type générique, utilisez une sélection par rapport à une liste de tuples pour créer la liste vide. Aucun élément ne sera instancié.

Voici le one-liner pour créer une liste vide:

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

Ensuite, vous pouvez y ajouter en utilisant votre type générique:

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

Comme alternative, vous pouvez faire quelque chose comme ci-dessous pour créer la liste vide (Mais, je préfère le premier exemple parce que vous pouvez également l'utiliser pour une collection remplie de Tuples):

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

Pas exactement, mais vous pouvez dire List<object>et les choses fonctionneront. Cependant, list[0].Idne fonctionnera pas.

Cela fonctionnera à l'exécution en C # 4.0 en ayant un List<dynamic>, c'est-à-dire que vous n'obtiendrez pas IntelliSense.

j'imagine

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

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

marchera.

Vous pourriez également envisager de l'écrire comme ceci:

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

J'utilise habituellement ce qui suit; principalement parce que vous "commencez" avec une liste vide.

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

Dernièrement, je l'ai écrit comme ceci à la place:

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

L'utilisation de la méthode de répétition vous permettrait également de faire:

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

..qui vous donne la liste initiale avec le premier élément déjà ajouté.

Vous pouvez le faire dans votre code.

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

Dans la dernière version 4.0, peut utiliser dynamique comme ci-dessous

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

J'ai vérifié l'IL sur plusieurs réponses. Ce code fournit efficacement une liste vide:

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

Voici ma tentative.

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

Je suis venu avec cela quand j'ai écrit quelque chose de similaire pour faire une liste anonyme pour un type personnalisé.

Vous pouvez créer une liste de dynamiques.

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

"dynamique" est initialisé par la première valeur ajoutée.

Au lieu de cela:

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);

Vous pouvez faire ceci:

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);

Cependant, vous obtiendrez une erreur de temps de compilation si vous essayez de faire quelque chose comme ça dans une autre étendue, bien que cela fonctionne à l'exécution:

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); 
    }
}

Le problème est que seuls les membres d'Object sont disponibles au moment de l'exécution, bien qu'intellisense affiche l' ID et le nom des propriétés .

Dans .net 4.0, une solution consiste à utiliser le mot clé istead dynamique d' objet dans le code ci-dessus.

Une autre solution consiste à utiliser la réflexion pour obtenir les propriétés

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();
        }
    }
}

Voici une autre méthode de création d'une liste de types anonymes qui vous permet de commencer avec une liste vide, tout en ayant accès à IntelliSense.

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

Si vous souhaitez conserver le premier élément, mettez simplement une lettre dans la chaîne.

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

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

C'est une vieille question, mais je pensais que je mettrais ma réponse C # 6. Je dois souvent configurer des données de test qui sont facilement saisies dans le code sous forme de liste de tuples. Avec quelques fonctions d'extension, il est possible d'avoir ce joli format compact, sans répéter les noms sur chaque entrée.

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 });

Cela donne un IEnumerable - si vous voulez une liste que vous pouvez ajouter, ajoutez simplement ToList ().

La magie vient des méthodes d'ajout d'extensions personnalisées pour les tuples, comme décrit sur 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...

}

La seule chose que je n'aime pas, c'est que les types sont séparés des noms, mais si vous ne voulez vraiment pas créer une nouvelle classe, cette approche vous permettra toujours d'avoir des données lisibles.

Je suis très surpris que personne n'ait suggéré d'initialisation de collection. Cette façon ne peut ajouter des objets que lorsque la liste est créée, d'où le nom, mais cela semble être la meilleure façon de le faire. Pas besoin de créer un tableau puis de le convertir en liste.

var list = new List<dynamic>() 
{ 
    new { Id = 1, Name = "Foo" }, 
    new { Id = 2, Name = "Bar" } 
};

Vous pouvez toujours utiliser objectau lieu de, dynamicmais essayer de le garder d'une manière générique véritable a alors dynamicplus de sens.

Vous pouvez le faire de cette façon:

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" });

Cela me semble un peu "hacky", mais cela fonctionne - si vous avez vraiment besoin d'avoir une liste et que vous ne pouvez pas simplement utiliser le tableau anonyme.

Pour votre deuxième exemple, où vous devez initialiser un nouveau List<T>, une idée est de créer une liste anonyme, puis de l'effacer.

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

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

Ou comme méthode d'extension, devrait être plus 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();

Ou probablement encore plus court,

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

Si vous utilisez C # 7 ou supérieur, vous pouvez utiliser des types de tuple au lieu de types anonymes.

var myList = new List<(int IntProp, string StrProp)>();
myList.Add((IntProp: 123, StrProp: "XYZ"));

Dérivant de cette réponse , j'ai trouvé deux méthodes qui pourraient faire la tâche:

    /// <summary>
    /// Create a list of the given anonymous class. <paramref name="definition"/> isn't called, it is only used
    /// for the needed type inference. This overload is for when you don't have an instance of the anon class
    /// and don't want to make one to make the list.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="definition"></param>
    /// <returns></returns>
#pragma warning disable RECS0154 // Parameter is never used
    public static List<T> CreateListOfAnonType<T>(Func<T> definition)
#pragma warning restore RECS0154 // Parameter is never used
    {
        return new List<T>();
    }
    /// <summary>
    /// Create a list of the given anonymous class. <paramref name="definition"/> isn't added to the list, it is
    /// only used for the needed type inference. This overload is for when you do have an instance of the anon
    /// class and don't want the compiler to waste time making a temp class to define the type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="definition"></param>
    /// <returns></returns>
#pragma warning disable RECS0154 // Parameter is never used
    public static List<T> CreateListOfAnonType<T>(T definition)
#pragma warning restore RECS0154 // Parameter is never used
    {
        return new List<T>();
    }

Vous pouvez utiliser les méthodes comme

var emptyList = CreateListOfAnonType(()=>new { Id = default(int), Name = default(string) });
//or
var existingAnonInstance = new { Id = 59, Name = "Joe" };
var otherEmptyList = CreateListOfAnonType(existingAnonInstance);

Cette réponse a une idée similaire, mais je ne l'ai vue qu'après avoir fait ces méthodes.

Essayez avec ceci:

var result = new List<object>();

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

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