AutoMapper: "Zignoruj resztę"?

Zaktualizowałem rozszerzenie Can Gencer, aby nie nadpisywać ż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;
}

Użycie:

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

Z tego, co zrozumiałem, pytanie było takie, że na miejscu docelowym są pola, które nie mają zmapowanego pola w źródle, dlatego szukasz sposobów na zignorowanie tych nie zmapowanych pól docelowych.

Zamiast implementować i używać tej metody rozszerzeń można po prostu użyć

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

Teraz automapper wie, że musi tylko zweryfikować, czy wszystkie pola źródłowe są mapowane, ale nie odwrotnie.

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.

Od AutoMapper 5.0, właściwość .TypeMap na IMappingExpression zniknęła, co oznacza, że rozwiązanie 4.2 nie działa. Stworzyłem rozwiązanie, które wykorzystuje oryginalną funkcjonalność, ale z 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));
    }
}

Wersja 5.0.0-beta-1 Automapp wprowadza metodę rozszerzenia ForAllOtherMembers, więc 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 jest korzystne, ponieważ nigdy nie wystąpią problemy z mapowaniem po cichu, które pojawiają się, gdy zapomnisz mapować właściwość.

Być może w Twoim przypadku byłoby mądrze zignorować wszystkich innych członków i dodać TODO, aby wrócić i wyrazić to wyraźnie po ustąpieniu częstotliwości zmian w tej klasie.

Minęło kilka lat od zadania pytania, ale ta metoda rozszerzenia wydaje mi się czystsza, używając aktualnej 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 API w wersji 4.2.0 i nowszej, można użyć następującej metody rozszerzenia (znalezionej tutaj w klasie AutoMapperExtensions):

// 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żne jest to, że po usunięciu statycznego API kod taki jak Mapper.FindTypeMapFor nie będzie już działał, stąd użycie pola expression.TypeMap.

Dla Automapper 5.0 aby pominąć wszystkie niezapisane właściwości wystarczy umieścić

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

Na końcu twojego 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 tym 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 trudnych rozszerzeń!

Zaktualizowałem odpowiedź Roberta Schroedera na AutoMapper 4.2. W przypadku niestatycznych konfiguracji maperów nie możemy użyć Mapper.GetAllTypeMaps(), ale expression ma odniesienie do wymaganego 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 są ignorowani? Czy istnieje konwencja, klasa bazowa lub atrybut, który chcesz zastosować? Kiedy już zaczniesz wyraźnie określać wszystkie mapowania, nie jestem pewien, jaką wartość uzyskasz z Automappera.

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

Używam ConstructUsing, object initializer sprzężony z forallmembers ignore 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żesz użyć sztuczki używanej w ProvidingCommonBaseClassConfiguration, aby zignorować wspólne właściwości dla podobnych klas.
I nie ma informacji o funkcji "Ignoruj resztę". Patrzyłem już wcześniej na kod i wydaje mi się, że bardzo trudno będzie dodać taką funkcjonalność. Również można spróbuj użyć jakiegoś atrybutu i zaznaczyć ignorowane właściwości i dodać jakiś ogólny / wspólny kod, aby zignorować wszystkie zaznaczone właściwości.

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

Jak można tego użyć w przykutym wyrażeniu CreateMap () W profilu?

Możesz użyć tej odpowiedź w ten sposób wewnątrz profilu ctor

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

Możesz użyć ForAllMembers, niż zastąpić tylko potrzebne like this

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 wszystkie, 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 Automapp. I testujesz, że wszystkie modele ze wszystkimi właściwościami odwzorowanymi poprawnie nie powinieneś używać takiej metody rozszerzenia

Powinieneś napisać jawnie ignoruj

W wersji 3.3.1 można po prostu użyć metod IgnoreAllPropertiesWithAnInaccessibleSetter() LUB IgnoreAllSourcePropertiesWithAnInaccessibleSetter().