AutoMapper: "Abaikan sisanya"?

Apakah ada cara untuk memberitahu AutoMapper untuk mengabaikan semua properti kecuali yang dipetakan secara eksplisit?

Saya memiliki kelas DTO eksternal yang cenderung berubah dari luar dan saya ingin menghindari menentukan masing-masing properti untuk diabaikan secara eksplisit, karena menambahkan properti baru akan merusak fungsionalitas (menyebabkan pengecualian) ketika mencoba memetakannya ke objek saya sendiri.

Ini adalah metode ekstensi yang saya tulis yang mengabaikan semua properti yang tidak ada di tujuan. Tidak yakin apakah masih akan berguna karena pertanyaannya sudah lebih dari dua tahun, tetapi saya mengalami masalah yang sama karena harus menambahkan banyak panggilan Abaikan manual.

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

Pemakaian:

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

UPDATE : Rupanya ini tidak berfungsi dengan benar jika Anda memiliki pemetaan khusus karena menimpa mereka. Saya kira itu masih bisa berfungsi jika panggilan IgnoreAllNonExisting dulu dan kemudian pemetaan kustom nanti.

schdr memiliki solusi (sebagai jawaban untuk pertanyaan ini) yang digunakan Mapper.GetAllTypeMaps()untuk mengetahui properti mana yang belum dipetakan dan mengabaikannya secara otomatis. Sepertinya solusi yang lebih kuat bagi saya.

Dari apa yang saya pahami pertanyaannya adalah bahwa ada bidang di tujuan yang tidak memiliki bidang yang dipetakan di sumbernya, itulah sebabnya Anda mencari cara untuk Mengabaikan bidang tujuan yang tidak dipetakan.

Alih-alih menerapkan dan menggunakan metode ekstensi ini, Anda cukup menggunakan

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

Sekarang automapper tahu bahwa itu hanya perlu memvalidasi bahwa semua bidang sumber dipetakan tetapi tidak sebaliknya.

Anda juga bisa menggunakan:

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

Saya telah memperbarui ekstensi Can Gencer untuk tidak menimpa peta yang ada.

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

Pemakaian:

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

Saya sudah bisa melakukan ini dengan cara berikut:

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

Catatan: Saya menggunakan AutoMapper v.2.0.

Versi 5.0.0-beta-1 dari AutoMapper memperkenalkan ForAllOtherMembersmetode ekstensi sehingga Anda sekarang dapat melakukan ini:

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

Ketahuilah bahwa ada keuntungan untuk memetakan secara eksplisit setiap properti karena Anda tidak akan pernah mendapatkan masalah pemetaan gagal secara diam-diam yang timbul ketika Anda lupa memetakan properti.

Mungkin dalam kasus Anda mungkin bijaksana untuk mengabaikan semua anggota lain dan menambahkan TODOuntuk kembali dan membuat ini eksplisit setelah frekuensi perubahan pada kelas ini diselesaikan.

Pada AutoMapper 5.0, .TypeMapproperti on IMappingExpressionsudah tidak ada, artinya solusi 4.2 tidak lagi berfungsi. Saya telah membuat solusi yang menggunakan fungsi asli tetapi dengan sintaks yang berbeda:

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

Penerapan:

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

Sudah ada beberapa tahun sejak pertanyaan diajukan, tetapi metode ekstensi ini tampak lebih bersih bagi saya, menggunakan versi AutoMapper saat ini (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;
}

Bagi mereka yang menggunakan API non-statis di versi 4.2.0 dan di atas, metode ekstensi berikut (ditemukan di sini di AutoMapperExtensionskelas) dapat digunakan:

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

Yang penting di sini adalah bahwa begitu API statis dihapus, kode seperti Mapper.FindTypeMapForitu tidak akan berfungsi lagi, maka penggunaan expression.TypeMapbidang tersebut.

Untuk Automapper 5.0 untuk melewati semua properti yang belum dipetakan, Anda hanya perlu memasukkannya

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

di akhir profil Anda.

Sebagai contoh:

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

Dalam hal ini hanya bidang Id untuk objek output yang akan diselesaikan, semua yang lain akan dilewati. Bekerja seperti pesona, sepertinya kita tidak membutuhkan ekstensi rumit lagi!

Saya telah memperbarui jawaban Robert Schroeder untuk AutoMapper 4.2. Dengan konfigurasi mapper non-statis, kita tidak dapat menggunakan Mapper.GetAllTypeMaps(), tetapi expressionmemiliki referensi ke yang diperlukan 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;
}

Bagaimana Anda lebih suka menentukan bahwa anggota tertentu diabaikan? Apakah ada konvensi, atau kelas dasar, atau atribut yang ingin Anda terapkan? Setelah Anda masuk ke bisnis menentukan semua pemetaan secara eksplisit, saya tidak yakin nilai apa yang akan Anda dapatkan dari AutoMapper.

Ini sepertinya pertanyaan lama tetapi saya pikir saya akan memposting jawaban saya untuk orang lain yang terlihat seperti saya.

Saya menggunakan ConstructUsing, penginisialisasi objek ditambah dengan ForAllMembers abaikan misalnya

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

Satu-satunya informasi tentang mengabaikan banyak anggota adalah utas ini - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Saya pikir Anda dapat menggunakan trik yang digunakan dalam ProvidingCommonBaseClassConfiguration untuk mengabaikan properti umum untuk kelas yang sama.
Dan tidak ada informasi tentang fungsi "Abaikan sisanya". Saya telah melihat kode sebelumnya dan menurut saya akan sangat dan sangat sulit untuk menambahkan fungsionalitas tersebut. Anda juga dapat mencoba menggunakan beberapa atribut dan menandainya dengan properti yang diabaikan dan menambahkan beberapa kode umum / umum untuk mengabaikan semua properti yang ditandai.

Saya tahu ini adalah pertanyaan lama, tetapi @jmoerdyk dalam pertanyaan Anda:

Bagaimana Anda menggunakan ini dalam ekspresi CreateMap () berantai dalam Profil?

Anda dapat menggunakan jawaban ini seperti ini di dalam profil Ctor

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

Anda dapat menggunakan ForAllMembers, daripada hanya menimpa yang diperlukan seperti ini

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

Hati-hati, itu akan mengabaikan semua, dan jika Anda tidak akan menambahkan pemetaan khusus, mereka sudah diabaikan dan tidak akan berfungsi

juga, saya ingin mengatakan, jika Anda memiliki unit test untuk AutoMapper. Dan Anda menguji bahwa semua model dengan semua properti dipetakan dengan benar, Anda seharusnya tidak menggunakan metode ekstensi tersebut

Anda harus menulis abaikan secara eksplisit

Solusi saat ini (versi 9) untuk mengabaikan properti yang tidak ada di tipe tujuan adalah membuat pemetaan terbalik dan membalikkannya:

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

Dalam versi 3.3.1 Anda cukup menggunakan IgnoreAllPropertiesWithAnInaccessibleSetter()atau IgnoreAllSourcePropertiesWithAnInaccessibleSetter()metode.