AutoMapper: Bỏ qua phần còn lại?

Có cách nào để yêu cầu AutoMapper bỏ qua tất cả các thuộc tính ngoại trừ các thuộc tính được ánh xạ rõ ràng không?

Tôi có các lớp DTO bên ngoài có khả năng thay đổi từ bên ngoài và tôi muốn tránh chỉ định rõ ràng từng thuộc tính bị bỏ qua, vì việc thêm các thuộc tính mới sẽ phá vỡ chức năng (gây ra ngoại lệ) khi cố gắng ánh xạ chúng vào các đối tượng của riêng tôi.

Đây là một phương pháp mở rộng mà tôi đã viết mà bỏ qua tất cả các thuộc tính không tồn tại trên đích. Không chắc nó có còn hữu ích không vì câu hỏi đã hơn hai năm tuổi, nhưng tôi gặp phải vấn đề tương tự khi phải thêm rất nhiều cuộc gọi Bỏ qua thủ công.

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

Sử dụng:

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

CẬP NHẬT : Rõ ràng điều này không hoạt động chính xác nếu bạn có ánh xạ tùy chỉnh vì nó ghi đè lên chúng. Tôi đoán nó vẫn có thể hoạt động nếu gọi Ignore ALLNonEx hiện trước và sau đó là ánh xạ tùy chỉnh sau.

schdr có một giải pháp (như một câu trả lời cho câu hỏi này) sử dụng Mapper.GetAllTypeMaps()để tìm ra các thuộc tính nào không được ánh xạ và tự động bỏ qua chúng. Có vẻ như một giải pháp mạnh mẽ hơn đối với tôi.

Từ những gì tôi hiểu câu hỏi là có các trường trên đích không có trường được ánh xạ trong nguồn, đó là lý do tại sao bạn đang tìm cách bỏ qua các trường đích không được ánh xạ đó.

Thay vì thực hiện và sử dụng các phương thức mở rộng này, bạn có thể chỉ cần sử dụng

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

Bây giờ trình tự động hóa biết rằng nó chỉ cần xác thực rằng tất cả các trường nguồn được ánh xạ chứ không phải theo cách khác.

Bạn cũng có thể dùng:

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

Tôi đã cập nhật tiện ích mở rộng của Can Gencer để không ghi đè lên bất kỳ bản đồ hiện có nào.

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

Sử dụng:

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

Tôi đã có thể làm điều này theo cách sau:

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

Lưu ý: Tôi đang sử dụng AutoMapper v.2.0.

Phiên bản 5.0.0-beta-1 của AutoMapper giới thiệu ForAllOtherMembersphương thức tiện ích mở rộng để bây giờ bạn có thể thực hiện việc này:

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

Xin lưu ý rằng có một lợi thế để lập bản đồ rõ ràng cho từng thuộc tính vì bạn sẽ không bao giờ gặp phải các vấn đề về ánh xạ thất bại phát sinh khi bạn quên lập bản đồ một thuộc tính.

Có lẽ trong trường hợp của bạn, có thể là khôn ngoan khi bỏ qua tất cả các thành viên khác và thêm một TODOđể quay lại và làm cho những điều này rõ ràng sau khi tần suất thay đổi của lớp này lắng xuống.

Kể từ AutoMapper 5.0, thuộc .TypeMaptính trên IMappingExpressionđã biến mất, nghĩa là giải pháp 4.2 không còn hoạt động. Tôi đã tạo một giải pháp sử dụng chức năng ban đầu nhưng với một cú pháp khác:

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

Thực hiện:

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

Đã có một vài năm kể từ khi câu hỏi được đặt ra, nhưng phương pháp mở rộng này có vẻ sạch hơn đối với tôi, sử dụng phiên bản hiện tại của 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;
}

Đối với những người đang sử dụng API không tĩnh trong phiên bản 4.2.0 trở lên, có thể sử dụng phương pháp tiện ích mở rộng sau (được tìm thấy ở đây trong AutoMapperExtensionslớp):

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

Điều quan trọng ở đây là một khi API tĩnh bị loại bỏ, mã như Mapper.FindTypeMapForsẽ không còn hoạt động, do đó sử dụng expression.TypeMaptrường.

Đối với Automapper 5.0 để bỏ qua tất cả các thuộc tính chưa được ánh xạ, bạn chỉ cần đặt

.Tất cảOtherMembers (x => x.Ignore ());

vào cuối hồ sơ của bạn.

Ví dụ:

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

Trong trường hợp này, chỉ có trường Id cho đối tượng đầu ra sẽ được giải quyết, tất cả các trường khác sẽ bị bỏ qua. Hoạt động như một bùa mê, dường như chúng ta không cần bất kỳ tiện ích mở rộng khó khăn nào nữa!

Tôi đã cập nhật câu trả lời của Robert Schroeder cho AutoMapper 4.2. Với các cấu hình ánh xạ không tĩnh, chúng tôi không thể sử dụng Mapper.GetAllTypeMaps(), nhưng expressioncó tham chiếu đến yêu cầu 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;
}

Làm thế nào bạn muốn xác định rằng các thành viên nhất định bị bỏ qua? Có một quy ước, hoặc lớp cơ sở, hoặc thuộc tính bạn muốn áp dụng? Khi bạn tham gia vào việc xác định rõ ràng tất cả các ánh xạ, tôi không chắc bạn sẽ nhận được giá trị gì từ AutoMapper.

Đây có vẻ là một câu hỏi cũ nhưng nghĩ rằng tôi sẽ đăng câu trả lời của mình cho bất cứ ai khác trông giống như tôi.

Tôi sử dụng ConstructUsing, trình khởi tạo đối tượng được kết hợp với ForAllMembers bỏ qua, vd

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

Thông tin duy nhất về việc bỏ qua nhiều thành viên là chủ đề này - http://groups.google.com/group/automapper-users/browse_thread/thread/9928ce9f2ffa641f . Tôi nghĩ rằng bạn có thể sử dụng thủ thuật được sử dụng trong Cung cấpCommonBaseClassConfiguration để bỏ qua các thuộc tính phổ biến cho các lớp tương tự.
Và không có thông tin về chức năng "Bỏ qua phần còn lại". Tôi đã xem mã trước đây và dường như sẽ rất khó để thêm chức năng đó. Ngoài ra, bạn có thể thử sử dụng một số thuộc tính và đánh dấu với các thuộc tính bị bỏ qua và thêm một số mã chung / chung để bỏ qua tất cả các thuộc tính được đánh dấu.

Tôi biết đây là một câu hỏi cũ, nhưng @jmoerdyk trong câu hỏi của bạn:

Làm thế nào bạn sẽ sử dụng điều này trong một biểu thức CreatMap () được xâu chuỗi trong Hồ sơ?

bạn có thể sử dụng câu trả lời như thế này trong ctor Profile

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

Bạn có thể sử dụng ForAllMembers, hơn ghi đè chỉ cần thiết như thế này

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

Hãy cẩn thận, nó sẽ bỏ qua tất cả và nếu bạn không thêm ánh xạ tùy chỉnh, chúng sẽ bị bỏ qua và sẽ không hoạt động

Ngoài ra, tôi muốn nói, nếu bạn có bài kiểm tra đơn vị cho AutoMapper. Và bạn kiểm tra rằng tất cả các mô hình với tất cả các thuộc tính được ánh xạ chính xác, bạn không nên sử dụng phương thức mở rộng như vậy

bạn nên viết bỏ qua một cách rõ ràng

Giải pháp hiện tại (phiên bản 9) để bỏ qua các thuộc tính không tồn tại trong loại đích là tạo ánh xạ lật và đảo ngược nó:

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

Trong phiên bản 3.3.1, bạn chỉ cần sử dụng IgnoreAllPropertiesWithAnInaccessibleSetter()hoặc IgnoreAllSourcePropertiesWithAnInaccessibleSetter()phương thức.