Một danh sách chung của lớp ẩn danh

Trong C # 3.0, bạn có thể tạo lớp ẩn danh với cú pháp sau

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

Có cách nào để thêm các lớp ẩn danh này vào một danh sách chung không?

Thí dụ:

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

Một vi dụ khac:

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

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

Bạn có thể làm:

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

Có rất nhiều cách để lột da con mèo này, nhưng về cơ bản, tất cả chúng sẽ sử dụng suy luận kiểu ở đâu đó - điều đó có nghĩa là bạn phải gọi một phương thức chung (có thể là phương pháp mở rộng). Một ví dụ khác có thể là:

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

var list = CreateList(o, o1);

Bạn có ý tưởng :)

Đây là câu trả lời.

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

Có nhiều cách để làm điều này, nhưng một số câu trả lời ở đây đang tạo một danh sách chứa các thành phần rác, yêu cầu bạn xóa danh sách.

Nếu bạn đang tìm kiếm một danh sách trống của loại chung, hãy sử dụng Chọn đối với Danh sách các Tuples để tạo danh sách trống. Không có yếu tố sẽ được khởi tạo.

Đây là một lớp lót để tạo một danh sách trống:

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

Sau đó, bạn có thể thêm vào nó bằng cách sử dụng loại chung của bạn:

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

Để thay thế, bạn có thể làm một cái gì đó như dưới đây để tạo danh sách trống (Nhưng, tôi thích ví dụ đầu tiên vì bạn cũng có thể sử dụng nó cho một bộ sưu tập Tuples đông dân cư):

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

Không chính xác, nhưng bạn có thể nói List<object>và mọi thứ sẽ hoạt động. Tuy nhiên, list[0].Idsẽ không làm việc.

Điều này sẽ hoạt động trong thời gian chạy trong C # 4.0 bằng cách có một List<dynamic>, đó là bạn sẽ không nhận được IntelliSense.

tôi đoán

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

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

sẽ làm việc.

Bạn cũng có thể xem xét viết nó như thế này:

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

Tôi thường sử dụng như sau; chủ yếu là vì sau đó bạn "bắt đầu" với một danh sách trống.

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

Gần đây, tôi đã viết nó như thế này:

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

Sử dụng phương thức lặp lại cũng sẽ cho phép bạn thực hiện:

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

.. trong đó cung cấp cho bạn danh sách ban đầu với mục đầu tiên đã được thêm vào.

Bạn có thể làm điều này trong mã của bạn.

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

Trong phiên bản 4.0 mới nhất, có thể sử dụng động như dưới đây

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

Tôi đã kiểm tra IL trên một số câu trả lời. Mã này cung cấp một danh sách trống:

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

Đây là nỗ lực của tôi.

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

Tôi đã nghĩ ra điều này khi tôi viết một cái gì đó tương tự để tạo Danh sách ẩn danh cho loại tùy chỉnh.

Bạn có thể tạo một danh sách năng động.

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

"Động" được khởi tạo bởi giá trị gia tăng đầu tiên.

Thay vì điều này:

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

Bạn có thể làm điều này:

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

Tuy nhiên, bạn sẽ gặp lỗi compXLime nếu bạn cố gắng làm một cái gì đó như thế này trong phạm vi khác, mặc dù nó hoạt động trong thời gian chạy:

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

Vấn đề là chỉ có các thành viên của Object có sẵn trong thời gian chạy, mặc dù intellisense sẽ hiển thị id và tên thuộc tính .

Trong .net 4.0, một giải pháp là sử dụng từ khóa động istead của đối tượng trong đoạn mã trên.

Một giải pháp khác là sử dụng sự phản chiếu để có được các thuộc tính

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

Đây là một phương pháp khác để tạo Danh sách các loại ẩn danh cho phép bạn bắt đầu với một danh sách trống, nhưng vẫn có quyền truy cập vào IntelliSense.

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

Nếu bạn muốn giữ mục đầu tiên, chỉ cần đặt một chữ cái trong chuỗi.

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

Đây là một câu hỏi cũ, nhưng tôi nghĩ tôi đã đưa vào câu trả lời C # 6 của mình. Tôi thường phải thiết lập dữ liệu thử nghiệm dễ dàng nhập mã dưới dạng danh sách các bộ dữ liệu. Với một vài chức năng mở rộng, có thể có định dạng nhỏ gọn, đẹp mắt này mà không cần lặp lại tên trên mỗi mục.

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

Điều này cung cấp một IEnumerable - nếu bạn muốn một danh sách mà bạn có thể thêm vào thì chỉ cần thêm ToList ().

Phép thuật đến từ tiện ích mở rộng tùy chỉnh Thêm phương thức cho bộ dữ liệu, như được mô tả tại 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...

}

Điều duy nhất tôi không thích là các loại được tách ra khỏi tên, nhưng nếu bạn thực sự không muốn tạo một lớp mới thì phương pháp này vẫn sẽ cho phép bạn có dữ liệu có thể đọc được.

Tôi rất ngạc nhiên không ai đề xuất khởi tạo bộ sưu tập. Cách này chỉ có thể thêm các đối tượng khi danh sách được tạo do đó tên tuy nhiên nó có vẻ như là cách tốt nhất để làm điều đó. Không cần phải tạo một mảng sau đó chuyển đổi nó thành một danh sách.

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

Bạn luôn có thể sử dụng objectthay vì dynamicnhưng cố gắng giữ nó theo cách chung chung thực sự sau đó dynamiccó ý nghĩa hơn.

Bạn có thể làm theo cách này:

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

Nó có vẻ hơi "hack" đối với tôi, nhưng nó hoạt động - nếu bạn thực sự cần phải có một danh sách và không thể chỉ sử dụng mảng ẩn danh.

Đối với ví dụ thứ hai của bạn, nơi bạn phải khởi tạo một List<T>ý tưởng mới , một ý tưởng là tạo một danh sách ẩn danh, sau đó xóa nó.

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

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

Hoặc như một phương pháp mở rộng, nên dễ dàng hơn:

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

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

Hoặc thậm chí có thể ngắn hơn,

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

Nếu bạn đang sử dụng C # 7 trở lên, bạn có thể sử dụng các loại tuple thay vì các loại ẩn danh.

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

Xuất phát từ câu trả lời này , tôi đã đưa ra hai phương pháp có thể thực hiện nhiệm vụ:

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

Bạn có thể sử dụng các phương pháp như

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

Câu trả lời này có một ý tưởng tương tự, nhưng tôi đã không thấy nó cho đến khi tôi thực hiện những phương pháp đó.

Hãy thử với điều này:

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