AutoMapper: "Ignoriere den Rest"?

Dies ist eine Erweiterung Methode, die ich schrieb, ignoriert alle nicht vorhandenen Eigenschaften, die auf das Ziel. Nicht sicher, ob es immer noch sinnvoll sein, die Frage ist mehr als zwei Jahre alt, aber ich lief in das gleiche Problem dass Sie eine Menge von manuellen Ignorieren Anrufe.

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 das nicht richtig, wenn Sie benutzerdefinierte Zuordnungen, weil er überschreibt diese. Ich denke es könnte immer noch funktionieren, falls der Anruf IgnoreAllNonExisting zuerst und dann die benutzerdefinierten Zuordnungen später.

schdr eine Lösung hat (als eine Antwort auf diese Frage), die verwendet Mapper.GetAllTypeMaps() um herauszufinden, welche Eigenschaften sind unsichtbar und automatisch ignorieren. Scheint wie eine robuste Lösung für mich.

InformationsquelleAutor der Antwort Can Gencer

Von dem, was ich verstanden, die Frage war, gibt es Felder, auf das Ziel, das nicht über ein zugeordnetes Feld in der Quelle, die ist, warum Sie sind Suche für Möglichkeiten zu Ignorieren diejenigen, die nicht zugeordneten Ziel-Felder.

Statt der Umsetzung und Anwendung dieser Methode die Sie könnte verwenden Sie einfach

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

Nun die automapper weiß, dass es muss nur überprüfen, dass alle Quell-Felder zugeordnet werden, aber nicht die andere Weise herum.

InformationsquelleAutor der Antwort Nazim Hafeez

Als der AutoMapper 5.0, die .TypeMap Eigenschaft auf IMappingExpression ist Weg, was bedeutet, der 4,2-Lösung nicht mehr funktioniert. Ich habe eine Lösung, die über die ursprüngliche Funktionalität, aber mit einer anderen syntax:

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

Umsetzung:

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

InformationsquelleAutor der Antwort Richard

Es ist schon ein paar Jahre her, seit die Frage gestellt wurde, aber diese Methode scheint sauberer zu mir, mit der aktuellen version von 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;
}

InformationsquelleAutor der Antwort Iravanchi

Für Automapper 5.0, um zu überspringen, alle nicht zugeordneten Eigenschaften, die Sie gerade brauchen, setzen

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

am Ende Ihres Profils.

Beispiel:

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 nur die Id-Feld für die Ausgabe-Objekt wird aufgelöst, alle anderen werden übersprungen. Funktioniert wie ein Charme, scheint, wir brauchen keine trickreiche Erweiterungen mehr!

InformationsquelleAutor der Antwort framerelay

Wie möchten Sie festlegen, dass bestimmte Mitglieder ignoriert? Gibt es eine Konvention, oder die Basis-Klasse oder Attribut, das Sie bewerben möchten? Sobald Sie in das Geschäft der Angabe aller Zuordnungen ausdrücklich, ich bin nicht sicher, was Wert, den Sie bekommen würde, aus AutoMapper.

InformationsquelleAutor der Antwort Jimmy Bogard

Nur Informationen über das ignorieren viele Mitglieder ist dieser thread - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Ich denke, Sie können den trick in ProvidingCommonBaseClassConfiguration zu ignorieren, gemeinsame Eigenschaften für ähnliche Klassen.

Und es gibt keine Informationen über die "Ignorieren" - Funktion. Ich habe den code vor, und es scheint mir, dass wird sehr, sehr schwer solch eine Funktionalität. Sie können auch versuchen, einige Attribut, mark und es ignoriert, Eigenschaften und fügen Sie einige generische/common code ignorieren alle markierten Eigenschaften.

InformationsquelleAutor der Antwort zihotki

Ich weiß, das ist eine alte Frage, aber @jmoerdyk
Ihre Frage:

Wie würden Sie diese in einer verketteten CreateMap () - Ausdruck in ein Profil?

können Sie diese Antwort wie dies im Profil ctor

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

InformationsquelleAutor der Antwort j.loucao.silva