使用表达式树通过单个属性nets InvalidOperationException来比较对象
本文关键字：InvalidOperationException nets 比较 对象 属性 单个 表达式 | 更新日期: 2023-09-27 18:27:57
我尝试使用表达式树，因为根据描述，这似乎是最正确的（性能、可配置）方法。
我希望能够编写一个语句，从现有的Items集合中获取与incomingItem的propertyNameToCompareOn值匹配的第一个项。
我有一个具有以下签名和模拟代码体的方法。。。
DetectDifferences<T>(List<T> incomingItems, List<T> existingItems)
{
var propertyNameToCompareOn = GetThisValueFromAConfigFile(T.FullName());
//does this belong outside of the loop?
var leftParam = Expression.Parameter(typeof(T), "left");
var leftProperty = Expression.Property(leftParam, identField);
var rightParam = Expression.Parameter(typeof(T), "right");
var rightProperty = Expression.Property(rightParam, identField);
//this throws the error
var condition = Expression.Lambda<Func<T, bool>>(Expression.Equal(leftProperty, rightProperty));
foreach (var incomingItem in incomingItems) //could be a parallel or something else.
{
// also, where am I supposed to provide incomingItem to this statement?
var existingItem = existingItems.FirstOrDefault(expression/condition/idk);
// the statement for Foo would be something like
var existingFoos = exsistingItems.FirstOrDefault(f => f.Bar.Equals(incomingItem.Bar);
//if item does not exist, consider it new for persistence
//if item does exist, compare a configured list of the remaining properties between the
// objects. If they are all the same, report no changes. If any
// important property is different, capture the differences for
// persistence. (This is where precalculating hashes seems like the
// wrong approach due to expense.)
}
}
在上面标记的行中，我得到一个"为lambda声明提供的参数数量不正确"InvalidOperationException。在这一点上，我只是从网上拼凑垃圾，我真的不知道这想要什么。VS可以用一堆重载来填满我的屏幕，从MSDN/SO上的文章中没有一个例子是有意义的。
PS-如果可以的话，我真的不想要一个IComparer或类似的实现。我可以通过反思来做到这一点。我确实需要使其尽可能快，但允许对多种类型调用它，因此可以选择表达式树。
使用表达式树时，首先要在实际代码中了解您想要做什么，这一点很重要
我总是首先（在静态代码中）用真正的C#lambda语法写出结果表达式的样子。
根据您的描述，您的既定目标是，您应该能够（动态）查找T类型的一些属性，以便进行某种快速比较。如果T和TProperty在编译时都是已知的，你会怎么写呢？我怀疑它看起来像这样：
Func<Foo, Foo, bool> comparer = (Foo first, Foo second) =>
first.FooProperty == second.FooProperty;
我们马上就能看出你的Expression是错的。你不需要一个输入t，你需要两个！
同样显而易见的是，你为什么也会得到InvalidOperationException。您从未向lambda表达式提供任何参数，只提供了正文。上面，"first"answers"second"是提供给lambda的参数。您还需要将它们提供给Expression.Lambda()呼叫。
var condition = Expression.Lambda<Func<T,T, bool>>(
Expression.Equal(leftProperty, rightProperty),
leftParam,
rightParam);
这只是将Expression.Lambda(Expression, ParameterExpression[])过载用于Expression.Lambda。每个ParameterExpression都是主体中使用的参数。就是这样。如果你想真正调用它，不要忘记将你的表达式.Compile()转换为委托。
当然，这并不意味着你的技术一定会很快。如果你用一个简单的O（n^2）方法来比较两个列表，那也没关系。
这里有一个生成属性访问表达式的方法；
public static Expression<Func<T, object>> MakeLambda<T>(string propertyName)
{
var param = Expression.Parameter(typeof(T));
var propertyInfo = typeof(T).GetProperty(propertyName);
var expr = Expression.MakeMemberAccess(param, propertyInfo);
var lambda = Expression.Lambda<Func<T, object>>(expr, param);
return lambda;
}
你可以这样使用；
var accessor = MakeLambda<Foo>("Name").Compile();
accessor(myFooInstance); // returns name
制作丢失的线路
var existingItem = existingItems.FirstOrDefault(e => accessor(e) == accessor(incomingItem));
请注意，==只适用于像int这样的值类型；小心比较对象。
以下是lambda方法更快的证明；
static void Main(string[] args)
{
var l1 = new List<Foo> { };
for(var i = 0; i < 10000000; i++)
{
l1.Add(new Foo { Name = "x" + i.ToString() });
}
var propertyName = nameof(Foo.Name);
var lambda = MakeLambda<Foo>(propertyName);
var f = lambda.Compile();
var propertyInfo = typeof(Foo).GetProperty(nameof(Foo.Name));
var sw1 = Stopwatch.StartNew();
foreach (var item in l1)
{
var value = f(item);
}
sw1.Stop();
var sw2 = Stopwatch.StartNew();
foreach (var item in l1)
{
var value = propertyInfo.GetValue(item);
}
sw2.Stop();
Console.WriteLine($"{sw1.ElapsedMilliseconds} vs {sw2.ElapsedMilliseconds}");
}
然而，正如有人指出的那样，OP中的双环是O（N^2），如果效率是驱动因素，那么这可能是下一个考虑因素。