AutoMapper：「残りを無視する」？

AutoMapperに、明示的にマップされているものを除くすべてのプロパティを無視するように指示する方法はありますか？

外部から変更される可能性のある外部DTOクラスがあり、各プロパティを明示的に無視するように指定しないようにします。新しいプロパティを追加すると、自分のオブジェクトにマップしようとすると機能（例外の原因）が機能しなくなるためです。

これは私が書いた拡張メソッドで、宛先に存在しないすべてのプロパティを無視します。質問が2年以上前のものであるため、それがまだ役立つかどうかはわかりませんが、同じ問題に遭遇し、手動で無視する呼び出しをたくさん追加する必要がありました。

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

これで、オートマッパーは、すべてのソースフィールドがマップされていることを検証するだけでよく、その逆は不要であることを認識しています。

次のものも使用できます。

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以降、.TypeMaponプロパティ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;
}

バージョン4.2.0以降で非静的APIを使用している場合は、次の拡張メソッド（ここでは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フィールドのみが解決され、その他はすべてスキップされます。魅力のように機能します。トリッキーな拡張機能はもう必要ないようです。

AutoMapper 4.2に対するRobert Schroederの回答を更新しました。非静的マッパー構成では、を使用できません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からどのような値が得られるかわかりません。

これは古い質問のようですが、私と同じように見える他の人のために私の回答を投稿しようと思いました。

私は、ConstructUsing、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（）式でどのように使用しますか？

あなたはこのような答えをプロフィールの中で使うことができます

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()メソッドを使用するだけです。