AutoMapper один из основных инструментов применяемых в разработке Enterprise приложений, поэтому хочется писать как можно меньше кода определяя маппинг сущностей.
Мне не нравится дублирование в MapFrom при широких проекциях.
CreateMap<Pupil, PupilDto>()
.ForMember(x => x.Name, s => s.MapFrom(x => x.Identity.Passport.Name))
.ForMember(x => x.Surname, s => s.MapFrom(x => x.Identity.Passport.Surname))
.ForMember(x => x.Age, s => s.MapFrom(x => x.Identity.Passport.Age))
.ForMember(x => x.Number, s => s.MapFrom(x => x.Identity.Passport.Number))
Я бы хотел переписать так:
CreateMap<Pupil, PupilDto>()
.From(x=>x.IdentityCard.Passport).To()
ProjectTo
AutoMapper умеет строить маппинг как в памяти, так и транслировать в SQL, он дописывает Expression, делая проекцию в DTO по правилам, которые вы описали в профайлах.
EntityQueryable.Select(dtoPupil => new PupilDto() {
Name = dtoPupil.Identity.Passport,
Surname = dtoPupil.Identity.Passport.Surname})
80% процентов маппинга, который приходится писать мне — маппинг который достраивает Expression из IQueryble.
Это очень удобно:
public ActionResult<IEnumerable<PupilDto>> GetAdultPupils(){
var result = _context.Pupils
.Where(x=>x.Identity.Passport.Age >= 18 && ...)
.ProjectTo<PupilDto>().ToList();
return result;
}
В декларативном стиле мы сформировали запрос к таблице Pupils, добавили фильтрацию, спроецировали в нужный DTO и вернули клиенту, так можно записать все read методы простого CRUD интерфейса.И все это будет выполнено в на уровне базы данных.
Правда, в серьезных приложениях такие action'ы вряд-ли будут удовлетворять клиентов.
Минусы AutoMapper'a
1) Он очень многословен, при "широком" маппинге приходится писать правила, которые не умещаются на одной строчке кода.
Профайлы разрастаются и превращаются в архивы кода, который один раз написан и изменяется только при рефакторинге наименований.
2) Если использовать маппинг по конвенции, теряется лаконичность наименования
свойств в DTO:
public class PupilDto
{
// Сущность Pupil связана один к одному с сущностью IdentityCard
// IdentityCard один к одному с Passport
public string IdentityCardPassportName { get; set; }
public string IdentityCardPassportSurname { get; set; }
}
3) Отсутствие типобезопасности
1 и 2 — неприятные моменты, но с ними можно смириться, а вот с отсутствием типобезопасности при регистрации смириться уже сложнее, это не должно компилироваться:
// Name - string
// Age - int
ForMember(x => x.Age, s => s.MapFrom(x => x.Identity.Passport.Name)
О таких ошибках мы хотим получать информацию на этапе компиляции, а не в run-time.
С помощью extention оберток устраним эти моменты.
Пишем обертку
Почему регистрация должна быть написана таким образом?
CreateMap<Pupil, PupilDto>()
.ForMember(x => x.Name, s => s.MapFrom(x => x.Identity.Passport.Name))
.ForMember(x => x.Surname, s => s.MapFrom(x => x.Identity.Passport.Surname))
.ForMember(x => x.Age, s => s.MapFrom(x => x.Identity.Passport.Age))
.ForMember(x => x.House, s => s.MapFrom(x => x.Address.House))
.ForMember(x => x.Street, s => s.MapFrom(x => x.Address.Street))
.ForMember(x => x.Country, s => s.MapFrom(x => x.Address.Country))
.ForMember(x => x.Surname, s => s.MapFrom(x => x.Identity.Passport.Age))
.ForMember(x => x.Group, s => s.MapFrom(x=>x.EducationCard.StudyGroup.Number))
Вот так намного лаконичнее:
CreateMap<Pupil,PupilDto>()
// маппинг по конвенции
// PassportName = Passport.Name, PassportSurname = Passport.Surname
.From(x => x.IdentityCard.Passport).To()
// House,Street,Country - по конвенции
.From(x => x.Address).To()
// первый параметр кортежа - свойство DTO, второй - сущности
.From(x => x.EducationCard.Group).To((x => x.Group,x => x.Number));
Метод To будет принимать кортежи, если понадобится указать правила маппинга
IMapping<TSource,TDest> это интерфейс automaper'a в котором определены методы ForMember,ForAll()… все эти методы возвращают возвращают this (Fluent Api).
Мы вернем wrapper чтобы запомнить Expression из метода From
public static MapperExpressionWrapper<TSource, TDest, TProjection>
From<TSource, TDest, TProjection>
(this IMappingExpression<TSource, TDest> mapping,
Expression<Func<TSource, TProjection>> expression) =>
new MapperExpressionWrapper<TSource, TDest, TProjection>(mapping, expression);
Теперь программист написав метод From сразу увидит перегрузку метода To, тем самым мы подскажем ему API, в таких случаях мы можем осознать все прелести extension методов, мы расширили поведение, не имея write доступ к исходникам автомаппера
Типизируем
Реализация типизированного метода To сложнее.
Попробуем спроектировать этот метод, нам нужно максимально разбить его на части и вынести всю логику в другие методы. Сразу условимся, что мы ограничим количество параметров-кортежей десятью.
Когда в моей практике встречается подобная задача, я сразу смотрю в сторону Roslyn, не хочется писать множество однотипных методов и заниматься Copy Paste, их проще сгенерировать.
В этом нам помогут generic'и. Нужно сгенерировать 10 методов c различным числом generic'ов и параметров
Первый подход к снаряду был немного другой, я хотел ограничить возвращаемые типы лямбд (int,string,boolean,DateTime) и не использовать универсальные типы.
Сложность в том, что даже для 3 параметров нам придется генерировать 64 различные перегрузки, а при использовании generic всего 1:
IMappingExpression<TSource, TDest> To<TSource, TDest, TProjection,T,T1, T2, T3>(
this MapperExpressionWrapper<TSource,TDest,TProjection> mapperExpressionWrapper,
(Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) arg0,
(Expression<Func<TDest, T1>>, Expression<Func<TProjection, T1>>) arg1,
(Expression<Func<TDest, T2>>, Expression<Func<TProjection, T2>>) arg2,
(Expression<Func<TDest, T3>>, Expression<Func<TProjection, T3>>) arg3)
{
...
}
Но это не главная проблема, мы же генерируем код, это займет определенное время и мы получим весь набор необходимых методов.
Проблема в другом, ReSharper не подхватит столько перегрузок и просто откажется работать, вы лишитесь Intellisience и подгрузите IDE.
Реализуем метод принимающий один кортеж:
public static IMappingExpression<TSource, TDest> To
<TSource, TDest, TProjection, T>(this
MapperExpressionWrapper<TSource,TDest,TProjection> mapperExpressionWrapper,
(Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) arg0)
{ // регистрация по конвенции
RegisterByConvention(mapperExpressionWrapper);
// регистрация по заданному expreession
RegisterRule(mapperExpressionWrapper, arg0);
// вернем IMappingExpression,чтобы далее можно было применить
// любые другие extension методы
return mapperExpressionWrapper.MappingExpression;
}
Сначала проверим для каких свойств можно найти маппинг по конвенции, это довольно простой метод, для каждого свойства в DTO ищем путь в исходной сущности. Методы придется вызывать рефлексивно, потому что нужно получить типизированную лямбду, а ее тип зависит от prop.
Регистрировать лямбду типа Expression<Func<TSource,object>> нельзя, тогда AutoMapper будет сопоставлять все свойства DTO типу object
private static void RegisterByConvention<TSource, TDest, TProjection>(
MapperExpressionWrapper<TSource, TDest, TProjection> mapperExpressionWrapper)
{
var properties = typeof(TDest).GetProperties().ToList();
properties.ForEach(prop =>
{
// mapperExpressionWrapper.FromExpression = x=>x.Identity.Passport
// prop.Name = Name
// ruleByConvention Expression<Func<Pupil,string>> x=>x.Identity.Passport.Name
var ruleByConvention = _cachedMethodInfo
.GetMethod(nameof(HelpersMethod.GetRuleByConvention))
.MakeGenericMethod(typeof(TSource), typeof(TProjection), prop.PropertyType)
.Invoke(null, new object[] {prop, mapperExpressionWrapper.FromExpression});
if (ruleByConvention == null) return;
//регистрируем
mapperExpressionWrapper.MappingExpression.ForMember(prop.Name,
s => s.MapFrom((dynamic) ruleByConvention));
});
}
RegisterRule получает кортеж, который задает правила маппинга, в нем нужно "соединить"
FromExpression и expression, переданный в кортеж.
В этом нам поможет Expression.Invoke, EF Core 2.0 не поддерживал его, более поздние версии начали поддерживать. Он позволит сделать "композицию лямбд":
Expression<Func<Pupil,StudyGroup>> from = x=>x.EducationCard.StudyGroup;
Expression<Func<StudyGroup,int>> @for = x=>x.Number;
//invoke = x=>x.EducationCard.StudyGroup.Number;
var composition = Expression.Lambda<Func<Pupil, string>>(
Expression.Invoke(@for,from.Body),from.Parameters.First())
Метод RegisterRule:
private static void RegisterRule<TSource, TDest, TProjection, T
(MapperExpressionWrapper<TSource,TDest,TProjection> mapperExpressionWrapper,
(Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) rule)
{
//rule = (x=>x.Group,x=>x.Number)
var (from, @for) = rule;
// заменяем интерполяцию на конкатенацию строк
@for = (Expression<Func<TProjection, T>>) _interpolationReplacer.Visit(@for);
//mapperExpressionWrapper.FromExpression = (x=>x.EducationCard.StudyGroup)
var result = Expression.Lambda<Func<TSource, T>>(
Expression.Invoke(@for, mapperExpressionWrapper.FromExpression.Body),
mapperExpressionWrapper.FromExpression.Parameters.First());
var destPropertyName = from.PropertiesStr().First();
// result = x => Invoke(x => x.Number, x.EducationCard.StudyGroup)
// можно читать, как result = x=>x.EducationCard.StudyCard.Number
mapperExpressionWrapper.MappingExpression
.ForMember(destPropertyName, s => s.MapFrom(result));
}
Метод To спроектирован так, чтобы его легко было расширять при добавлении параметров-кортежей. При добавлении в параметры еще одного кортежа, нужно добавить еще один generic, параметр, и вызов метода RegisterRule для нового параметра.
Пример для двух параметров:
IMappingExpression<TSource, TDest> To<TSource, TDest, TProjection, T, T1>
(this MapperExpressionWrapper<TSource,TDest,TProjection>mapperExpressionWrapper,
(Expression<Func<TDest, T>>, Expression<Func<TProjection, T>>) arg0,
(Expression<Func<TDest, T1>>, Expression<Func<TProjection, T1>>) arg1)
{
RegisterByConvention(mapperExpressionWrapper);
RegisterRule(mapperExpressionWrapper, arg0);
RegisterRule(mapperExpressionWrapper, arg1);
return mapperExpressionWrapper.MappingExpression;
}
Используем CSharpSyntaxRewriter, это визитор который проходится по узлам синтаксического дерева. За основу возьмем метод с To с одним аргументом и в процессе обхода добавим generic, параметр и вызов RegisterRule;
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
// Если это не метод To
if (node.Identifier.Value.ToString() != "To")
return base.VisitMethodDeclaration(node);
// returnStatement = return mapperExpressionWrapper.MappingExpression;
var returnStatement = node.Body.Statements.Last();
//beforeReturnStatements:
//[RegisterByConvention(mapperExpressionWrapper),
// RegisterRule(mapperExpressionWrapper, arg0)]
var beforeReturnStatements = node.Body.Statements.SkipLast(1);
//добавляем вызов метода RegisterRule перед returStatement
var newBody = SyntaxFactory.Block(
beforeReturnStatements.Concat(ReWriteMethodInfo.Block.Statements)
.Concat(new[] {returnStatement}));
// возвращаем перезаписанный узел дерева
return node.Update(
node.AttributeLists, node.Modifiers,
node.ReturnType,
node.ExplicitInterfaceSpecifier,
node.Identifier,
node.TypeParameterList.AddParameters
(ReWriteMethodInfo.Generics.Parameters.ToArray()),
node.ParameterList.AddParameters
(ReWriteMethodInfo.AddedParameters.Parameters.ToArray()),
node.ConstraintClauses,
newBody,
node.SemicolonToken);
}
В ReWriteMethodInfo лежат сгенерированные синтаксические узлы дерева, которые необходимо добавить. После этого мы получим список, состоящий их 10 объектов с типом MethodDeclarationSyntax (синтаксическое дерево, представляющее метод).
На следующем шаге возьмем класс, в котором лежит шаблонный метод To и запишем в него все новые методы используя другой Visitor, в котором переопределим VisitClassDeclatation.
Метод Update метод позволяет редактировать существующий узел дерева, он под капотом перебирает все переданные аргументы, и если хотя бы один отличается от исходного создает новый узел.
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
//todo refactoring it
return node.Update(
node.AttributeLists,
node.Modifiers,
node.Keyword,
node.Identifier,
node.TypeParameterList,
node.BaseList,
node.ConstraintClauses,
node.OpenBraceToken,
new SyntaxList<MemberDeclarationSyntax>(ReWriteMethods),
node.CloseBraceToken,
node.SemicolonToken);
}
В конце концов мы получим SyntaxNode — класс с добавленными методами, запишем узел в новый файл.Теперь у нас появились перегрузки метода To принимающие от 1 до 10 кортежей и намного более лаконичный маппинг.
Точка расширения
Посмотрим на AutoMapper, как на нечто большее. Queryable Provider не может разобрать достаточно много запросов, и определенную часть этих запросов можно выполнить переписав по-другому. Вот тут в игру вступает AutoMapper, extension'ы это точка расширения, куда мы можем добавить свои правила.
Применим visitor из предыдущей статьи заменяющий интерполяцию строк конкатенацией в методе RegusterRule.В итоге все expression'ы, определяющие маппинг из сущности, пройдут через этот visitor, тем самым мы избавимся от необходимости каждый раз вызывать ReWrite.Это не панацея, единственное, чем мы можем управлять — проекция, но это все-равно облегчает жизнь.
Также мы можем дописать некоторые удобные extention'ы, например, для маппинга по условию:
CreateMap<Passport,PassportDto>()
.ToIf(x => x.Age, x => x < 18, x => $"{x.Age}", x => "Adult")
Главное не заиграться с этим и не начать переносить сложную логику на уровень отображения
Github
Комментариев нет:
Отправить комментарий