익명 클래스의 일반적인 목록

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 에서 런타임 에 작동 하여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);
        }
    }

나는 몇 가지 답변에서 IL을 확인했습니다. 이 코드는 빈 목록을 효율적으로 제공합니다.

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

문제는 intellisense에 속성 id 및 name 이 표시되지만 런타임에 Object 멤버 만 사용할 수 있다는 것 입니다.

.net 4.0에서 해결책은 위의 코드에서 객체 대신 키워드 dynamic istead 를 사용하는 것 입니다.

또 다른 해결책은 리플렉션을 사용하여 속성을 얻는 것입니다.

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

이것은 오래된 질문이지만 C # 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에 설명 된대로 튜플에 대한 사용자 정의 확장 Add 메소드에서 비롯됩니다 .

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

그것은 나에게 약간의 "해킹"것처럼 보이지만 작동합니다. 실제로 목록이 필요하고 익명 배열을 사용할 수없는 경우 작동합니다.

두 번째 예에서는 new를 초기화해야하는 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);
}