AutoMapper: „Zignorować resztę”?

Czy istnieje sposób, aby powiedzieć AutoMapperowi, aby zignorował wszystkie właściwości oprócz tych, które są jawnie zmapowane?

Mam zewnętrzne klasy DTO, które mogą ulec zmianie z zewnątrz i chcę uniknąć jawnego ignorowania każdej właściwości, ponieważ dodanie nowych właściwości spowoduje uszkodzenie funkcji (spowoduje wyjątki) podczas próby odwzorowania ich na własne obiekty.

Jest to metoda rozszerzenia, którą napisałem, która ignoruje wszystkie nieistniejące właściwości w miejscu docelowym. Nie jestem pewien, czy nadal będzie przydatny, ponieważ pytanie ma więcej niż dwa lata, ale natknąłem się na ten sam problem, ponieważ musiałem dodać wiele ręcznych połączeń Ignoruj.

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

Stosowanie:

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

AKTUALIZACJA : Najwyraźniej to nie działa poprawnie, jeśli masz niestandardowe mapowania, ponieważ je zastępują. Myślę, że to może nadal działać, jeśli najpierw wywołasz IgnoreAllNonExisting, a następnie niestandardowe odwzorowania później.

schdr ma rozwiązanie (jako odpowiedź na to pytanie), które wykorzystuje, Mapper.GetAllTypeMaps()aby dowiedzieć się, które właściwości nie są mapowane i automatycznie je ignorować. Wydaje mi się to bardziej niezawodnym rozwiązaniem.

Z tego, co zrozumiałem, pytanie brzmiało, że w miejscu docelowym znajdują się pola, które nie mają zmapowanego pola w źródle, dlatego szukasz sposobów na zignorowanie tych niezamapowanych pól docelowych.

Zamiast implementować i używać tej metody rozszerzenia, możesz po prostu użyć

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

Teraz automapper wie, że musi tylko sprawdzić, czy wszystkie pola źródłowe są odwzorowane, ale nie na odwrót.

Możesz także użyć:

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

Zaktualizowałem rozszerzenie Can Gencer, aby nie zastępowało żadnych istniejących map.

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

Stosowanie:

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

Udało mi się to zrobić w następujący sposób:

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

Uwaga: używam AutoMapper v.2.0.

Wersja 5.0.0-beta-1 programu AutoMapper wprowadza ForAllOtherMembersmetodę rozszerzenia, dzięki czemu możesz teraz to zrobić:

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

Należy pamiętać, że jawne mapowanie każdej właściwości ma tę zaletę, że nigdy nie wystąpią problemy z cichym niepowodzeniem mapowania, które pojawiają się, gdy zapomnisz o mapowaniu właściwości.

Być może w twoim przypadku rozsądne może być zignorowanie wszystkich innych członków i dodanie TODOznaku „wracaj”, aby wyrazić je wyraźnie po ustaleniu częstotliwości zmian w tej klasie.

Od wersji AutoMapper 5.0 .TypeMapwłaściwość nie IMappingExpressiondziała, co oznacza, że ​​rozwiązanie 4.2 już nie działa. Stworzyłem rozwiązanie, które korzysta z oryginalnej funkcjonalności, ale ma inną składnię:

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

Realizacja:

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

Minęło kilka lat, odkąd pytanie zostało zadane, ale ta metoda rozszerzenia wydaje mi się czystsza, używając bieżącej wersji 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;
}

Dla tych, którzy używają niestatycznego interfejsu API w wersji 4.2.0 i nowszej, można zastosować następującą metodę rozszerzenia (znajdującą się tutaj w AutoMapperExtensionsklasie):

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

Ważną rzeczą jest tutaj to, że po usunięciu statycznego interfejsu API kod taki, jak ten Mapper.FindTypeMapFor, przestanie działać, stąd użycie expression.TypeMappola.

W przypadku programu Automapper 5.0, aby pominąć wszystkie niezapisane właściwości, wystarczy je umieścić

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

na końcu swojego profilu.

Na przykład:

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

W takim przypadku tylko pole Id dla obiektu wyjściowego zostanie rozwiązane, wszystkie pozostałe zostaną pominięte. Działa jak urok, wydaje się, że nie potrzebujemy już żadnych skomplikowanych rozszerzeń!

Zaktualizowałem odpowiedź Roberta Schroedera na AutoMapper 4.2. Przy niestatycznych konfiguracjach mapowania nie możemy użyć Mapper.GetAllTypeMaps(), ale expressionzawiera odniesienie do wymaganych 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;
}

Jak wolisz określić, że niektórzy członkowie będą ignorowani? Czy istnieje konwencja, klasa podstawowa lub atrybut, który chcesz zastosować? Gdy przejdziesz do firmy polegającej na jawnym określaniu wszystkich mapowań, nie jestem pewien, jaką wartość uzyskasz z AutoMappera.

To wydaje się stare pytanie, ale pomyślałem, że opublikuję odpowiedź dla każdego, kto wygląda tak jak ja.

Używam ConstructUsing, inicjator obiektów w połączeniu z ForAllMembers ignoruje np

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

Jedyną informacją o ignorowaniu wielu członków jest ten wątek - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Myślę, że można użyć sztuczki zastosowanej w ProvidingCommonBaseClassConfiguration, aby zignorować wspólne właściwości podobnych klas.
I nie ma żadnych informacji na temat funkcji „Ignoruj ​​resztę”. Przeglądałem już kod i wydaje mi się, że bardzo trudno będzie dodać taką funkcjonalność. Możesz także spróbować użyć jakiegoś atrybutu i oznaczyć go ignorowanymi właściwościami oraz dodać jakiś ogólny / wspólny kod, aby zignorować wszystkie oznaczone właściwości.

Wiem, że to stare pytanie, ale @jmoerdyk w twoim pytaniu:

Jak użyłbyś tego w łańcuchowym wyrażeniu CreateMap () w profilu?

możesz użyć tej odpowiedzi w ten sposób w profilu ctor

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

Możesz użyć ForAllMembers, aby zastąpić tylko potrzebne w ten sposób

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

Bądź ostrożny, zignoruje wszystko, a jeśli nie dodasz niestandardowego mapowania, są one już ignorowane i nie będą działać

również chcę powiedzieć, jeśli masz test jednostkowy dla AutoMapper. I testujesz, że wszystkie modele z poprawnie odwzorowanymi wszystkimi właściwościami nie powinny używać takiej metody rozszerzenia

powinieneś wyraźnie napisać ignoruj

Obecne (wersja 9) rozwiązanie do ignorowania właściwości, które nie istnieją w typie docelowym, polega na utworzeniu odwróconego mapowania i odwróceniu go:

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

W wersji 3.3.1 możesz po prostu używać IgnoreAllPropertiesWithAnInaccessibleSetter()lub IgnoreAllSourcePropertiesWithAnInaccessibleSetter()metod.