AutoMapper: "Ignorar o resto"?

Existe uma maneira de dizer ao AutoMapper para ignorar todas as propriedades, exceto aquelas mapeadas explicitamente?

Eu tenho classes DTO externas que provavelmente mudam do lado de fora e quero evitar especificar que cada propriedade seja ignorada explicitamente, pois a adição de novas propriedades interromperá a funcionalidade (causará exceções) ao tentar mapeá-las em meus próprios objetos.

Este é um método de extensão que escrevi que ignora todas as propriedades não existentes no destino. Não tenho certeza se ainda será útil, pois a pergunta tem mais de dois anos, mas encontrei o mesmo problema ao adicionar muitas chamadas manuais de Ignorar.

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;
}

Uso:

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

ATUALIZAÇÃO : Aparentemente, isso não funciona corretamente se você tiver mapeamentos personalizados porque os substitui. Eu acho que ainda poderia funcionar se chamar IgnoreAllNonExisting primeiro e depois os mapeamentos personalizados posteriormente.

O schdr tem uma solução (como resposta a esta pergunta) que é usada Mapper.GetAllTypeMaps()para descobrir quais propriedades não estão mapeadas e ignorá-las automaticamente. Parece uma solução mais robusta para mim.

Pelo que entendi, a pergunta era que existem campos no destino que não possuem um campo mapeado na origem, e é por isso que você está procurando maneiras de ignorar esses campos de destino não mapeados.

Em vez de implementar e usar esse método de extensão, você pode simplesmente usar

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

Agora, o automapper sabe que precisa validar apenas que todos os campos de origem estão mapeados, mas não o contrário.

Você também pode usar:

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

Atualizei a extensão de Can Gencer para não substituir nenhum mapa existente.

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;
}

Uso:

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

Consegui fazer isso da seguinte maneira:

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*/);
...

Nota: estou usando o AutoMapper v.2.0.

A versão 5.0.0-beta-1 do AutoMapper apresenta o ForAllOtherMembersmétodo de extensão para que você possa fazer isso agora:

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());

Esteja ciente de que existe uma vantagem em mapear explicitamente cada propriedade, pois você nunca terá problemas em mapear falhas silenciosas que surgem quando você esquece de mapear uma propriedade.

Talvez, no seu caso, talvez seja sensato ignorar todos os outros membros, adicionar a TODOpara voltar e torná-los explícitos após o término da frequência das alterações nessa classe.

No AutoMapper 5.0, a .TypeMappropriedade on IMappingExpressionfoi desativada, o que significa que a solução 4.2 não funciona mais. Eu criei uma solução que usa a funcionalidade original, mas com uma sintaxe diferente:

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>();
}

Implementação:

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));
    }
}

Há alguns anos desde que a pergunta foi feita, mas esse método de extensão me parece mais limpo, usando a versão atual do 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;
}

Para aqueles que estão usando a API não estática na versão 4.2.0 e acima, o seguinte método de extensão (encontrado aqui na AutoMapperExtensionsclasse) pode ser usado:

// 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;
}

O importante aqui é que, uma vez removida a API estática, o código que Mapper.FindTypeMapFornão funcionará mais, daí o uso do expression.TypeMapcampo.

Para o Automapper 5.0, para pular todas as propriedades não mapeadas, basta colocar

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

no final do seu perfil.

Por exemplo:

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());
    }
}

Nesse caso, apenas o campo Id para o objeto de saída será resolvido e todos os outros serão ignorados. Funciona como um encanto, parece que não precisamos mais de extensões complicadas!

Atualizei a resposta de Robert Schroeder para o AutoMapper 4.2. Com configurações de mapeador não estático, não podemos usar Mapper.GetAllTypeMaps(), mas ele expressiontem uma referência ao necessário 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;
}

Como você prefere especificar que certos membros sejam ignorados? Existe uma convenção, classe base ou atributo que você gostaria de aplicar? Depois que você começa a especificar explicitamente todos os mapeamentos, não tenho certeza de qual valor você obteria do AutoMapper.

Parece uma pergunta antiga, mas pensei em postar minha resposta para qualquer pessoa que parecesse.

Eu uso ConstructUsing, inicializador de objeto juntamente com ForAllMembers ignorar, por exemplo

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

A única informação sobre como ignorar muitos membros é este tópico - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Eu acho que você pode usar o truque usado em ProvidingCommonBaseClassConfiguration para ignorar propriedades comuns para classes semelhantes.
E não há informações sobre a funcionalidade "Ignorar o resto". Eu olhei o código antes e me parece que será muito e muito difícil adicionar essa funcionalidade. Além disso, você pode tentar usar algum atributo e marcar propriedades ignoradas e adicionar algum código genérico / comum para ignorar todas as propriedades marcadas.

Eu sei que essa é uma pergunta antiga, mas @jmoerdyk na sua pergunta:

Como você usaria isso em uma expressão CreateMap () encadeada em um perfil?

você pode usar esta resposta como essa dentro do ctor Profile

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

Você pode usar ForAllMembers, em vez de sobrescrever apenas o necessário

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

Cuidado, ele ignorará tudo e, se você não adicionar um mapeamento personalizado, eles já serão ignorados e não funcionarão.

Além disso, quero dizer, se você tiver teste de unidade para o AutoMapper. E você testa que todos os modelos com todas as propriedades mapeadas corretamente não devem usar esse método de extensão

você deve escrever ignorar explicitamente

A solução atual (versão 9) para ignorar as propriedades que não existem no tipo de destino é criar um mapeamento invertido e revertê-lo:

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

Na versão 3.3.1, você simplesmente pode usar IgnoreAllPropertiesWithAnInaccessibleSetter()ou IgnoreAllSourcePropertiesWithAnInaccessibleSetter()métodos.