转换复杂表达式<Func<TDTO> ,bool&gt; 到表达式<Func<TEntity> ,布尔&gt;

Question

I have DTOmodel in my Framework. BLL and View do not see EntiyModel at all. I want to transfer and convert Complex Expression between layers.

this is a method in the BLL like this...

//// BLL(Service)
Public PersonDTO getAll(Expression<Func<PersonDTO, bool>> whereCondition)
{

   return _repository.getAll(whereCondition);

}


// DLL(Repository)

Public PersonDTO getAll(Expression<Func<PersonDTO, bool>> whereCondition)
{

   Expression<Func<Person, bool>> NewCondition = ?/ How Convert DTOwhereCondition ???

   return DataContext.Persons(NewCondition);

}

///// I want to create complex expression on PersonDTO like this:

var persons = serive.getPersons(i => i.PersonDetailsDTO.Count == 3);

///// My Classes

     public class Person
       {
        public Int32 Id { get; set; }
        public String FirstName { get; set; }
        public String LastName { get; set; }
        public List<PersonDetail> PersonDetails { get; set; }
       }


    public class PersonDTO
      {
        public Int32 Id { get; set; }
        public String FirstName { get; set; }
        public String LastName { get; set; }
        public List<PersonDetailDTO> PersonDetailsDTO { get; set; }
      }

Answer 1

This is quite the most basic solution. If you need more features, maybe you can work your way up from there. So far it allows to optionally provide a delegate to resolve mapped property names, but the property types have to be the same.

Usage:

var mappedExpression =
    ExpressionMapper<Person>.MapFrom(originalDtoExpression, null);

// or:

var mappedExpression =
    ExpressionMapper<Person>.MapFrom(originalDtoExpression,
            entityPropertyName => someMapper.ResolveDtoPropertyName(entityPropertyName));

Implementation:

public class ExpressionMapper<TTarget> : ExpressionVisitor
{
    protected ExpressionMapper(Type sourceType, Func<string, string> resolveTargetMemberNameFunc)
    {
        this.SourceType = sourceType;
        this.ResolveTargetMemberNameFunc = resolveTargetMemberNameFunc ?? (cur => cur);
    }

    public Func<string, string> ResolveTargetMemberNameFunc { get; private set; }

    public Type SourceType { get; private set; }

    public static Expression MapFrom<TSource>(Expression sourceExpression, Func<string, string> resolveTargetMemberNameFunc)
    {
        return new ExpressionMapper<TTarget>(typeof(TSource), resolveTargetMemberNameFunc).Visit(sourceExpression);
    }

    public static Expression<Func<TTarget, bool>> MapFrom<TSource>(Expression<Func<TSource, bool>> sourcePredicateExpression, Func<string, string> resolveTargetMemberNameFunc)
    {
        return Expression.Lambda<Func<TTarget, bool>>(
                MapFrom<TSource>(sourcePredicateExpression.Body, resolveTargetMemberNameFunc),
                Expression.Parameter(typeof(TTarget), sourcePredicateExpression.Parameters[0].Name));
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        var sourceMemberName = node.Member.Name;
        var targetNode = this.Visit(node.Expression);
        var targetMemberName = this.ResolveTargetMemberNameFunc(sourceMemberName);
        var targetMember = targetNode.Type.GetMember(targetMemberName).FirstOrDefault();

        if (targetMember == null)
        {
            throw new NotSupportedException(String.Format("The source type '{0}' cannot be mapped to the target type '{1}', because that target type has no member '{2}'.", node.Expression.Type.Name, targetNode.Type.Name, targetMemberName));
        }

        return Expression.MakeMemberAccess(targetNode, targetMember);
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        if (node.Type == this.SourceType)
        {
            return Expression.Parameter(typeof(TTarget), node.Name);
        }

        return node;
    }
}

Answer 2

I have used AutoMapper to convert expressions using DTOs to Entities. Expression mapping is part of AutoMapper.Extensions.ExpressionMapping package. You essentially have to call AddExpressionMapping when you call AddAutoMapper (which itself is an extension method to IServiceCollection)