AutoMapper: "Den Rest ignorieren"?

Gibt es eine Möglichkeit, AutoMapper anzuweisen, alle Eigenschaften außer denen, die explizit zugeordnet sind, zu ignorieren?

Ich habe externe DTO-Klassen, die sich wahrscheinlich von außen ändern, und ich möchte vermeiden, dass jede Eigenschaft explizit ignoriert wird, da das Hinzufügen neuer Eigenschaften die Funktionalität beeinträchtigt (Ausnahmen verursacht), wenn versucht wird, sie meinen eigenen Objekten zuzuordnen.

Dies ist eine Erweiterungsmethode, die ich geschrieben habe und die alle nicht vorhandenen Eigenschaften des Ziels ignoriert. Ich bin mir nicht sicher, ob es noch nützlich sein wird, da die Frage älter als zwei Jahre ist, aber ich bin auf dasselbe Problem gestoßen, das viele manuelle Ignorieraufrufe hinzufügen musste.

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

Verwendung:

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

UPDATE : Anscheinend funktioniert dies nicht richtig, wenn Sie benutzerdefinierte Zuordnungen haben, da diese überschrieben werden. Ich denke, es könnte immer noch funktionieren, wenn Sie zuerst IgnoreAllNonExisting und später die benutzerdefinierten Zuordnungen aufrufen.

schdr hat eine Lösung (als Antwort auf diese Frage), mit Mapper.GetAllTypeMaps()der herausgefunden wird, welche Eigenschaften nicht zugeordnet sind, und diese automatisch ignoriert wird. Scheint mir eine robustere Lösung zu sein.

Soweit ich verstanden habe, war die Frage, dass es Felder am Ziel gibt, die kein zugeordnetes Feld in der Quelle haben. Deshalb suchen Sie nach Möglichkeiten, diese nicht zugeordneten Zielfelder zu ignorieren.

Anstatt diese Erweiterungsmethode zu implementieren und zu verwenden, können Sie sie einfach verwenden

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

Jetzt weiß der Automapper, dass er nur überprüfen muss, ob alle Quellfelder zugeordnet sind, aber nicht umgekehrt.

Sie können auch verwenden:

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

Ich habe die Erweiterung von Can Gencer aktualisiert, um keine vorhandenen Karten zu überschreiben.

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

Verwendung:

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

Ich konnte dies folgendermaßen tun:

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

Hinweis: Ich verwende AutoMapper v.2.0.

In Version 5.0.0-beta-1 von AutoMapper wird die ForAllOtherMembersErweiterungsmethode eingeführt, sodass Sie dies jetzt tun können:

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

Beachten Sie, dass die explizite Zuordnung jeder Eigenschaft von Vorteil ist, da Sie niemals Probleme mit der stillschweigenden Zuordnung erhalten, die auftreten, wenn Sie vergessen, eine Eigenschaft zuzuordnen.

In Ihrem Fall ist es möglicherweise ratsam, alle anderen Mitglieder zu ignorieren und ein hinzuzufügen TODO, um zurückzukehren und diese explizit zu machen, nachdem sich die Häufigkeit der Änderungen an dieser Klasse beruhigt hat.

Ab AutoMapper 5.0 ist die .TypeMapEigenschaft on IMappingExpressionweg, was bedeutet, dass die 4.2-Lösung nicht mehr funktioniert. Ich habe eine Lösung erstellt, die die ursprüngliche Funktionalität verwendet, jedoch eine andere Syntax aufweist:

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

Implementierung:

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

Es ist einige Jahre her, seit die Frage gestellt wurde, aber diese Erweiterungsmethode scheint mir mit der aktuellen Version von AutoMapper (3.2.1) sauberer zu sein:

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

Für diejenigen, die die nicht statische API in Version 4.2.0 und höher verwenden, kann die folgende Erweiterungsmethode ( hier in der AutoMapperExtensionsKlasse zu finden) verwendet werden:

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

Das Wichtigste dabei ist, dass nach dem Entfernen der statischen API Code wie Mapper.FindTypeMapFordieser nicht mehr funktioniert, daher die Verwendung des expression.TypeMapFelds.

Für Automapper 5.0, um alle nicht zugeordneten Eigenschaften zu überspringen, müssen Sie nur setzen

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

am Ende Ihres Profils.

Beispielsweise:

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 diesem Fall wird nur das ID-Feld für das Ausgabeobjekt aufgelöst, alle anderen werden übersprungen. Funktioniert wie ein Zauber, anscheinend brauchen wir keine kniffligen Erweiterungen mehr!

Ich habe die Antwort von Robert Schroeder für AutoMapper 4.2 aktualisiert. Bei nicht statischen Mapper-Konfigurationen können wir keine verwenden Mapper.GetAllTypeMaps(), aber das expressionhat einen Verweis auf das Erforderliche 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;
}

Wie möchten Sie festlegen, dass bestimmte Mitglieder ignoriert werden? Gibt es eine Konvention, eine Basisklasse oder ein Attribut, das Sie anwenden möchten? Wenn Sie erst einmal alle Zuordnungen explizit angegeben haben, bin ich mir nicht sicher, welchen Wert AutoMapper für Sie haben würde.

Dies scheint eine alte Frage zu sein, aber ich dachte, ich würde meine Antwort für alle anderen veröffentlichen, die so aussehen wie ich.

Ich benutze ConstructUsing, Objektinitialisierer in Verbindung mit ForAllMembers ignorieren zB

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

Die einzige Information über das Ignorieren vieler Mitglieder ist dieser Thread - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Ich denke, Sie können den in ProvidingCommonBaseClassConfiguration verwendeten Trick verwenden, um allgemeine Eigenschaften für ähnliche Klassen zu ignorieren.
Und es gibt keine Informationen über die Funktion "Den Rest ignorieren". Ich habe mir den Code schon einmal angesehen und es scheint mir sehr und sehr schwierig zu sein, solche Funktionen hinzuzufügen. Sie können auch versuchen, ein Attribut zu verwenden und damit ignorierte Eigenschaften zu markieren und generischen / allgemeinen Code hinzuzufügen, um alle markierten Eigenschaften zu ignorieren.

Ich weiß, dass dies eine alte Frage ist, aber @jmoerdyk in Ihrer Frage:

Wie würden Sie dies in einem verketteten CreateMap () - Ausdruck in einem Profil verwenden?

Sie können diese Antwort wie folgt im Profil ctor verwenden

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

Sie können ForAllMembers verwenden, um dann nur so zu überschreiben

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

Seien Sie vorsichtig, es werden alle ignoriert, und wenn Sie keine benutzerdefinierten Zuordnungen hinzufügen, werden diese bereits ignoriert und funktionieren nicht

Ich möchte auch sagen, ob Sie einen Unit-Test für AutoMapper haben. Und Sie testen, dass alle Modelle mit allen Eigenschaften, die korrekt zugeordnet sind, keine solche Erweiterungsmethode verwenden sollten

Sie sollten explizit ignorieren

Die aktuelle Lösung (Version 9) zum Ignorieren der Eigenschaften, die im Zieltyp nicht vorhanden sind, besteht darin, eine gespiegelte Zuordnung zu erstellen und diese umzukehren:

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

In Version 3.3.1 können Sie einfach IgnoreAllPropertiesWithAnInaccessibleSetter()oder IgnoreAllSourcePropertiesWithAnInaccessibleSetter()Methoden verwenden.