题
在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" });
作为替代方案,您可以执行以下操作来创建空列表(但是,我更喜欢第一个示例,因为您也可以将它用于填充的元组集合):
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"} );
使用repeat方法还可以执行以下操作:
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" });
我在几个答案上检查了IL。此代码有效地提供了一个空List:
using System.Linq;
…
var list = new[]{new{Id = default(int), Name = default(string)}}.Skip(1).ToList();
在最新的4.0版本中,可以使用如下的动态
var list = new List<dynamic>();
list.Add(new {
Name = "Damith"
});
foreach(var item in list){
Console.WriteLine(item.Name);
}
}
这是我的尝试。
List<object> list = new List<object> { new { Id = 10, Name = "Testing1" }, new {Id =2, Name ="Testing2" }};
当我为自定义类型制作匿名列表时,我想出了类似的东西。
这是另一种创建匿名类型列表的方法,它允许您从空列表开始,但仍然可以访问IntelliSense。
var items = "".Select( t => new {Id = 1, Name = "foo"} ).ToList();
如果你想保留第一项,只需在字符串中加一个字母。
var items = "1".Select( t => new {Id = 1, Name = "foo"} ).ToList();
而不是:
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将显示属性 id 和 name 。
在.net 4.0中,解决方案是在上面的代码中使用关键字动态而不是对象。
另一种解决方案是使用反射来获取属性
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();
}
}
}
var list = new[]{
new{
FirstField = default(string),
SecondField = default(int),
ThirdField = default(double)
}
}.ToList();
list.RemoveAt(0);
您可以创建动态列表。
List<dynamic> anons=new List<dynamic>();
foreach (Model model in models)
{
var anon= new
{
Id = model.Id,
Name=model.Name
};
anons.Add(anon);
}
<!> QUOT; <!>动态QUOT;由第一个增加值初始化。
你可以这样做:
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" });
似乎有点<!>“hacky <!>”;对我来说,但它确实有效 - 如果你真的需要一个列表而不能只使用匿名数组。
这是一个老问题,但我认为我已经加入了我的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所述。
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...
}
我唯一不喜欢的是类型与名称分开,但如果你真的不想创建一个新类,那么这种方法仍然会让你拥有可读数据。
对于你的第二个例子,你必须初始化一个新的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();
从这个答案中得出,我提出了两种可以完成任务的方法:
/// <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);
}