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

Тепер автомат знає, що йому потрібно лише перевірити, що всі вихідні поля відображаються, але не навпаки.

Ви також можете використовувати:

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.

Версія 5.0.0-beta-1 програми AutoMapper представляє 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 для вихідного об'єкта, всі інші будуть пропущені. Діє як шарм, здається, нам вже не потрібні хитрі розширення!

Я оновив відповідь Роберта Шредера для AutoMapper 4.2. З нестатичними конфігураціями картографів ми не можемо користуватися 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 () у профілі?

Ви можете використовувати цю відповідь, як це всередині 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()методи.