Lambda表达式转换
使用实体框架，我们有许多实体，我们希望从调用代码的其余部分隐藏它们，以消除对数据库的直接依赖。我们是通过使用 DTO 来实现的，DTO 在大多数情况下与实体相同。我们还有一个抽象的通用提供者和持久化模式，用于处理 dtos 和实体之间的转换，以及所有数据库交互。基本抽象提供者的一般加载方法使用以下签名：
protected virtual IEnumerable<TDto> Load(Expression<Func<TEntity, bool>> filter)
所以任何扩展抽象的提供者都可以是这样的：
public IEnumerable<FooDto> GetSomeFilteredData(IEnumerable<string> identifiers)
{
return base.Load(entity => identifiers.Contains(entity.SomeProperty));
}
因此，从调用代码中隐藏实体。
这种模式对我们很有效，但我一直在研究如何操作表达式，以便我可以将以下内容放入基本提供程序中：
public virtual IEnumerable<TDto> Load(Expression<Func<TDto, bool>> filter)
然后，基本提供程序会将 转换Expression<Func<TDto, bool>>为等效的实体表达式，并像以前一样加载数据，因此无需编写繁琐的方法，并为我们提供更多的调用代码控制权。
最终结果如下 ExpressionConverter
public class ExpressionConverter<Dto, Entity>
where Dto : class, new() where Entity : class, new()
{
private MappedConverter<Dto, Entity> converter;
public ExpressionConverter(MappedConverter<Dto, Entity> converter)
{
this.converter = converter;
}
public Expression<Func<Entity, bool>> ConvertExpr(Expression<Func<Dto, bool>> expr)
{
ParameterExpression entityParam = Expression.Parameter(typeof(Entity), "e");
Expression entityExpression = this.ConvertExpression(expr.Body, entityParam);
var result = Expression.Lambda<Func<Entity, bool>>(entityExpression, entityParam);
return result;
}
private Expression ConvertExpression(Expression expression, ParameterExpression entityParam)
{
if (expression is BinaryExpression binary)
{
return this.ConvertBinaryExpression(binary, entityParam);
}
if (expression is MemberExpression member)
{
return this.ConvertMemberExpression(member, entityParam);
}
if (expression is MethodCallExpression method)
{
return this.ConvertMethodCallExpression(method, entityParam);
}
return expression;
}
private Expression ConvertBinaryExpression(BinaryExpression binary, ParameterExpression param)
{
Expression left = this.ConvertExpression(binary.Left, param);
Expression right = this.ConvertExpression(binary.Right, param);
ExpressionType nodeType = binary.NodeType;
return this.CombineExpressions(left, right, nodeType);
}
private Expression ConvertMemberExpression(Expression expression, ParameterExpression entityParam)
{
if (this.IsParseableMemberExpression(expression))
{
MemberExpression memberExpr = expression as MemberExpression;
var value = Expression.Lambda(memberExpr).Compile().DynamicInvoke();
return Expression.Constant(value);
}
else if (this.IsConvertibleMember(expression))
{
MemberInfo dtoMember = (expression as MemberExpression).Member;
Mapping<Dto, Entity> mapping = this.converter.GetMappingFromMemberName<Dto>(dtoMember.Name);
MemberExpression entityMemberExpr = Expression.MakeMemberAccess(entityParam, mapping.EntityProperty);
return entityMemberExpr;
}
return expression;
}
private Expression ConvertMethodCallExpression(MethodCallExpression expression, ParameterExpression entityParam)
{
Expression objectExpr = this.ConvertMemberExpression(expression.Object, entityParam);
IEnumerable<Expression> argumentExpressions = expression.Arguments.Select(x => this.ConvertMemberExpression(x, entityParam));
MethodInfo method = expression.Method;
Expression result = Expression.Call(objectExpr, method, argumentExpressions);
return result;
}
private bool IsConvertibleMember(Expression expression)
{
return expression.NodeType == ExpressionType.MemberAccess;
}
private bool IsParseableMemberExpression(Expression expression)
{
if (expression is MemberExpression memberExpression)
{
return Regex.IsMatch(expression.ToString(), @"value[(].*[)]")
|| this.IsDateTimeExpression(memberExpression);
}
return false;
}
private bool IsDateTimeExpression(MemberExpression expression)
{
return Regex.IsMatch(expression.ToString(), @"DateTime\.(Today|Now)");
}
private Expression CombineExpressions(Expression left, Expression right, ExpressionType type)
{
switch (type)
{
case ExpressionType.And: return Expression.And(left, right);
case ExpressionType.AndAlso: return Expression.AndAlso(left, right);
case ExpressionType.Equal: return Expression.Equal(left, right);
case ExpressionType.ExclusiveOr: return Expression.ExclusiveOr(left, right);
case ExpressionType.GreaterThan: return Expression.GreaterThan(left, right);
case ExpressionType.GreaterThanOrEqual: return Expression.GreaterThanOrEqual(left, right);
case ExpressionType.LessThan: return Expression.LessThan(left, right);
case ExpressionType.LessThanOrEqual: return Expression.LessThanOrEqual(left, right);
case ExpressionType.NotEqual: return Expression.NotEqual(left, right);
case ExpressionType.Or: return Expression.Or(left, right);
case ExpressionType.OrElse: return Expression.OrElse(left, right);
default:
throw new Exception($"Unsupported expression type: {type.ToString()}");
}
}
}
MappedConverter<Dto, Entity>以下是哪里：
public class MappedConverter<Dto, Entity> where Dto : class, new() where Entity : class, new()
{
public List<Mapping<Dto, Entity>> Mappings { get; set; }
public MappedConverter(params Mapping<Dto, Entity>[] maps)
{
this.Mappings = maps.ToList();
}
public Mapping<Dto, Entity> GetMappingFromMemberName<T>(string name)
{
if (typeof(T) == typeof(Dto))
{
return this.Mappings.SingleOrDefault(x => x.DtoProperty.Name == name);
}
else if (typeof(T) == typeof(Entity))
{
return this.Mappings.SingleOrDefault(x => x.EntityProperty.Name == name);
}
throw new Exception($"Cannot get mapping for {typeof(T).Name} from MappedConverter<{typeof(Dto).Name}, {typeof(Entity).Name}>");
}
}
并且Mapping<Dto, Entity>是以下内容：
public class Mapping<Dto, Entity>
{
public PropertyInfo DtoProperty { get; }
public PropertyInfo EntityProperty { get; }
}
笔记：
转换只需要处理表单的表达式 Expression<Func<Dto, bool>>
我特别在寻找改进方法IsParseableMemberExpression和IsDateTimeExpression方法
IsParseableMemberExpression用于Regex查看表达式是否表示完整表达式中的变量。例如variable在x => x.Value == variable
5
您可以使用ExpressionVisitor类给自己更多的灵活性，而不必自己处理所有条件。
public class ExpressionConverter<TFrom, TTo> : ExpressionVisitor
where TFrom : class, new()
where TTo : class, new()
{
private readonly MappedConverter<TFrom, TTo> _converter;
private ParameterExpression _fromParameter;
private ParameterExpression _toParameter;
public ExpressionConverter(MappedConverter<TFrom, TTo> converter)
{
_converter = converter;
}
public override Expression Visit(Expression node)
{
if (_fromParameter == null)
{
if (node.NodeType != ExpressionType.Lambda)
{
throw new ArgumentException("Expression must be a lambda");
}
var lambda = (LambdaExpression)node;
if (lambda.ReturnType != typeof(bool) || lambda.Parameters.Count != 1 ||
lambda.Parameters[0].Type != typeof(TFrom))
{
throw new ArgumentException("Expression must be a Func<TFrom, bool>");
}
_fromParameter = lambda.Parameters[0];
_toParameter = Expression.Parameter(typeof(TTo), _fromParameter.Name);
}
return base.Visit(node);
}
我们将让 ExpressionConverter 从 ExpressionVisitor 继承，并且第一次调用 Visit 确保它是一个 Func lambda（在 ExpressionTree 中通过递归调用了很多）。如果是这样，我们保存我们要转换的参数表达式，并为我们要转换的参数创建一个新的表达式。
然后覆盖 VisitParameter 并换出参数
protected override Expression VisitParameter(ParameterExpression node)
{
if (_fromParameter == node)
{
return _toParameter;
}
return base.VisitParameter(node);
}
然后我们还需要覆盖 VisitMembers 来交换成员分配
protected override Expression VisitMember(MemberExpression node)
{
if (node.Expression == _fromParameter)
{
var member = _converter.GetMappingFromMemberName<TFrom>(node.Member.Name);
return Expression.Property(_toParameter, member);
}
return base.VisitMember(node);
}
我确实必须更改 GetMappingFromMemberName 以返回正确的 PropertyInfo 而不是映射以使其更容易工作。
public PropertyInfo GetMappingFromMemberName<T>(string name)
{
if (typeof(T) == typeof(Dto))
{
return this.Mappings.SingleOrDefault(x => x.DtoProperty.Name == name).EntityProperty;
}
else if (typeof(T) == typeof(Entity))
{
return this.Mappings.SingleOrDefault(x => x.EntityProperty.Name == name).DtoProperty;
}
throw new Exception($"Cannot get mapping for {typeof(T).Name} from MappedConverter<{typeof(Dto).Name}, {typeof(Entity).Name}>");
}
我们需要做的最后一件事是创建一个新的 Expression<Func<TFrom, bool>>
protected override Expression VisitLambda<T>(Expression<T> node)
{
if (typeof(T) == typeof(Func<TFrom, bool>))
{
return Expression.Lambda<Func<TTo, bool>>(Visit(node.Body), new[] { _toParameter });
}
return base.VisitLambda(node);
}
你可以这样称呼它
Expression<Func<Model, bool>> lambda = x => x.LastName == x.FirstName && x.FirstName == "John";
var newLambda = expressionConverter.Visit(lambda);
如果您不喜欢 Visit 调用，您可以随时将其设为另一个类中的私有类，以赋予它不同的方法签名。但是现在您不必创建常量或运算符。只需更新正在使用的参数和属性。我没有做 CallMethod 但如果你需要，你可以override Expression VisitMethodCall(MethodCallExpression node)使用与上面相同的技术。
-
不错，没想到用ExpressionVisitor。我遇到的唯一问题是使用转换器的相同实例转换多个表达式，因为
_fromParameter和_toParameter字段引用了先前表达式中的 Func 变量，因此InvalidOperationException在换出参数表达式时会得到。这可以通过将Visit方法包装在ConvertExpression像上面这样的帮助器中并在调用时重置字段来解决 - 克里斯汀 2019-06-06 13:21 -
1这确实意味着它不是线程安全的，而是通过将访问逻辑提取到一个单独的子类中，您每次转换表达式时都会实例化该子类，您会得到它，并且代码仍然保持良好和干净 – 克里斯汀 2019-06-06 13:23
-
正确，您每次需要使用它时都需要更新一个类，因为它具有需要保留的属性。 —— 查尔斯·恩里斯 2019-06-06 13:26
-
@JChristen 刚刚意识到你一年多前问了这个问题，当时我得到了答案的徽章。 —— 查尔斯·恩里斯 2019-06-06 22:07
-
@CharlesNRice 在将
Mapping<From, To>类传递给MappedConverter构造函数时如何实例化它。 —— 坦维尔·阿杰尔 19 年 12 月 28 日 16:22
3
我可以先说 - 这很好 - 无论是帖子还是提供的答案。
我的工具遵循类似的模式，通过我的控制器呈现 DTO 并抽象出我的数据访问。
我一直在寻找这样的东西一段时间了，这对我有帮助。
使用 @CharlesNRice 提供的 ExpressionVisitor - 我对 MappedConverter 的实现添加了另一个小改动。
使用 Automapper 似乎
public class Mapping<Dto, Entity>
{
public PropertyInfo DtoProperty { get; }
public PropertyInfo EntityProperty { get; }
}
可以通过使用 Automapper 并引用已注册的映射配置来替换。
我将 Mapped Converter 更改为 IPropertyMappingProvider
public interface IPropertyMappingProvider
{
IPropertyMapping GetPropertyMapping<TSource, TDestination>(string sourcePropertyName);
}
使用 IPropertyMapping 与您实现的 Mapping 完全相同。
public interface IPropertyMapping
{
PropertyInfo SourceProperty { get; }
PropertyInfo DestinationProperty { get; }
}
PropertyMappingProvider 的实现只是注入了向应用程序注册的 IMapper 实例。然后我们可以使用 IMapper 来获取属性映射配置。
public class PropertyMappingProvider : IPropertyMappingProvider
{
private readonly IMapper _mapper;
public PropertyMappingProvider(IMapper mapper)
{
_mapper = mapper;
}
/// <summary>
/// Returns a <see cref="IPropertyMapping"/> mapped properties from the IMapper configuration based on the source property name
/// </summary>
/// <typeparam name="TSource">Source mapping class</typeparam>
/// <typeparam name="TDestination">Destination mapping class</typeparam>
/// <param name="sourcePropertyName">The property name on the source class</param>
/// <returns><see cref="IPropertyMapping"/> Contains the <see cref="PropertyInfo"/> classes for <typeparam name="TSource"></typeparam> property and <typeparam name="TDestination"></typeparam></returns>
public virtual IPropertyMapping GetPropertyMapping<TSource, TDestination>(string sourcePropertyName)
{
var configurationProvider = _mapper.ConfigurationProvider;
var mapping = configurationProvider.FindTypeMapFor<TSource, TDestination>();
var propertyMap = mapping.PropertyMaps.FirstOrDefault(pm => pm.SourceMember.Name == sourcePropertyName);
if(propertyMap == null)
throw new ArgumentException($"No mappings found for {sourcePropertyName}");
if(propertyMap.SourceMember.MemberType != MemberTypes.Property)
throw new ArgumentException($"{sourcePropertyName} is not a property {nameof(TSource)}");
if(propertyMap.DestinationMember.MemberType != MemberTypes.Property)
throw new ArgumentException($"{propertyMap.DestinationMember.Name} is not a property of {nameof(TDestination)}");
var sourcePropertyInfo = (PropertyInfo) propertyMap.SourceMember;
var destinationPropertyInfo = (PropertyInfo) propertyMap.DestinationMember;
return new PropertyMapping(sourcePropertyInfo, destinationPropertyInfo);
}
}
我们可以访问映射属性上的 PropertyInfo 对象。
使用它就像您在 ExpressionVisitor 实现中所做的一样：
public sealed class ExpressionConverter<TFrom, TTo> : ExpressionVisitor, IExpressionConverter<TFrom, TTo>
{
private readonly IPropertyMappingProvider _propertyMappingProvider;
private ParameterExpression _fromParameter;
private ParameterExpression _toParameter;
public ExpressionConverter(IPropertyMappingProvider propertyMappingProvider)
{
_propertyMappingProvider = propertyMappingProvider;
}
public Expression<Func<TTo, bool>> Convert(Expression<Func<TFrom, bool>> expression)
{
var expr = Visit(expression);
return expr.Convert<TTo>();
}
...
protected override Expression VisitMember(MemberExpression node)
{
if (node.Expression != _fromParameter) return base.VisitMember(node);
var member = _propertyMappingProvider.GetPropertyMapping<TFrom, TTo>(node.Member.Name);
return Expression.Property(_toParameter, member.DestinationProperty);
}
-
你的
PropertyMapping课在哪里？ —— 坦维尔·阿杰尔 19 年 12 月 28 日 16:20 -
您的
IExpressionConverter<TFrom, TTo>接口及其实现在哪里？ —— 坦维尔·阿杰尔 19 年 12 月 28 日 16:57 -
@TanvirArjel - PropertyMapping 只是原始 post Mapping 类的接口提取。IExpressionConverter 在 ExpressionConverter 具体类中实现。该接口只是公共 Convert 方法。 —— JDBennett 19 年 12 月 28 日 22:27
浙公网安备 33010602011771号
TEntity会损害您在其他方面相当广泛的层分离。但是，仅使用的问题TDto是不能保证其相关项TEntity具有与该表达式可以使用的类似属性。我并不是说它在技术上无法完成，但是所需的努力值得付出吗？希望直接控制您强行抽象的实体属性是违反直觉的。您本质上要求过滤器的类型安全为零，这似乎可能成为未来问题的根源。 —— 扁平化 2018 年 5 月 2 日 11:26