AutoMapper: "Ignora il resto"?

C'è un modo per dire ad AutoMapper di ignorare tutte le proprietà tranne quelle che sono mappate esplicitamente?

Ho classi DTO esterne che probabilmente cambieranno dall'esterno e voglio evitare di specificare ogni proprietà da ignorare esplicitamente, poiché l'aggiunta di nuove proprietà interromperà la funzionalità (causa eccezioni) quando provo a mapparle nei miei oggetti.

Questo è un metodo di estensione che ho scritto che ignora tutte le proprietà non esistenti sulla destinazione. Non sono sicuro se sarà ancora utile poiché la domanda ha più di due anni, ma ho riscontrato lo stesso problema con l'aggiunta di molte chiamate Ignore manuali.

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

AGGIORNAMENTO : a quanto pare questo non funziona correttamente se si dispone di mapping personalizzati perché li sovrascrive. Immagino che potrebbe funzionare ancora se prima chiami IgnoreAllNonExisting e poi i mapping personalizzati.

schdr ha una soluzione (come risposta a questa domanda) che usa Mapper.GetAllTypeMaps()per scoprire quali proprietà non sono mappate e ignorarle automaticamente. Mi sembra una soluzione più solida.

Da quello che ho capito la domanda era che ci sono campi sulla destinazione che non hanno un campo mappato nella fonte, motivo per cui stai cercando modi per ignorare quei campi di destinazione non mappati.

Invece di implementare e utilizzare questi metodi di estensione potresti semplicemente usare

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

Ora l'automapper sa che deve solo convalidare che tutti i campi di origine sono mappati ma non viceversa.

Puoi anche usare:

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

Ho aggiornato l'estensione Can Gencer per non sovrascrivere alcuna mappa esistente.

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

Sono stato in grado di farlo nel modo seguente:

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

La versione 5.0.0-beta-1 di AutoMapper introduce il ForAllOtherMembersmetodo di estensione, quindi ora puoi farlo:

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

Essere consapevoli del fatto che esiste un vantaggio nel mappare esplicitamente ogni proprietà poiché non si verificheranno mai problemi di mappatura che falliscono in modo silenzioso che si presentano quando si dimentica di mappare una proprietà.

Forse nel tuo caso potrebbe essere saggio ignorare tutti gli altri membri e aggiungere un TODOper tornare e renderli espliciti dopo che la frequenza delle modifiche a questa classe si è stabilizzata.

A partire da AutoMapper 5.0, la .TypeMapproprietà on IMappingExpressionè sparita, il che significa che la soluzione 4.2 non funziona più. Ho creato una soluzione che utilizza la funzionalità originale ma con una sintassi diversa:

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

Implementazione:

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

Sono passati alcuni anni da quando è stata posta la domanda, ma questo metodo di estensione mi sembra più pulito, usando l'attuale versione di 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;
}

Per coloro che utilizzano l' API non statica nella versione 4.2.0 e successive, è possibile utilizzare il seguente metodo di estensione (trovato qui nella AutoMapperExtensionsclasse):

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

La cosa importante qui è che una volta rimossa l'API statica, codice come Mapper.FindTypeMapFornon funzionerà più, quindi l'uso del expression.TypeMapcampo.

Per Automapper 5.0 per saltare tutte le proprietà non mappate è sufficiente inserirle

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

alla fine del tuo profilo.

Per esempio:

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

In questo caso verrà risolto solo il campo ID per l'oggetto di output, tutti gli altri verranno ignorati. Funziona come un fascino, sembra che non abbiamo più bisogno di estensioni complicate!

Ho aggiornato la risposta di Robert Schroeder per AutoMapper 4.2. Con le configurazioni del mapper non statico, non possiamo usare Mapper.GetAllTypeMaps(), ma expressionha un riferimento al richiesto 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;
}

Come preferiresti specificare che alcuni membri vengano ignorati? Esiste una convenzione, una classe di base o un attributo che desideri applicare? Una volta che inizi a specificare tutte le mappature in modo esplicito, non sono sicuro di quale valore otterrai da AutoMapper.

Questa sembra una vecchia domanda, ma ho pensato di pubblicare la mia risposta per chiunque sembri.

Uso ConstructUsing, l'inizializzatore di oggetti accoppiato a ForAllMembers ignora ad es

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

L'unica informazione sull'ignorare molti membri è questa discussione: http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Penso che tu possa usare il trucco usato in ProvidingCommonBaseClassConfiguration per ignorare le proprietà comuni per classi simili.
E non ci sono informazioni sulla funzionalità "Ignora il resto". Ho già esaminato il codice e mi sembra che sarà molto e molto difficile aggiungere tale funzionalità. Inoltre, puoi provare a utilizzare alcuni attributi e contrassegnare con esso le proprietà ignorate e aggiungere un codice generico / comune per ignorare tutte le proprietà contrassegnate.

So che questa è una vecchia domanda, ma @jmoerdyk nella tua domanda:

Come lo useresti in un'espressione concatenata di CreateMap () in un profilo?

puoi usare questa risposta in questo modo nel Profile ctor

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

È possibile utilizzare ForAllMembers, che sovrascrivere è necessario solo in questo modo

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

Fai attenzione, ignorerà tutto e se non aggiungerai il mapping personalizzato, saranno già ignorati e non funzioneranno

Inoltre, voglio dire, se si dispone di unit test per AutoMapper. E testerai che tutti i modelli con tutte le proprietà mappate correttamente non dovresti usare tale metodo di estensione

dovresti scrivere ignora esplicitamente

L'attuale soluzione (versione 9) per ignorare le proprietà che non esistono nel tipo di destinazione consiste nel creare un mapping capovolto e invertirlo:

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

Nella versione 3.3.1 puoi semplicemente usare IgnoreAllPropertiesWithAnInaccessibleSetter()o IgnoreAllSourcePropertiesWithAnInaccessibleSetter()metodi.