Question

我有一个场景，我从客户端网格的配置动态创建WHERE子句。客户端将一些json发送到服务器，然后我将其解析并随后转换为表达式，以便将其作为where子句传递到存储库中。

目前我正在努力为复杂的属性类型创建表达式，例如：

public partial class Resource
{
  public string DisplayName { get; set; }
  public virtual ResourceType ResourceType { get; set; }
}

下面的代码转换为表达式适用于简单类型，如Displayname属性。表达式将类似于：

x => x.DisplayName == "ValueEnteredByUserInTheUI"

但是，当在ResourceType属性的网格中输入值时，表达式最终将类似于：

x => x.ResourceType == "ValueEnteredByUserInTheUI"

我错过了转换成这一步的一步：

 x => x.ResourceType.Name == "ValueEnteredByuserInTheUI"

任何人都可以指出我在正确的方向吗？

public Expression<Func<T, bool>> GetExpression<TEntity>(string field, string operation, object value, string ignoreCase)
{
 Expression<Func<T, bool>> whereClause = default(Expression<Func<T, bool>>);

// Define lambda
ParameterExpression param = Expression.Parameter(typeof(T), "x");    
 MemberExpression member = Expression.Property(param, field);

 // Get property type
  Type propertyType = member.Type;

  // Get converter for type
   TypeConverter converter = TypeDescriptor.GetConverter(propertyType);

   // Convert property to type
   var result = converter.ConvertFrom(value.ToString());

   // Convert value to constant value
   ConstantExpression constant = Expression.Constant(result);

    Expression comparingExpression = default(BinaryExpression);
    switch (operation)
    {
      case "like":
           comparingExpression = Expression.Equal(member, Expression.Convert(constant, member.Type));
           break;           
       default:
           break;
   }

  var lambda = Expression.Lambda<Func<T, bool>>(comparingExpression, param);
   whereClause = whereClause == default(Expression<Func<T, bool>>) ? lambda : NewPredicateBuilder.And(whereClause, lambda);
        return whereClause;
  }

Answer 1

显然没有很多人热衷于表达。无论如何，我已经为这个问题创建了一个解决方法。我在方法中添加了另一个参数，指示根对象的复杂属性的属性名称。

$ ./bin/permute4int

 total permutations : 24

 permutations:

 25 15  8 20
 25 15 20  8
 25  8 15 20
 25  8 20 15
 25 20  8 15
 25 20 15  8
 15 25  8 20
 15 25 20  8
 15  8 25 20
 15  8 20 25
 15 20  8 25
 15 20 25  8
  8 15 25 20
  8 15 20 25
  8 25 15 20
  8 25 20 15
  8 20 25 15
  8 20 15 25
 20 15  8 25
 20 15 25  8
 20  8 15 25
 20  8 25 15
 20 25  8 15
 20 25 15  8

它不具有很高的可扩展性，也不是通用的，但现在这样做。

复杂类型属性

1 个答案: