23

给定一个原始值age，我知道如何创建这样的表达式：

//assuming: age is an int or some other primitive type
employee => employee.Age == age

通过做这个：

var entityType = typeof(Employee);
var propertyName = "Age";
int age = 30;
var parameter = Expression.Parameter(entityType, "entity");

var lambda = Expression.Lambda(
        Expression.Equal(
            Expression.Property(parameter, propertyName),
            Expression.Constant(age)
        )                    
    , parameter);

除非在所讨论的属性和常量不是原始类型的情况下，否则效果很好。

如果比较是在对象之间，我将如何构造一个类似的表达式？

使用 EF 我可以写：

Location location = GetCurrentLocation();
employees = DataContext.Employees.Where(e => e.Location == location);

这也有效，但如果我尝试创建相同的表达式：

var entityType = typeof(Employee);
var propertyName = "Location";
var location = GetCurrentLocation();
var parameter = Expression.Parameter(entityType, "entity");

var lambda = Expression.Lambda(
        Expression.Equal(
            Expression.Property(parameter, propertyName),
            Expression.Constant(location)
        )                    
    , parameter);

我收到一条错误消息：

Unable to create a constant value of type 'Location'. Only primitive types or enumeration types are supported in this context.

我的怀疑是Expression.Constant()只需要原始类型，所以我需要使用不同的表达式工厂方法。（也许Expression.Object？-我知道那不存在）

有没有办法创建一个比较对象的表达式？如果它是一个编译的 LINQ 语句，为什么 EF 能够正确解释它，但当它是一个表达式时却不能？

4

3 回答 3

7

除了之前的答案中提到的内容。一个更具体的解决方案是这样的：

public static Expression CreateExpression<T>(string propertyName, object valueToCompare)
{
    // get the type of entity
    var entityType = typeof(T);
    // get the type of the value object
    var valueType = valueToCompare.GetType();
    var entityProperty = entityType.GetProperty(propertyName);
    var propertyType = entityProperty.PropertyType;


    // Expression: "entity"
    var parameter = Expression.Parameter(entityType, "entity");

    // check if the property type is a value type
    // only value types work 
    if (propertyType.IsValueType || propertyType.Equals(typeof(string)))
    {
        // Expression: entity.Property == value
        return Expression.Equal(
            Expression.Property(parameter, entityProperty),
            Expression.Constant(valueToCompare)
        );
    }
    // if not, then use the key
    else
    {
        // get the key property
        var keyProperty = propertyType.GetProperties().FirstOrDefault(p => p.GetCustomAttributes(typeof(KeyAttribute), false).Length > 0);

        // Expression: entity.Property.Key == value.Key
        return Expression.Equal(
            Expression.Property(
                Expression.Property(parameter, entityProperty),
                keyProperty
            ),
            Expression.Constant(
                keyProperty.GetValue(valueToCompare),
                keyProperty.PropertyType
            )
        );
    }
}

要点：

  1. 确保检查空值
  2. 确保propertyType并valueType兼容（它们是相同类型或可转换）
  3. 这里做了几个假设（例如，您确实分配了 a KeyAttribute）
  4. 此代码未经测试，因此无法完全复制/粘贴。

希望有帮助。

于 2013-04-15T22:53:20.380 回答
3

您不能这样做，因为 EF 不知道如何将相等比较Location转换为 SQL 表达式。

但是，如果您知道Location要比较哪些属性，则可以使用匿名类型执行此操作：

var location = GetCurrentLocation();
var locationObj = new { location.LocationName, location.LocationDescription };
employees = DataContext.Employees.Where(e => new { e.Location.LocationName, e.Location.Description } == locationObj);

当然这相当于：

var location = GetCurrentLocation();
employees = DataContext.Employees.Where(e => e.Location.LocationName == location.Name && 
                                             e.Location.Description == location.Description);
于 2013-04-12T18:01:08.733 回答
2

运行下面的代码。我想测试您的假设，即 e => e.Location == location 正在编译成可以使用 Expression.Equal、Expression.Property 和 Expression.Constant 构造的东西。

    class Program {
       static void Main(string[] args) {
          var location = new Location();
          Expression<Func<Employee, bool>> expression = e => e.Location == location;

          var untypedBody = expression.Body;

          //The untyped body is a BinaryExpression
           Debug.Assert(
              typeof(BinaryExpression).IsAssignableFrom(untypedBody.GetType()), 
              "Not Expression.Equal");

           var body = (BinaryExpression)untypedBody;
           var untypedLeft = body.Left;
           var untypedRight = body.Right;

           //The untyped left expression is a MemberExpression
           Debug.Assert(
              typeof(MemberExpression).IsAssignableFrom(untypedLeft.GetType()), 
              "Not Expression.Property");

           ////The untyped right expression is a ConstantExpression
          //Debug.Assert(
          //   typeof(ConstantExpression).IsAssignableFrom(untypedRight.GetType()),                 
          //   "Not Expression.Constant");

          //The untyped right expression is a MemberExpression?
          Debug.Assert(
               typeof(MemberExpression).IsAssignableFrom(untypedRight.GetType())));
    }
}

public class Employee
{
    public Location Location { get; set; }
}

public class Location { }

似乎不是，因为正确的表达式不是常量。要查看这一点，请取消注释已注释掉的代码。

我不明白为什么正确的表达式是 MemberExpression。也许知道 linq 表达式编译器的人可以比我更了解这一点。

编辑：这可能与 lambdas 中的闭包有关——在幕后创建了一个包含封闭变量的类。该位置可能是该类的成员。我不确定这一点，但这是我怀疑的。

这篇文章可能会进一步说明这种情况。

于 2013-04-12T19:21:33.800 回答