AutoMapper: "¿Ignorar el resto"?

¿Hay alguna manera de decirle a AutoMapper que ignore todas las propiedades, excepto las que se asignan explícitamente?

Tengo clases externas de DTO que es probable que cambien desde el exterior y quiero evitar especificar que cada propiedad se ignore explícitamente, ya que agregar nuevas propiedades romperá la funcionalidad (causará excepciones) cuando intente asignarlas a mis propios objetos.

Este es un método de extensión que escribí que ignora todas las propiedades no existentes en el destino. No estoy seguro de si seguirá siendo útil ya que la pregunta tiene más de dos años, pero me encontré con el mismo problema al tener que agregar muchas llamadas de Ignorar manuales.

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

ACTUALIZACIÓN : Aparentemente, esto no funciona correctamente si tiene asignaciones personalizadas porque las sobrescribe. Supongo que aún podría funcionar si llama a IgnoreAllNonExisting primero y luego las asignaciones personalizadas más tarde.

schdr tiene una solución (como respuesta a esta pregunta) que utiliza Mapper.GetAllTypeMaps()para averiguar qué propiedades no están asignadas y las ignora automáticamente. Parece una solución más robusta para mí.

Por lo que entendí, la pregunta era que hay campos en el destino que no tienen un campo mapeado en la fuente, por lo que está buscando formas de ignorar esos campos de destino no mapeados.

En lugar de implementar y usar estos métodos de extensión, simplemente podría usar

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

Ahora el automapper sabe que solo necesita validar que todos los campos de origen estén asignados, pero no al revés.

También puedes usar:

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

He actualizado la extensión de Can Gencer para no sobrescribir ningún 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();

He podido hacer esto de la siguiente manera:

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: Estoy usando AutoMapper v.2.0.

La versión 5.0.0-beta-1 de AutoMapper presenta el ForAllOtherMembersmétodo de extensión para que ahora pueda hacer esto:

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

Tenga en cuenta que existe una ventaja al mapear explícitamente cada propiedad, ya que nunca tendrá problemas de mapeo silencioso que surgen cuando se olvida de mapear una propiedad.

Quizás en su caso, sería aconsejable ignorar a todos los demás miembros y agregar un TODOpara volver y hacerlos explícitos después de que se establezca la frecuencia de los cambios en esta clase.

A partir de AutoMapper 5.0, la .TypeMappropiedad IMappingExpressionha desaparecido, lo que significa que la solución 4.2 ya no funciona. Creé una solución que usa la funcionalidad original pero con una sintaxis 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>();
}

Implementación:

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

Han pasado algunos años desde que se hizo la pregunta, pero este método de extensión me parece más limpio, usando la versión actual de 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 aquellos que usan la API no estática en la versión 4.2.0 y superior, se puede usar el siguiente método de extensión (que se encuentra aquí en la AutoMapperExtensionsclase):

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

Lo importante aquí es que una vez que se elimina la API estática, el código como Mapper.FindTypeMapForya no funcionará, de ahí el uso del expression.TypeMapcampo.

Para Automapper 5.0 para omitir todas las propiedades no asignadas, solo necesita poner

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

al final de tu perfil.

Por ejemplo:

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

En este caso, solo el campo Id para el objeto de salida se resolverá, todos los demás se omitirán. Funciona de maravilla, ¡parece que ya no necesitamos extensiones difíciles!

He actualizado la respuesta de Robert Schroeder para AutoMapper 4.2. Con configuraciones de mapeador no estático, no podemos usar Mapper.GetAllTypeMaps(), pero expressiontiene una referencia a lo requerido 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;
}

¿Cómo preferiría especificar que ciertos miembros sean ignorados? ¿Hay alguna convención, clase base o atributo que le gustaría aplicar? Una vez que entre en el negocio de especificar todas las asignaciones explícitamente, no estoy seguro de qué valor obtendría de AutoMapper.

Esta parece una vieja pregunta, pero pensé que publicaría mi respuesta para cualquier otra persona que parezca que era.

Utilizo ConstructUsing, el inicializador de objeto junto con ForAllMembers ignora, por ejemplo

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

La única información sobre ignorar a muchos miembros es este hilo: http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Creo que puede usar el truco utilizado en Pro ProvideCommonBaseClassConfiguration para ignorar las propiedades comunes de clases similares.
Y no hay información sobre la funcionalidad "Ignorar el resto". He visto el código antes y me parece que será muy y muy difícil agregar dicha funcionalidad. También puede intentar usar algún atributo y marcar con él las propiedades ignoradas y agregar algún código genérico / común para ignorar todas las propiedades marcadas.

Sé que esta es una vieja pregunta, pero @jmoerdyk en tu pregunta:

¿Cómo usarías esto en una expresión encadenada de CreateMap () en un perfil?

puedes usar esta respuesta como esta dentro del Perfil ctor

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

Puede usar ForAllMembers, que sobrescribir solo se necesita de esta manera

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

Tenga cuidado, lo ignorará todo, y si no agrega mapeo personalizado, ya se ignorarán y no funcionarán.

También, quiero decir, si tiene prueba de unidad para AutoMapper. Y prueba que todos los modelos con todas las propiedades asignadas correctamente no deberían usar dicho método de extensión

deberías escribir ignorar explícitamente

La solución actual (versión 9) para ignorar las propiedades que no existen en el tipo de destino es crear una asignación invertida y revertirla:

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

En la versión 3.3.1 simplemente puede usar IgnoreAllPropertiesWithAnInaccessibleSetter()o IgnoreAllSourcePropertiesWithAnInaccessibleSetter()métodos.