我怎么将匿名类型作为参数传递给其他函数？考虑以下示例：
var query = from employee in employees select new { Name = employee.Name, Id = employee.Id };
LogEmployees(query);
query 变量在这里没有强类型。我应该如何定义我的 LogEmployees 函数来接受它？
public void LogEmployees (? list)
{
foreach (? item in list)
{
}
}
换句话说，我应该使用什么东西代替?标记。
我认为你应该为这个匿名类型创建一个类。在我看来，这是最明智的做法。但如果你真的不想这样做，你可以使用动态类型：
public void LogEmployees (IEnumerable<dynamic> list)
{
foreach (dynamic item in list)
{
string name = item.Name;
int id = item.Id;
}
}
请注意，这并不是强类型的。因此，例如当“Name”更改为“EmployeeName”时，只有在运行时才会知道存在问题。
dynamic。这对我来说真的很方便。谢谢 :) - Saeed Neamatipublic void LogEmployees<T>(List<T> list) // Or IEnumerable<T> list
{
foreach (T item in list)
{
}
}
...但是你不能对每个项目都做很多事情。你可以调用ToString，但你将无法直接使用（比如）Name和Id。
IList即可。 - Jon Skeet很遗憾，你尝试的操作是不可能的。在底层，查询变量的类型被定义为一个匿名类型的 IEnumerable。由于无法在用户代码中表示匿名类型名称，因此无法将其作为函数的输入参数。
最好的方法是创建一个类型，并将其用作查询的返回值，然后将其传递到函数中。例如:
struct Data {
public string ColumnName;
}
var query = (from name in some.Table
select new Data { ColumnName = name });
MethodOp(query);
...
MethodOp(IEnumerable<Data> enumerable);
但在这种情况下，您仅选择了一个字段，因此直接选择该字段可能更容易。这将导致查询被类型化为该字段类型的 IEnumerable。在这种情况下，列名称。
var query = (from name in some.Table select name); // IEnumerable<string>
Equals 的行为会发生变化。也就是说，你必须实现它。（我知道这个差异，但在重构期间仍然忘记了它。） - LosManos如果参数类型不是object，则无法将匿名类型传递给非泛型函数。
public void LogEmployees (object obj)
{
var list = obj as IEnumerable();
if (list == null)
return;
foreach (var item in list)
{
}
}
匿名类型是用于方法内短期使用的。
来自 MSDN - 匿名类型：
您无法将字段、属性、事件或方法的返回类型声明为匿名类型。同样，您也不能将方法、属性、构造函数或索引器的形式参数声明为匿名类型。要将匿名类型或包含匿名类型的集合作为参数传递给方法，可以将参数声明为 object 类型。但是，这样做会破坏强类型的目的。
(重点在我这里)
更新
您可以使用泛型来实现您想要的功能：
public void LogEmployees<T>(IEnumerable<T> list)
{
foreach (T item in list)
{
}
}
object 或 dynamic ;p - Marc Gravellobject与使方法成为泛型不同，详见我的回答。 - Jon Skeet"dynamic"这个词也可以用于这个目的。
var anonymousType = new { Id = 1, Name = "A" };
var anonymousTypes = new[] { new { Id = 1, Name = "A" }, new { Id = 2, Name = "B" };
private void DisplayAnonymousType(dynamic anonymousType)
{
}
private void DisplayAnonymousTypes(IEnumerable<dynamic> anonymousTypes)
{
foreach (var info in anonymousTypes)
{
}
}
public void LogEmployees<T>(IEnumerable<T> list)
{
foreach (T item in list)
{
var typedItem = Cast(item, new { Name = "", Id = 0 });
// now you can use typedItem.Name, etc.
}
}
static T Cast<T>(object obj, T type)
{
return (T)obj;
}
MapEntToObj<T>(IQueryable<T> query) {...}
MapEntToObj(query)时推断出T。不太确定您想在方法内部执行什么操作，所以我无法确定这是否有用...问题是在MapEntToObj内部仍然无法命名T - 您只能：
T调用其他通用方法T使用反射进行操作但除此之外，匿名类型很难操作-最重要的是它们是不可变的；-p
另一个技巧（在提取数据时）是同时传递选择器-即类似于：
Foo<TSource, TValue>(IEnumerable<TSource> source,
Func<TSource,string> name) {
foreach(TSource item in source) Console.WriteLine(name(item));
}
...
Foo(query, x=>x.Title);
dynamic someEmp = new ThreadSafeDynamicObject(someCustomEmployee);
一旦您将someEmp转换为正确的动态对象，您的LogEmployee函数可以例如将该对象序列化并记录它或以其他方式处理它（请注意，如果仅需要序列化匿名类实例，则不必通过将其转换为动态对象来进行操作）。
示例：
dynamic threadSafeToyota = new ThreadSafeDynamicObject(new {
Make = "Toyota",
Model = "CR-H",
Propulsion = new {
IsHybrid = true,
UsesPetrol = true,
ElectricMotor = true
}
});
这段代码接受一个动态对象，并使用私有方法'ToDictionary'将提供的匿名类实例的对象图转换为字典，作为设置动态对象属性的另一种替代方式。
请注意，我在这里添加了一些代码以提供线程安全性，用于设置和获取属性。
public class ThreadSafeDynamicObject : DynamicObject, IEnumerable<KeyValuePair<string, object>>
{
public ThreadSafeDynamicObject()
{
}
public ThreadSafeDynamicObject(dynamic members)
{
var membersDict = ToDictionary(members);
InitMembers(membersDict);
}
private IDictionary<string, object> ToDictionary(object data)
{
var attr = BindingFlags.Public | BindingFlags.Instance;
var dict = new Dictionary<string, object>();
foreach (var property in data.GetType().GetProperties(attr))
{
if (property.CanRead)
{
dict.Add(property.Name, property.GetValue(data, null));
}
}
return dict;
}
private void InitMembers(IDictionary<string, object> membersDict)
{
foreach (KeyValuePair<string, object> member in membersDict){
_members.AddOrUpdate(member.Key, member.Value, (key, oldValue) => member.Value);
}
}
private readonly ConcurrentDictionary<string, object> _members = new();
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
return _members.TryGetValue(binder.Name, out result);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
_members.AddOrUpdate(binder.Name, value, (key, oldvalue) => value);
return true;
}
public override IEnumerable<string> GetDynamicMemberNames()
{
return _members.Keys.ToList().AsReadOnly();
}
public override string ToString()
{
return JsonSerializer.Serialize(_members);
}
public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
{
return _members.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return _members.GetEnumerator();
}
}
当在Linqpad 7中运行代码时，我得到了以下输出（我正在使用静态System.Console并在此处使用System.Dynamic）：
WriteLine(threadSafe.ToString());
WriteLine(threadSafe.Make);
WriteLine(threadSafe.Model);
WriteLine(threadSafe.Propulsion.IsHybrid);
WriteLine(threadSafe.Propulsion.UsesPetrol);
WriteLine(threadSafe.Propulsion.ElectricMotor);
这样做有几个优点。它支持嵌套级别，正如您在输出中所看到的，并且非常灵活。这里的关键是使用'ToDictionary'方法。此外，我们不必在.NET框架之外使用其他库，因此功能已内置。我没有检查此代码的所有变体，但至少支持匿名类型对象图的典型场景。
关键在于首先将匿名类型转换为字典，然后使用派生的DynamicObject的成员（'fields'或'props'）填充内部并发字典。
有几种解决方法：
您可以进行装箱。例如，编写一个接受对象的方法，使用反射提取属性并记录属性及其值，例如：
public void LogEmployees(object someCustomEmployee) { // .. }
您可以像我的示例一样将匿名对象转换为动态对象
除了装箱或转换为动态对象之外，您还可以通过序列化转换后的对象（包括装箱的对象或动态变量）来避免反射。
不要传递匿名类型，而是传递一个动态类型的List：
var dynamicResult = anonymousQueryResult.ToList<dynamic>();DoSomething(List<dynamic> _dynamicResult)DoSomething(dynamicResult);感谢Petar Ivanov！
如果您知道您的结果实现了某个接口，您可以使用该接口作为数据类型：
public void LogEmployees<T>(IEnumerable<T> list)
{
foreach (T item in list)
{
}
}