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

이제 automapper는 모든 소스 필드가 맵핑되었지만 다른 방식으로 맵핑되지 않았 음을 검증해야한다는 것을 알고 있습니다.

다음을 사용할 수도 있습니다.

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

속성 매핑을 잊었을 때 발생하는 자동 실패 매핑 문제는 발생하지 않으므로 각 속성을 명시 적으로 매핑하는 이점이 있습니다.

아마도 귀하의 경우에는 다른 모든 멤버를 무시 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. 무시 ());

프로필 끝에서

예를 들면 다음과 같습니다.

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 () 표현식에서 이것을 어떻게 사용 하시겠습니까?

이 답변을 Profile 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에 대한 단위 테스트가 있다면 말하고 싶습니다. 그리고 모든 속성이 올바르게 매핑 된 모든 모델은 그러한 확장 방법을 사용하지 않아야합니다.

당신은 명시 적으로 ignore를 작성해야합니다

대상 유형에 존재하지 않는 속성을 무시하는 현재 (버전 9) 솔루션은 뒤집힌 매핑을 만들고 뒤집는 것입니다.

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

3.3.1 버전에서는 단순히 IgnoreAllPropertiesWithAnInaccessibleSetter()또는 IgnoreAllSourcePropertiesWithAnInaccessibleSetter()메소드를 사용할 수 있습니다 .