AutoMapper: "Ignorer le reste"?

Existe-t-il un moyen de dire à AutoMapper d'ignorer toutes les propriétés à l'exception de celles qui sont mappées explicitement?

J'ai des classes DTO externes qui sont susceptibles de changer de l'extérieur et je veux éviter de spécifier explicitement chaque propriété à ignorer, car l'ajout de nouvelles propriétés cassera la fonctionnalité (provoquera des exceptions) lors de la tentative de les mapper dans mes propres objets.

Il s'agit d'une méthode d'extension que j'ai écrite qui ignore toutes les propriétés non existantes sur la destination. Je ne sais pas si cela sera toujours utile car la question a plus de deux ans, mais j'ai rencontré le même problème en ajoutant beaucoup d'appels manuels Ignore.

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

Usage:

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

MISE À JOUR : Apparemment, cela ne fonctionne pas correctement si vous avez des mappages personnalisés car ils les écrasent. Je suppose que cela pourrait encore fonctionner si appelez d'abord IgnoreAllNonExisting puis les mappages personnalisés plus tard.

schdr a une solution (comme réponse à cette question) qui utilise Mapper.GetAllTypeMaps()pour découvrir quelles propriétés ne sont pas mappées et les ignorer automatiquement. Cela me semble être une solution plus robuste.

D'après ce que j'ai compris, la question était qu'il y a des champs sur la destination qui n'ont pas de champ mappé dans la source, c'est pourquoi vous cherchez des moyens d'ignorer ces champs de destination non mappés.

Au lieu d'implémenter et d'utiliser ces méthodes d'extension, vous pouvez simplement utiliser

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

Maintenant, l'automappeur sait qu'il n'a qu'à valider que tous les champs source sont mappés mais pas l'inverse.

Vous pouvez aussi utiliser:

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

J'ai mis à jour l'extension Can Gencer pour ne pas écraser les cartes existantes.

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

Usage:

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

J'ai pu le faire de la manière suivante:

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

Remarque: j'utilise AutoMapper v.2.0.

La version 5.0.0-beta-1 d'AutoMapper introduit la ForAllOtherMembersméthode d'extension afin que vous puissiez maintenant le faire:

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

Sachez qu'il existe un avantage à mapper explicitement chaque propriété, car vous n'aurez jamais de problèmes de mappage échouant silencieusement qui surviennent lorsque vous oubliez de mapper une propriété.

Dans votre cas, il serait peut-être sage d'ignorer tous les autres membres et d'ajouter un TODOpour revenir et les rendre explicites une fois la fréquence des changements apportés à cette classe établie.

Depuis AutoMapper 5.0, la .TypeMappropriété on a IMappingExpressiondisparu, ce qui signifie que la solution 4.2 ne fonctionne plus. J'ai créé une solution qui utilise la fonctionnalité d'origine mais avec une syntaxe différente:

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

La mise en oeuvre:

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

Il y a quelques années que la question a été posée, mais cette méthode d'extension me semble plus propre, en utilisant la version actuelle d'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;
}

Pour ceux qui utilisent l' API non statique dans les versions 4.2.0 et supérieures, la méthode d'extension suivante (trouvée ici dans la AutoMapperExtensionsclasse) peut être utilisée:

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

L'important ici est qu'une fois l'API statique supprimée, le code tel que Mapper.FindTypeMapForne fonctionnera plus, d'où l'utilisation du expression.TypeMapchamp.

Pour Automapper 5.0 afin d'ignorer toutes les propriétés non mappées dont vous avez juste besoin

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

à la fin de votre profil.

Par exemple:

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

Dans ce cas, seul le champ Id pour l'objet de sortie sera résolu, tous les autres seront ignorés. Fonctionne comme un charme, il semble que nous n'ayons plus besoin d'extensions délicates!

J'ai mis à jour la réponse de Robert Schroeder pour AutoMapper 4.2. Avec les configurations de mappeur non statiques, nous ne pouvons pas utiliser Mapper.GetAllTypeMaps(), mais le expressionfait référence au requis 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;
}

Comment préférez-vous spécifier que certains membres soient ignorés? Y a-t-il une convention, une classe de base ou un attribut que vous aimeriez appliquer? Une fois que vous vous êtes lancé dans la spécification explicite de tous les mappages, je ne sais pas quelle valeur vous obtiendriez d'AutoMapper.

Cela semble être une vieille question, mais j'ai pensé publier ma réponse pour toute autre personne qui ressemblerait à moi.

J'utilise ConstructUsing, l'initialiseur d'objet couplé à ForAllMembers ignore par exemple

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

La seule infraction concernant l'ignorance de nombreux membres est ce fil - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Je pense que vous pouvez utiliser l'astuce utilisée dans ProvidingCommonBaseClassConfiguration pour ignorer les propriétés communes de classes similaires.
Et il n'y a aucune information sur la fonctionnalité "Ignorer le reste". J'ai déjà regardé le code et il me semble qu'il sera très et très difficile d'ajouter une telle fonctionnalité. Vous pouvez également essayer d'utiliser un attribut et marquer avec lui les propriétés ignorées et ajouter du code générique / commun pour ignorer toutes les propriétés marquées.

Je sais que c'est une vieille question, mais @jmoerdyk dans votre question:

Comment utiliseriez-vous cela dans une expression CreateMap () chaînée dans un profil?

vous pouvez utiliser cette réponse comme ceci dans le profil ctor

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

Vous pouvez utiliser ForAllMembers, que remplacer uniquement nécessaire comme ceci

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

Attention, il ignorera tout, et si vous n'ajoutez pas de mappage personnalisé, ils sont déjà ignorés et ne fonctionneront pas

aussi, je veux dire, si vous avez un test unitaire pour AutoMapper. Et vous testez que tous les modèles avec toutes les propriétés mappées correctement, vous ne devez pas utiliser une telle méthode d'extension

vous devez écrire explicitement ignorer

La solution actuelle (version 9) pour ignorer les propriétés qui n'existent pas dans le type de destination consiste à créer un mappage inversé et à l'inverser:

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

Dans la version 3.3.1, vous pouvez simplement utiliser les méthodes IgnoreAllPropertiesWithAnInaccessibleSetter()ou IgnoreAllSourcePropertiesWithAnInaccessibleSetter().