Ogólna lista anonimowych klas

W C # 3.0 możesz utworzyć anonimową klasę o następującej składni

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

Czy istnieje sposób na dodanie tych anonimowych klas do ogólnej listy?

Przykład:

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

Inny przykład:

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

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

Mógłbyś:

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

Jest wiele sposobów na skórowanie tego kota, ale w zasadzie wszyscy używają gdzieś wnioskowania typu - co oznacza, że ​​musisz wywoływać metodę ogólną (być może jako metodę rozszerzenia). Innym przykładem może być:

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

var list = CreateList(o, o1);

Masz pomysł :)

Oto odpowiedź.

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

Można to zrobić na wiele sposobów, ale niektóre odpowiedzi tutaj tworzą listę zawierającą elementy śmieci, co wymaga wyczyszczenia listy.

Jeśli szukasz pustej listy typu ogólnego, użyj opcji Wybierz przeciwko liście krotek, aby utworzyć pustą listę. Żadne elementy nie zostaną utworzone.

Oto jeden wiersz, aby utworzyć pustą listę:

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

Następnie możesz dodać do niego swój typ ogólny:

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

Alternatywnie możesz zrobić coś takiego jak poniżej, aby utworzyć pustą listę (ale wolę pierwszy przykład, ponieważ możesz go użyć również do zapełnionej kolekcji Tuples):

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

Nie do końca, ale można powiedzieć, że List<object>wszystko będzie działać. Jednak list[0].Idnie zadziała.

Będzie to działać w środowisku wykonawczym w C # 4.0 List<dynamic>, ponieważ oznacza to, że nie uzyskasz IntelliSense.

zgaduję

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

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

będzie działać.

Możesz również rozważyć napisanie tego w ten sposób:

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

Zwykle używam następujących; głównie dlatego, że „zaczynasz” z pustą listą.

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

Ostatnio pisałem to w ten sposób:

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

Zastosowanie metody powtarzania pozwoliłoby również na:

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

... która daje początkową listę z już dodanym pierwszym elementem.

Możesz to zrobić w swoim kodzie.

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

W najnowszej wersji 4.0 można używać dynamiki jak poniżej

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

Sprawdziłem IL na kilka odpowiedzi. Ten kod skutecznie zapewnia pustą listę:

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

Oto moja próba.

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

Wymyśliłem to, kiedy napisałem coś podobnego do stworzenia Anonimowej listy dla niestandardowego typu.

Możesz utworzyć listę dynamiczną.

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

„dynamiczny” jest inicjalizowany przez pierwszą wartość dodaną.

Zamiast tego:

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

Możesz to zrobić:

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

Jeśli jednak spróbujesz zrobić coś takiego w innym zakresie, pojawi się błąd czasu kompilacji, chociaż działa on w czasie wykonywania:

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

Problem polega na tym, że tylko członkowie Object są dostępni w czasie wykonywania, chociaż intellisense pokaże identyfikator właściwości i nazwę .

W .net 4.0 rozwiązaniem jest użycie słowa kluczowego dynamiczna istead obiektu w powyższym kodzie.

Innym rozwiązaniem jest użycie odbicia, aby uzyskać właściwości

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

Oto kolejna metoda tworzenia Listy anonimowych typów, która pozwala zacząć od pustej listy, ale nadal mieć dostęp do IntelliSense.

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

Jeśli chcesz zachować pierwszy element, po prostu umieść jedną literę w ciągu.

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

To stare pytanie, ale pomyślałem, że wstawię odpowiedź C # 6. Często muszę skonfigurować dane testowe, które można łatwo wprowadzić w kodzie jako listę krotek. Dzięki kilku funkcjom rozszerzenia można mieć ten ładny, kompaktowy format, bez powtarzania nazw dla każdego wpisu.

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

To daje IEnumerable - jeśli chcesz listę, którą możesz dodać, po prostu dodaj ToList ().

Magia pochodzi z niestandardowego rozszerzenia Dodaj metody krotek, jak opisano na 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...

}

Jedyne, co mi się nie podoba, to to, że typy są oddzielone od nazw, ale jeśli naprawdę nie chcesz tworzyć nowej klasy, to podejście pozwoli ci mieć czytelne dane.

Jestem bardzo zaskoczony, że nikt nie sugerował inicjalizacji kolekcji. W ten sposób można dodawać obiekty tylko podczas tworzenia listy, stąd nazwa, jednak wydaje się, że jest to najładniejszy sposób. Nie trzeba tworzyć tablicy, a następnie konwertować jej na listę.

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

Zawsze możesz użyć objectzamiast, dynamicale starając się zachować to w sposób ogólny, wtedy dynamicma to większy sens.

Możesz to zrobić w ten sposób:

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

Wydaje mi się to trochę „hacky”, ale działa - jeśli naprawdę potrzebujesz listy i nie możesz po prostu użyć anonimowej tablicy.

W drugim przykładzie, w którym musisz zainicjować nowy List<T>, jednym z pomysłów jest utworzenie anonimowej listy, a następnie wyczyszczenie jej.

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

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

Lub jako metoda rozszerzenia powinna być łatwiejsza:

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

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

A może nawet krótszy,

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

Jeśli używasz C # 7 lub nowszego, możesz użyć typów krotek zamiast typów anonimowych.

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

Na podstawie tej odpowiedzi opracowałem dwie metody, które mogłyby wykonać to zadanie:

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

Możesz użyć metod takich jak

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

Ta odpowiedź ma podobny pomysł, ale nie widziałam jej, dopóki nie stworzyłem tych metod.

Spróbuj tego:

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