AutoMapper: “Kalanı yoksay” mı?

AutoMapper'a açıkça eşlenenler dışındaki tüm özellikleri yok saymasını söylemenin bir yolu var mı?

Dışarıdan değişmesi muhtemel dış DTO sınıfları var ve yeni özellikler ekleyerek kendi nesneleri içine eşlemeye çalışırken işlevselliği (istisnalara neden) kıracak çünkü açıkça, her özellik belirtilmesini önlemek istiyorum.

Bu, hedefte var olmayan tüm özellikleri yok sayan bir uzantı yöntemidir. Sorunun iki yıldan daha eski olduğu için hala yararlı olup olmayacağından emin değilim, ancak aynı sorunu çok sayıda manuel Yoksay çağrısı eklemek zorunda kaldım.

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

Kullanımı:

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

GÜNCELLEME : Görünüşe göre, bunların üzerine yazdığı için özel eşlemeleriniz varsa doğru şekilde çalışmaz. Önce IgnoreAllNonExisting ve daha sonra özel eşlemeler çağırırsanız yine de işe yarayabilir sanırım.

schdr, Mapper.GetAllTypeMaps()hangi özelliklerin eşlenmemiş olduğunu bulmak ve bunları otomatik olarak yoksaymak için kullanılan bir çözüme (bu sorunun cevabı olarak) sahiptir . Bana daha sağlam bir çözüm gibi görünüyor.

Soruyu anladığım kadarıyla, hedefte kaynakta eşlenmiş bir alanı olmayan alanlar olduğu, bu yüzden bu eşlenmemiş hedef alanlarını yoksaymanın yollarını aradığınız oldu.

Bu uzantı yöntemini uygulamak ve kullanmak yerine,

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

Artık otomatikleştirici, yalnızca tüm kaynak alanlarının eşlendiğini doğrulamak gerektiğini biliyor, ancak bunun tersi değil.

Ayrıca kullanabilirsiniz:

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

Can Gencer'in uzantısını mevcut haritaların üzerine yazmayacak şekilde güncelledim.

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

Kullanımı:

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

Bunu şu şekilde yapabildim:

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

Not: AutoMapper v.2.0 kullanıyorum.

AutoMapper'ın 5.0.0-beta-1 sürümü ForAllOtherMembers, şimdi bunu yapabilmeniz için uzantı yöntemini sunar:

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

Bir mülkü eşlemeyi unuttuğunuzda ortaya çıkan sessizce haritalama sorunlarıyla karşılaşmayacağınız için, her mülkü açıkça eşlemenin bir avantajı olduğunu unutmayın.

Belki de sizin durumunuzda, diğer tüm üyeleri görmezden TODOgelmek ve geri gelmek için bir ek eklemek akıllıca olabilir ve bu sınıftaki değişikliklerin sıklığı yerleştikten sonra bunları açık bir şekilde ortaya koyabilirsiniz.

AutoMapper 5.0'dan itibaren, .TypeMapözellik kaldırıldı IMappingExpression, yani 4.2 çözümü artık çalışmıyor. Orijinal işlevselliği kullanan ancak farklı bir sözdizimiyle bir çözüm oluşturdum:

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

Uygulama:

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

Sorunun sorulmasından bu yana birkaç yıl geçti, ancak bu uzantı yöntemi AutoMapper'in (3.2.1) geçerli sürümünü kullanarak bana daha temiz görünüyor:

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

Kullandığınız olanlar için statik olmayan API , yukarıdaki (bulunan aşağıdaki uzatma yöntemi sürümü 4.2.0 ve burada yer AutoMapperExtensionskullanılabilir sınıfına):

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

Burada önemli olan, statik API kaldırıldıktan sonra, kodun Mapper.FindTypeMapForartık çalışmaz olması, dolayısıyla expression.TypeMapalanın kullanılmasıdır.

Automapper 5.0 için tüm eşlenmemiş özellikleri atlamak için tek yapmanız gereken

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

profilinizin sonunda.

Örneğin:

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

Bu durumda, yalnızca çıktı nesnesi için Kimlik alanı çözülür ve diğer tüm alan atlanır. Bir cazibe gibi çalışıyor, artık zor uzantılara ihtiyacımız yok gibi görünüyor!

Robert Schroeder'in AutoMapper 4.2 yanıtını güncelledim. Statik olmayan eşleyici yapılandırmalarıyla kullanamayız Mapper.GetAllTypeMaps(), ancak expressiongerekli olanlara bir referansı vardır 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;
}

Belirli üyelerin yok sayılmasını nasıl belirlersiniz? Uygulamak istediğiniz bir kongre, temel sınıf veya özellik var mı? Tüm eşlemeleri açıkça belirleme işine girdikten sonra, AutoMapper'dan hangi değeri alacağınızdan emin değilim.

Bu eski bir soru gibi görünüyor ama cevabımı sanki başka biri için göndereceğimi düşündüm.

ConstructUsing, ForAllMembers ile birleştiğinde nesne başlatıcısı yoksay örn.

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

Üyelerin çoğunu görmezden gelmeyle ilgili tek bilgi bu konudur - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Benzer sınıflar için ortak özellikleri yok saymak için ProvidingCommonBaseClassConfiguration kullanılan hile kullanabilirsiniz düşünüyorum.
Ve "Kalanı yoksay" işlevi hakkında bilgi yoktur. Daha önce koda baktım ve bana böyle bir işlevsellik eklemek çok ve çok zor olacak gibi görünüyor. Ayrıca, bazı öznitelikleri kullanmayı ve yok sayılan özelliklerle işaretlemeyi ve tüm işaretli özellikleri yok saymak için genel / ortak kod eklemeyi deneyebilirsiniz.

Bunun eski bir soru olduğunu biliyorum, ama sorunuzda @jmoerdyk:

Bunu bir Profildeki zincirlenmiş CreateMap () ifadesinde nasıl kullanırsınız?

bu yanıtı Profil sepetinde bu şekilde kullanabilirsiniz

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

Sadece böyle gerekli olanların üzerine yazmak yerine ForAllMembers kullanabilirsiniz.

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

Dikkatli olun, hepsini yok sayar ve özel eşleme eklemezseniz, zaten yok sayılır ve çalışmaz

Ayrıca, AutoMapper için birim testiniz varsa, söylemek istiyorum. Ve tüm özelliklere sahip tüm modellerin doğru şekilde eşlendiğini test edersiniz, böyle bir uzantı yöntemi kullanmamalısınız

görmezden gelmelisin

Hedef türünde bulunmayan özellikleri yok saymak için geçerli (sürüm 9) çözüm, döndürülmüş bir eşleme oluşturmak ve tersine çevirmektir:

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

3.3.1 sürümünde IgnoreAllPropertiesWithAnInaccessibleSetter()veya IgnoreAllSourcePropertiesWithAnInaccessibleSetter()yöntemlerini kullanabilirsiniz .