AutoMapper:“ ละเว้นส่วนที่เหลือ” หรือไม่

มีวิธีบอก AutoMapper ให้ละเว้นคุณสมบัติทั้งหมดยกเว้นคุณสมบัติที่แมปอย่างชัดเจนหรือไม่

ฉันมีคลาส DTO ภายนอกซึ่งมีแนวโน้มที่จะเปลี่ยนจากภายนอกและฉันต้องการหลีกเลี่ยงการระบุคุณสมบัติแต่ละรายการให้ถูกละเว้นอย่างชัดเจนเนื่องจากการเพิ่มคุณสมบัติใหม่จะทำให้ฟังก์ชันการทำงาน (ทำให้เกิดข้อยกเว้น) เมื่อพยายามแมปเข้ากับวัตถุของฉันเอง

นี่เป็นวิธีส่วนขยายที่ฉันเขียนซึ่งไม่สนใจคุณสมบัติที่ไม่มีอยู่ทั้งหมดบนปลายทาง ไม่แน่ใจว่ามันจะยังคงมีประโยชน์เพราะคำถามมีอายุมากกว่าสองปี แต่ฉันพบปัญหาเดียวกันกับที่ต้องเพิ่มการละเว้นการโทรด้วยตนเองจำนวนมาก

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

การใช้งาน:

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

อัปเดต : เห็นได้ชัดว่านี่ไม่ทำงานอย่างถูกต้องหากคุณมีการแมปที่กำหนดเองเพราะมันเขียนทับพวกเขา ฉันเดาว่ามันยังสามารถใช้งานได้ถ้าโทร IgnoreAllNonExisting ก่อนจากนั้นจึงทำการแมปที่กำหนดเองในภายหลัง

schdr มีวิธีแก้ปัญหา (เป็นคำตอบสำหรับคำถามนี้) ซึ่งใช้Mapper.GetAllTypeMaps()เพื่อค้นหาว่าคุณสมบัติใดที่ไม่ได้ถูกแมป ดูเหมือนจะเป็นทางออกที่แข็งแกร่งสำหรับฉัน

จากสิ่งที่ฉันเข้าใจคำถามก็คือมีเขตข้อมูลบนปลายทางซึ่งไม่มีเขตข้อมูลที่แมปในแหล่งที่มาซึ่งเป็นสาเหตุที่คุณกำลังมองหาวิธีที่จะละเว้นเขตข้อมูลปลายทางที่ไม่ได้แมป

แทนที่จะใช้และใช้วิธีการขยายเหล่านี้คุณก็สามารถใช้

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

ตอนนี้ automapper รู้ว่ามันจะต้องตรวจสอบเท่านั้นว่าเขตข้อมูลที่มาทั้งหมดจะถูกแมป แต่ไม่ใช่วิธีอื่น ๆ

คุณยังสามารถใช้:

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

ฉันได้อัปเดตส่วนขยายของ Can Gencer เพื่อไม่เขียนทับแผนที่ที่มีอยู่

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

การใช้งาน:

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

ฉันสามารถทำสิ่งนี้ด้วยวิธีต่อไปนี้:

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

หมายเหตุ: ฉันใช้ AutoMapper v.2.0

AutoMapper เวอร์ชัน 5.0.0-beta-1 แนะนำForAllOtherMembersวิธีการขยายดังนั้นตอนนี้คุณสามารถทำได้:

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

โปรดทราบว่ามีข้อได้เปรียบในการทำแผนที่แต่ละคุณสมบัติอย่างชัดเจนเนื่องจากคุณจะไม่ได้รับปัญหาของการทำแผนที่ความล้มเหลวอย่างเงียบ ๆ ที่เกิดขึ้นเมื่อคุณลืมที่จะทำแผนที่คุณสมบัติ

บางทีในกรณีของคุณอาจเป็นการดีที่จะไม่สนใจสมาชิกคนอื่น ๆ ทั้งหมดและเพิ่ม a TODOเพื่อกลับมาทำอย่างชัดเจนหลังจากความถี่ของการเปลี่ยนแปลงในชั้นเรียนนี้สงบลง

ในฐานะของ AutoMapper 5.0 .TypeMapคุณสมบัติที่IMappingExpressionหายไปหมายถึงโซลูชัน 4.2 ไม่ทำงานอีกต่อไป ฉันได้สร้างโซลูชันที่ใช้ฟังก์ชั่นดั้งเดิม แต่มีไวยากรณ์แตกต่างกัน:

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

การดำเนินงาน:

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

ไม่กี่ปีที่ผ่านมาตั้งแต่คำถามถูกถาม แต่วิธีการขยายนี้ดูสะอาดสำหรับฉันโดยใช้ 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;
}

สำหรับผู้ที่ใช้API ที่ไม่คงที่ในรุ่น 4.2.0 และสูงกว่าสามารถใช้วิธีการต่อไปนี้ (พบได้ที่นี่ใน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;
}

สิ่งสำคัญคือเมื่อสแตติก API ถูกลบแล้วโค้ดเช่นMapper.FindTypeMapForจะไม่ทำงานอีกต่อไปดังนั้นการใช้expression.TypeMapฟิลด์

สำหรับ Automapper 5.0 เพื่อข้ามคุณสมบัติที่ไม่ได้แมปทั้งหมดที่คุณต้องการ

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

ในตอนท้ายของโปรไฟล์ของคุณ

ตัวอย่างเช่น:

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

ในกรณีนี้เฉพาะฟิลด์ Id สำหรับวัตถุที่ส่งออกจะได้รับการแก้ไขอื่น ๆ ทั้งหมดจะถูกข้าม ทำงานเหมือนมีเสน่ห์ดูเหมือนว่าเราไม่ต้องการส่วนขยายที่ยุ่งยากอีกต่อไป!

ฉันได้อัปเดตคำตอบของ Robert Schroeder สำหรับ AutoMapper 4.2 ด้วยการกำหนดค่า mapper แบบคงที่เราไม่สามารถใช้Mapper.GetAllTypeMaps()แต่expressionมีการอ้างอิงถึงสิ่งที่ต้องการ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;
}

คุณต้องการระบุให้สมาชิกบางคนถูกเพิกเฉยอย่างไร มีการประชุมหรือคลาสพื้นฐานหรือแอตทริบิวต์ที่คุณต้องการสมัครหรือไม่? เมื่อคุณเข้าสู่ธุรกิจของการระบุการแมปทั้งหมดอย่างชัดเจนแล้วฉันไม่แน่ใจว่ามูลค่าที่คุณจะได้รับจาก AutoMapper

นี่ดูเหมือนเป็นคำถามเก่า แต่คิดว่าฉันจะโพสต์คำตอบสำหรับคนอื่นที่ดูเหมือนว่าฉันเป็น

ฉันใช้ ConstructU การใช้วัตถุเริ่มต้นพร้อมกับ ForAllMembers ละเว้นเช่น

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

กลุ่มข้อมูลข่าวสารเพียงประมาณละเลยสมาชิกหลายคนเป็นหัวข้อนี้ - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f ฉันคิดว่าคุณสามารถใช้เคล็ดลับที่ใช้ใน ProvidingCommonBaseClassConfiguration เพื่อละเว้นคุณสมบัติทั่วไปสำหรับคลาสที่คล้ายกัน
และไม่มีข้อมูลเกี่ยวกับฟังก์ชัน "ละเว้นส่วนที่เหลือ" ฉันเคยดูโค้ดมาก่อนและดูเหมือนว่าสำหรับฉันจะเพิ่มฟังก์ชั่นดังกล่าวได้ยากมาก นอกจากนี้คุณสามารถลองใช้แอททริบิวและทำเครื่องหมายด้วยมันละเว้นคุณสมบัติและเพิ่มรหัสทั่วไป / ทั่วไปเพื่อละเว้นคุณสมบัติที่ทำเครื่องหมายไว้ทั้งหมด

ฉันรู้ว่านี่เป็นคำถามเก่า แต่ @jmoerdyk ในคำถามของคุณ:

คุณจะใช้มันอย่างไรในนิพจน์ CreateMap () ที่ถูกล่ามโซ่ในโปรไฟล์?

คุณสามารถใช้คำตอบนี้เช่นนี้ภายใน ctor รายละเอียด

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

คุณสามารถใช้ ForAllMembers ได้แทนที่จะเขียนทับแบบนี้เท่านั้น

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

ระวังมันจะไม่สนใจทั้งหมดและถ้าคุณจะไม่เพิ่มการแมปที่กำหนดเองพวกเขาจะถูกละเว้นแล้วและจะไม่ทำงาน

นอกจากนี้ฉันอยากจะบอกว่าถ้าคุณมีการทดสอบหน่วยสำหรับ AutoMapper และคุณทดสอบว่าทุกรุ่นที่มีการแมปคุณสมบัติทั้งหมดอย่างถูกต้องคุณไม่ควรใช้วิธีการขยายดังกล่าว

คุณควรเขียนความไม่สนใจอย่างชัดเจน

โซลูชันปัจจุบัน (เวอร์ชัน 9) สำหรับการเพิกเฉยต่อคุณสมบัติที่ไม่มีอยู่ในประเภทปลายทางคือการสร้างการแมปแบบพลิกแล้วย้อนกลับ:

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

ในเวอร์ชั่น 3.3.1 คุณสามารถใช้IgnoreAllPropertiesWithAnInaccessibleSetter()หรือIgnoreAllSourcePropertiesWithAnInaccessibleSetter()วิธีการ