Загальний список анонімного класу

У C # 3.0 ви можете створити анонімний клас із наступним синтаксисом

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

Чи є спосіб додати ці анонімні класи до загального списку?

Приклад:

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

Ще один приклад:

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

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

Ви можете зробити:

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

Існує маса способів зняти цю кішку, але в основному всі вони кудись використовують висновки про тип - це означає, що вам потрібно викликати загальний метод (можливо, як метод розширення). Іншим прикладом може бути:

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

var list = CreateList(o, o1);

Ви отримуєте ідею :)

Ось відповідь.

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

Існує багато способів зробити це, але деякі відповіді тут створюють список, який містить елементи сміття, що вимагає очищення списку.

Якщо ви шукаєте порожній список загального типу, використовуйте пункт Вибрати проти списку кортежів, щоб зробити порожній список. Жоден елемент не буде створений.

Ось один лайнер для створення порожнього списку:

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

Потім ви можете додати до нього за допомогою свого загального типу:

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

Як альтернативу, ви можете зробити щось на кшталт нижче, щоб створити порожній список (Але я вважаю за краще перший приклад, тому що ви можете використовувати його і для заселеної колекції Tuples):

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

Не зовсім так, але ви можете сказати, List<object>і справи будуть працювати. Однак list[0].Idне вийде.

Це працюватиме під час виконання в C # 4.0, маючи a List<dynamic>, тобто ви не отримаєте IntelliSense.

я вважаю

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

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

буду працювати.

Ви також можете розглянути можливість написання цього тексту так:

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

Я зазвичай використовую наступне; головним чином тому, що ви потім "починаєте" зі порожнього списку.

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

Останнім часом я замість цього писав так:

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

Використання методу повтору також дозволить вам зробити:

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

..який дає вам початковий список із уже доданим першим елементом.

Це можна зробити у своєму коді.

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

В останній версії 4.0 можна використовувати такі динамічні, як нижче

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

Я перевірив ІЛ на кілька відповідей. Цей код ефективно забезпечує порожній список:

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

Ось моя спроба.

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

Я придумав це, коли написав щось подібне для створення списку анонімних для користувацького типу.

Можна створити список динамічних.

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

"Динамічний" отримує ініціалізацію першою доданою вартістю.

Замість цього:

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

Ви можете це зробити:

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

Однак ви отримаєте помилку компіляції, якщо спробуєте зробити щось подібне в іншому обсязі, хоча це працює під час виконання:

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

Проблема полягає в тому, що під час виконання програми доступні лише члени Object, хоча intellisense відображатиме ідентифікатори властивостей та ім'я .

У .net 4.0 рішенням є використання ключового слова динамічний istaad об'єкта у наведеному вище коді.

Іншим рішенням є використання відображення для отримання властивостей

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

Ось ще один метод створення Списку анонімних типів, який дозволяє починати з порожнього списку, але все ще маєте доступ до IntelliSense.

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

Якщо ви хотіли зберегти перший елемент, просто покладіть одну букву в рядок.

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

Це давнє запитання, але я думав, що я поставив би свою відповідь С # 6. Мені часто доводиться встановлювати тестові дані, які легко вводяться в код як список кортежів. За допомогою декількох функцій розширення можна отримати цей приємний, компактний формат, не повторюючи імена на кожному записі.

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

Це дає IEnumerable - якщо ви хочете список, до якого ви можете додати, просто додайте ToList ().

Магія походить від спеціального розширення Додати методи для кортежів, як описано на веб-сторінці 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...

}

Єдине, що мені не подобається, це те, що типи відокремлені від імен, але якщо ви дійсно не хочете складати новий клас, то такий підхід все одно дозволить вам мати читабельні дані.

Я дуже здивований, що ніхто не запропонував ініціалізатори колекції. Цей спосіб може додавати об’єкти лише тоді, коли список створений, звідси і назва, однак це виглядає як найприємніший спосіб зробити це. Не потрібно створювати масив, потім перетворите його у список.

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

Ви завжди можете використовувати objectзамість цього, dynamicале намагатися зберегти його справжнім загальним способом, то dynamicмає більше сенсу.

Ви можете це зробити так:

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

Мені це здається трохи "хакітним", але це працює - якщо вам справді потрібно мати список і не можете просто використовувати анонімний масив.

Для вашого другого прикладу, коли вам потрібно ініціалізувати новий List<T>, одна ідея - створити анонімний список, а потім очистити його.

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

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

Або спосіб розширення повинен бути простішим:

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

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

Або, можливо, навіть коротше,

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

Якщо ви використовуєте C # 7 або вище, ви можете використовувати типи кортежу замість анонімних типів.

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

Виходячи з цієї відповіді , я придумав два методи, які могли б виконати завдання:

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

Можна використовувати такі методи

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

Ця відповідь має схожу ідею, але я не бачив її лише після того, як я застосував ці методи.

Спробуйте з цим:

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