AutoMapper: «Игнорировать все остальное»?

Есть ли способ сказать AutoMapper игнорировать все свойства, кроме тех, которые отображаются явно?

У меня есть внешние классы DTO, которые могут измениться извне, и я хочу избежать указания каждого свойства, которое будет явно игнорироваться, так как добавление новых свойств нарушит функциональность (вызывает исключения) при попытке сопоставить их с моими собственными объектами.

Это метод расширения, который я написал, который игнорирует все несуществующие свойства в месте назначения. Не уверен, будет ли он по-прежнему полезен, так как этому вопросу более двух лет, но я столкнулся с той же проблемой, когда пришлось добавить множество игнорируемых вручную вызовов.

public static IMappingExpression<TSource, TDestination> IgnoreAllNonExisting<TSource, TDestination>
(this IMappingExpression<TSource, TDestination> expression)
{
    var flags = BindingFlags.Public | BindingFlags.Instance;
    var sourceType = typeof (TSource);
    var destinationProperties = typeof (TDestination).GetProperties(flags);

    foreach (var property in destinationProperties)
    {
        if (sourceType.GetProperty(property.Name, flags) == null)
        {
            expression.ForMember(property.Name, opt => opt.Ignore());
        }
    }
    return expression;
}

Использование:

Mapper.CreateMap<SourceType, DestinationType>()
                .IgnoreAllNonExisting();

ОБНОВИТЬ : Очевидно, это не работает правильно, если у вас есть пользовательские сопоставления, потому что он перезаписывает их. Я предполагаю, что он все еще может работать, если сначала вызвать IgnoreAllNonExisting, а затем пользовательские сопоставления.

У schdr есть решение (в качестве ответа на этот вопрос), которое Mapper.GetAllTypeMaps()позволяет выяснить, какие свойства не сопоставлены, и автоматически их игнорировать. Похоже, более надежное решение для меня.

Из того, что я понял, вопрос заключался в том, что в месте назначения есть поля, у которых нет сопоставленного поля в источнике, поэтому вы ищете способы игнорировать эти не сопоставленные поля назначения.

Вместо реализации и использования этих методов расширения вы можете просто использовать

Mapper.CreateMap<sourceModel, destinationModel>(MemberList.Source);  

Теперь автопроизводитель знает, что ему нужно только проверить, что все исходные поля сопоставлены, но не наоборот.

Вы также можете использовать:

Mapper.CreateMap<sourceModel, destinationModel>(MemberList.Destination);  

Я обновил расширение Can Gencer, чтобы не переписывать существующие карты.

public static IMappingExpression<TSource, TDestination> 
    IgnoreAllNonExisting<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    var sourceType = typeof (TSource);
    var destinationType = typeof (TDestination);
    var existingMaps = Mapper.GetAllTypeMaps().First(x => x.SourceType.Equals(sourceType) && x.DestinationType.Equals(destinationType));
    foreach (var property in existingMaps.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

Использование:

Mapper.CreateMap<SourceType, DestinationType>()
                .ForMember(prop => x.Property, opt => opt.MapFrom(src => src.OtherProperty))
                .IgnoreAllNonExisting();

Я смог сделать это следующим образом:

Mapper.CreateMap<SourceType, DestinationType>().ForAllMembers(opt => opt.Ignore());
Mapper.CreateMap<SourceType, DestinationType>().ForMember(/*Do explicit mapping 1 here*/);
Mapper.CreateMap<SourceType, DestinationType>().ForMember(/*Do explicit mapping 2 here*/);
...

Примечание: я использую AutoMapper v.2.0.

Версия 5.0.0-бета-1 AutoMapper представляет ForAllOtherMembersметод расширения, поэтому теперь вы можете сделать это:

CreateMap<Source, Destination>()
    .ForMember(d => d.Text, o => o.MapFrom(s => s.Name))
    .ForMember(d => d.Value, o => o.MapFrom(s => s.Id))
    .ForAllOtherMembers(opts => opts.Ignore());

Имейте в виду, что есть явное преимущество в явном сопоставлении каждого свойства, поскольку у вас никогда не возникнет проблем с молчаливым сбоем сопоставления, возникающих, когда вы забываете сопоставить свойство.

Возможно, в вашем случае было бы разумно игнорировать всех других членов и добавить a, TODOчтобы вернуться и сделать их явными после того, как частота изменений в этом классе установится.

Начиная с AutoMapper 5.0, .TypeMapсвойство on IMappingExpressionпропало, что означает, что решение 4.2 больше не работает. Я создал решение, которое использует оригинальную функциональность, но с другим синтаксисом:

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src, Dest>();
    cfg.IgnoreUnmapped();        // Ignores unmapped properties on all maps
    cfg.IgnoreUnmapped<Src, Dest>();  // Ignores unmapped properties on specific map
});

// or add  inside a profile
public class MyProfile : Profile
{
   this.IgnoreUnmapped();
   CreateMap<MyType1, MyType2>();
}

Реализация:

public static class MapperExtensions
{
    private static void IgnoreUnmappedProperties(TypeMap map, IMappingExpression expr)
    {
        foreach (string propName in map.GetUnmappedPropertyNames())
        {
            if (map.SourceType.GetProperty(propName) != null)
            {
                expr.ForSourceMember(propName, opt => opt.Ignore());
            }
            if (map.DestinationType.GetProperty(propName) != null)
            {
                expr.ForMember(propName, opt => opt.Ignore());
            }
        }
    }

    public static void IgnoreUnmapped(this IProfileExpression profile)
    {
        profile.ForAllMaps(IgnoreUnmappedProperties);
    }

    public static void IgnoreUnmapped(this IProfileExpression profile, Func<TypeMap, bool> filter)
    {
        profile.ForAllMaps((map, expr) =>
        {
            if (filter(map))
            {
                IgnoreUnmappedProperties(map, expr);
            }
        });
    }

    public static void IgnoreUnmapped(this IProfileExpression profile, Type src, Type dest)
    {
        profile.IgnoreUnmapped((TypeMap map) => map.SourceType == src && map.DestinationType == dest);
    }

    public static void IgnoreUnmapped<TSrc, TDest>(this IProfileExpression profile)
    {
        profile.IgnoreUnmapped(typeof(TSrc), typeof(TDest));
    }
}

Прошло несколько лет с тех пор, как вопрос был задан, но этот метод расширения кажется мне чище, используя текущую версию AutoMapper (3.2.1):

public static IMappingExpression<TSource, TDestination> IgnoreUnmappedProperties<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    var typeMap = Mapper.FindTypeMapFor<TSource, TDestination>();
    if (typeMap != null)
    {
        foreach (var unmappedPropertyName in typeMap.GetUnmappedPropertyNames())
        {
            expression.ForMember(unmappedPropertyName, opt => opt.Ignore());
        }
    }

    return expression;
}

Для тех, кто использует нестатический API в версии 4.2.0 и выше, может использоваться следующий метод расширения (найденный здесь в AutoMapperExtensionsклассе):

// from http://stackoverflow.com/questions/954480/automapper-ignore-the-rest/6474397#6474397
public static IMappingExpression IgnoreAllNonExisting(this IMappingExpression expression)
{
    foreach(var property in expression.TypeMap.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

Здесь важно то, что после удаления статического API такой код, как Mapper.FindTypeMapFor, больше не будет работать, следовательно, использование expression.TypeMapполя.

Для Automapper 5.0, чтобы пропустить все несопоставленные свойства, вам просто нужно положить

.ForAllOtherMembers (х => x.Ignore ());

в конце вашего профиля.

Например:

internal class AccountInfoEntityToAccountDtoProfile : Profile
{
    public AccountInfoEntityToAccountDtoProfile()
    {
        CreateMap<AccountInfoEntity, AccountDto>()
           .ForMember(d => d.Id, e => e.MapFrom(s => s.BankAcctInfo.BankAcctFrom.AcctId))
           .ForAllOtherMembers(x=>x.Ignore());
    }
}

В этом случае будет разрешено только поле Id для выходного объекта, все остальные будут пропущены. Работает как шарм, кажется, нам больше не нужны хитрые расширения!

Я обновил ответ Роберта Шредера для AutoMapper 4.2. С нестатическими конфигурациями сопоставления мы не можем использовать Mapper.GetAllTypeMaps(), но expressionесть ссылка на обязательные TypeMap:

public static IMappingExpression<TSource, TDestination> 
    IgnoreAllNonExisting<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    foreach (var property in expression.TypeMap.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

Как бы вы предпочли указать, что некоторые члены игнорируются? Есть ли соглашение, базовый класс или атрибут, который вы хотели бы применить? Когда вы начнете явно указывать все сопоставления, я не уверен, какую ценность вы получите от AutoMapper.

Это кажется старым вопросом, но я решил опубликовать свой ответ для всех, кто похож на меня.

Я использую ConstructUsing, инициализатор объекта в сочетании с ForAllMembers игнорировать, например

    Mapper.CreateMap<Source, Target>()
        .ConstructUsing(
            f =>
                new Target
                    {
                        PropVal1 = f.PropVal1,
                        PropObj2 = Map<PropObj2Class>(f.PropObj2),
                        PropVal4 = f.PropVal4
                    })
        .ForAllMembers(a => a.Ignore());

Единственная информация об игнорировании многих участников - эта тема - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Я думаю, что вы можете использовать трюк, используемый в ProvidingCommonBaseClassConfiguration, чтобы игнорировать общие свойства для похожих классов.
И нет никакой информации о функционале «Игнорировать остальные». Я смотрел на код раньше, и мне кажется, что добавить такую ​​функциональность будет очень и очень сложно. Также вы можете попытаться использовать какой-либо атрибут и пометить им игнорируемые свойства и добавить общий / общий код, чтобы игнорировать все отмеченные свойства.

Я знаю, что это старый вопрос, но @jmoerdyk в вашем вопросе:

Как бы вы использовали это в цепочечном выражении CreateMap () в профиле?

Вы можете использовать этот ответ, как это внутри профиля Ctor

this.IgnoreUnmapped();
CreateMap<TSource, Tdestination>(MemberList.Destination)
.ForMember(dest => dest.SomeProp, opt => opt.MapFrom(src => src.OtherProp));

Вы можете использовать ForAllMembers, чем нужно перезаписывать только так

public static IMappingExpression<TSource, TDest> IgnoreAll<TSource, TDest>(this IMappingExpression<TSource, TDest> expression)
        {
            expression.ForAllMembers(opt => opt.Ignore());
            return expression;
        }

Будьте осторожны, он будет игнорировать все, и если вы не добавите пользовательские сопоставления, они уже игнорируются и не будут работать

Кроме того, я хочу сказать, если у вас есть модульный тест для AutoMapper. И вы проверяете, что все модели со всеми свойствами отображаются правильно, вы не должны использовать такой метод расширения

вы должны написать игнорировать явно

Текущее (версия 9) решение для игнорирования свойств, которые не существуют в типе назначения, состоит в том, чтобы создать перевернутое отображение и обратить его вспять:

var config = new MapperConfiguration(cfg => {
  cfg.CreateMap<TheActualDestinationType, TheActualSourceType>().ReverseMap();
});

В версии 3.3.1 вы просто можете использовать IgnoreAllPropertiesWithAnInaccessibleSetter()или IgnoreAllSourcePropertiesWithAnInaccessibleSetter()методы.