private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeInfo sourceTypeInfo, IMappingOptions options) { var parameters = new List<ConstructorParameterMap>(); var ctorParameters = destCtor.GetParameters(); if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled) return false; foreach (var parameter in ctorParameters) { var members = new LinkedList<MemberInfo>(); if (!MapDestinationPropertyToSource(members, sourceTypeInfo, parameter.Name, options)) return false; var resolvers = members.Select(mi => mi.ToMemberGetter()); var param = new ConstructorParameterMap(parameter, resolvers.ToArray()); parameters.Add(param); } typeMap.AddConstructorMap(destCtor, parameters); return true; }
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options, MemberList memberList) { var sourceTypeInfo = GetTypeInfo(sourceType, options); var destTypeInfo = GetTypeInfo(destinationType, options.ShouldMapProperty, options.ShouldMapField, new MethodInfo[0]); var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList); foreach (var destProperty in destTypeInfo.PublicWriteAccessors) { var members = new LinkedList<MemberInfo>(); if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options)) { var resolvers = members.Select(mi => mi.ToMemberGetter()); var destPropertyAccessor = destProperty.ToMemberAccessor(); typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>()); } } if (!destinationType.IsAbstract() && destinationType.IsClass()) { foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length)) { if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options)) { break; } } } return typeMap; }
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IProfileConfiguration options, MemberList memberList) { var sourceTypeInfo = GetTypeInfo(sourceType, options); var destTypeInfo = GetTypeInfo(destinationType, options); var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList, options.ProfileName); foreach (var destProperty in destTypeInfo.PublicWriteAccessors) { var resolvers = new LinkedList<IValueResolver>(); if (MapDestinationPropertyToSource(options, sourceTypeInfo, destProperty.GetMemberType(), destProperty.Name, resolvers)) { var destPropertyAccessor = destProperty.ToMemberAccessor(); typeMap.AddPropertyMap(destPropertyAccessor, resolvers); } } if (!destinationType.IsAbstract() && destinationType.IsClass()) { foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length)) { if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options)) { break; } } } return typeMap; }
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options) { var sourceTypeInfo = GetTypeInfo(sourceType); var destTypeInfo = GetTypeInfo(destinationType); var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo); foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors()) { var members = new LinkedList<MemberInfo>(); if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options)) { var resolvers = members.Select(mi => mi.ToMemberGetter()); var destPropertyAccessor = destProperty.ToMemberAccessor(); #if !SILVERLIGHT typeMap.AddPropertyMap(destPropertyAccessor, resolvers); #else typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>()); #endif } } if (!destinationType.IsAbstract && destinationType.IsClass) { foreach (var destCtor in destTypeInfo.GetConstructors().OrderByDescending(ci => ci.GetParameters().Length)) { if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options)) { break; } } } return typeMap; }
private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeDetails sourceTypeInfo, IProfileConfiguration options) { var parameters = new List<ConstructorParameterMap>(); var ctorParameters = destCtor.GetParameters(); if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled) return false; foreach (var parameter in ctorParameters) { var resolvers = new LinkedList<IValueResolver>(); var canResolve = MapDestinationPropertyToSource(options, sourceTypeInfo, parameter.GetType(), parameter.Name, resolvers); if(!canResolve && parameter.HasDefaultValue) { canResolve = true; } var param = new ConstructorParameterMap(parameter, resolvers.ToArray(), canResolve); parameters.Add(param); } typeMap.AddConstructorMap(destCtor, parameters); return true; }
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, ProfileMap options, MemberList memberList) { var sourceTypeInfo = options.CreateTypeDetails(sourceType); var destTypeInfo = options.CreateTypeDetails(destinationType); var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList, options); foreach (var destProperty in destTypeInfo.PublicWriteAccessors) { var resolvers = new LinkedList<MemberInfo>(); if (MapDestinationPropertyToSource(options, sourceTypeInfo, destProperty.DeclaringType, destProperty.GetMemberType(), destProperty.Name, resolvers)) { typeMap.AddPropertyMap(destProperty, resolvers); } } if (!destinationType.IsAbstract() && destinationType.IsClass()) { foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length)) { if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options)) { break; } } } return typeMap; }
private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeDetails sourceTypeInfo, ProfileMap options) { var ctorParameters = destCtor.GetParameters(); if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled) return false; var ctorMap = new ConstructorMap(destCtor, typeMap); foreach (var parameter in ctorParameters) { var resolvers = new LinkedList<MemberInfo>(); var canResolve = MapDestinationPropertyToSource(options, sourceTypeInfo, destCtor.DeclaringType, parameter.GetType(), parameter.Name, resolvers); if(!canResolve && parameter.HasDefaultValue) { canResolve = true; } ctorMap.AddParameter(parameter, resolvers.ToArray(), canResolve); } typeMap.ConstructorMap = ctorMap; return true; }
public AutoMapperConfigurationException(TypeMap typeMap, string[] unmappedPropertyNames) : base(string.Format( "The following {3} properties on {0} are not mapped: \n\t{2}\nAdd a custom mapping expression, ignore, or rename the property on {1}.", typeMap.DestinationType.FullName, typeMap.SourceType.FullName, string.Join("\n\t", unmappedPropertyNames), unmappedPropertyNames.Length)) { }
private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, ResolutionContext context) { if (typeMap != null) { typeMapsChecked.Add(typeMap); if(typeMap.CustomMapper != null || typeMap.TypeConverterType != null) { return; } CheckPropertyMaps(typeMapsChecked, typeMap, context); } else { var mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(types)); if (mapperToUse == null && types.SourceType.IsNullableType()) { var nullableTypes = new TypePair(Nullable.GetUnderlyingType(types.SourceType), types.DestinationType); mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableTypes)); } if (mapperToUse == null) { throw new AutoMapperConfigurationException(types); } if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper) { CheckElementMaps(typeMapsChecked, types, context); } } }
public static IEnumerable<MapVisual> X(TypeMap map) { foreach (var propertyMap in map.GetPropertyMaps()) { yield return new MapVisual { SourceSystem = extractSystem(propertyMap.SourceMember), SourceValue = getValue(propertyMap.SourceMember), TargetSystem = extractSystem(propertyMap.DestinationProperty), TargetValue = propertyMap.DestinationProperty.Name }; } }
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options) { var sourceTypeInfo = GetTypeInfo(sourceType); var destTypeInfo = GetTypeInfo(destinationType); var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo); foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors()) { var members = new LinkedList<MemberInfo>(); if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options)) { var resolvers = members.Select(mi => mi.ToMemberGetter()).Cast<IValueResolver>(); var destPropertyAccessor = destProperty.ToMemberAccessor(); typeMap.AddPropertyMap(destPropertyAccessor, resolvers); } } return typeMap; }
public MappingExpression(TypeMap typeMap, Func <Type, object> typeConverterCtor) { _typeMap = typeMap; _typeConverterCtor = typeConverterCtor; }
private void CheckPropertyMaps(ICollection<TypeMap> typeMapsChecked, TypeMap typeMap, ResolutionContext context) { foreach (var propertyMap in typeMap.GetPropertyMaps()) { if (propertyMap.Ignored) continue; var sourceType = propertyMap.SourceType; if (sourceType == null) continue; // when we don't know what the source type is, bail if (sourceType.IsGenericParameter || sourceType == typeof (object)) return; var destinationType = propertyMap.DestinationProperty.GetMemberType(); var memberTypeMap = _config.ResolveTypeMap(sourceType, destinationType); if (typeMapsChecked.Any(tm => Equals(tm, memberTypeMap))) continue; DryRunTypeMap(typeMapsChecked, new TypePair(sourceType, destinationType), memberTypeMap, context); } }
private IMappingExpression <TSource, TDestination> CreateMappingExpression <TSource, TDestination>(TypeMap typeMap) { var mappingExp = new MappingExpression <TSource, TDestination>(typeMap, _serviceCtor, this); var type = (typeMap.ConfiguredMemberList == MemberList.Destination) ? typeof(TDestination) : typeof(TSource); return(Ignore(mappingExp, type)); }
public PathMap FindOrCreatePathMapFor(LambdaExpression destinationExpression, MemberPath path, TypeMap typeMap) { var pathMap = _pathMaps.SingleOrDefault(p => p.MemberPath == path); if (pathMap == null) { pathMap = new PathMap(destinationExpression, path, typeMap); _pathMaps.Add(pathMap); } return(pathMap); }
public IncludedMember(TypeMap typeMap, LambdaExpression memberExpression) : this(typeMap, memberExpression, Variable(memberExpression.Body.Type, string.Join("", memberExpression.GetMembersChain().Select(m => m.Name))), memberExpression) { }
private void ApplyMemberMaps(TypeMap mainMap, IConfigurationProvider configurationProvider) { AddMemberMaps(mainMap.IncludedMembers, mainMap, configurationProvider); AddMemberMaps(mainMap.GetUntypedIncludedMembers(), mainMap, configurationProvider); }
protected void OnTypeMapCreated(TypeMap typeMap) { TypeMapCreated?.Invoke(this, new TypeMapCreatedEventArgs(typeMap)); }
internal void DecrementTypeDepth(TypeMap typeMap) => TypeDepth[typeMap.Types]--;
public TypeMapConfigErrors(TypeMap typeMap, string[] unmappedPropertyNames, bool canConstruct) { TypeMap = typeMap; UnmappedPropertyNames = unmappedPropertyNames; CanConstruct = canConstruct; }
internal void ValidateMap(TypeMap typeMap) => ConfigurationProvider.AssertConfigurationIsValid(typeMap);
internal void IncrementTypeDepth(TypeMap typeMap) => TypeDepth[typeMap.Types]++;
public PropertyMap(PropertyMap includedMemberMap, TypeMap typeMap, LambdaExpression expression) : this(includedMemberMap, typeMap) => ApplyIncludedMemberMap(includedMemberMap, expression);
public void RegisterTypeMap(TypeMap typeMap) => _typeMaps[typeMap.Types] = typeMap;
private IMappingExpression CreateMappingExpression(TypeMap typeMap, Type destinationType) { var mappingExp = new MappingExpression(typeMap, _serviceCtor, this); return((IMappingExpression)Ignore(mappingExp, destinationType)); }
public void InheritTypes(TypeMap inheritedTypeMap) { foreach (var includedDerivedType in inheritedTypeMap._includedDerivedTypes .Where(includedDerivedType => !_includedDerivedTypes.Contains(includedDerivedType))) { _includedDerivedTypes.Add(includedDerivedType); } }
private void ApplyInheritedTypeMap(TypeMap inheritedTypeMap) { foreach (var inheritedMappedProperty in inheritedTypeMap.GetPropertyMaps().Where(m => m.IsMapped())) { var conventionPropertyMap = GetPropertyMaps() .SingleOrDefault(m => m.DestinationProperty.Name == inheritedMappedProperty.DestinationProperty.Name); if (conventionPropertyMap != null) { conventionPropertyMap.ApplyInheritedPropertyMap(inheritedMappedProperty); } else { var propertyMap = new PropertyMap(inheritedMappedProperty, this); _inheritedMaps.Add(propertyMap); } } //Include BeforeMap foreach (var beforeMapAction in inheritedTypeMap._beforeMapActions) { AddBeforeMapAction(beforeMapAction); } //Include AfterMap foreach (var afterMapAction in inheritedTypeMap._afterMapActions) { AddAfterMapAction(afterMapAction); } }
public ConstructorMap(ConstructorInfo ctor, TypeMap typeMap) { Ctor = ctor; TypeMap = typeMap; }
private static void ApplyBaseMaps(TypeMapRegistry typeMapRegistry, TypeMap derivedMap, TypeMap currentMap) { foreach (var baseMap in currentMap.IncludedBaseTypes.Select(typeMapRegistry.GetTypeMap).Where(baseMap => baseMap != null)) { baseMap.IncludeDerivedTypes(currentMap.SourceType, currentMap.DestinationType); derivedMap.ApplyInheritedMap(baseMap); ApplyBaseMaps(typeMapRegistry, derivedMap, baseMap); } }
private void DryRunTypeMap(ICollection <TypeMap> typeMapsChecked, ResolutionContext context) { if (context.TypeMap != null) { typeMapsChecked.Add(context.TypeMap); } var mapperToUse = GetMappers().FirstOrDefault(mapper => mapper.IsMatch(context)); if (mapperToUse == null && context.SourceType.IsNullableType()) { var nullableContext = context.CreateValueContext(null, Nullable.GetUnderlyingType(context.SourceType)); mapperToUse = GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableContext)); } if (mapperToUse == null) { throw new AutoMapperConfigurationException(context); } if (mapperToUse is TypeMapMapper) { foreach (var propertyMap in context.TypeMap.GetPropertyMaps()) { if (!propertyMap.IsIgnored()) { var lastResolver = propertyMap.GetSourceValueResolvers().OfType <IMemberResolver>().LastOrDefault(); if (lastResolver != null) { var sourceType = lastResolver.MemberType; var destinationType = propertyMap.DestinationProperty.MemberType; var memberTypeMap = ((IConfigurationProvider)this).ResolveTypeMap(sourceType, destinationType); if (typeMapsChecked.Any(typeMap => Equals(typeMap, memberTypeMap))) { continue; } var memberContext = context.CreateMemberContext(memberTypeMap, null, null, sourceType, propertyMap); DryRunTypeMap(typeMapsChecked, memberContext); } } } } else if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper) { Type sourceElementType = TypeHelper.GetElementType(context.SourceType); Type destElementType = TypeHelper.GetElementType(context.DestinationType); TypeMap itemTypeMap = ((IConfigurationProvider)this).ResolveTypeMap(sourceElementType, destElementType); if (typeMapsChecked.Any(typeMap => Equals(typeMap, itemTypeMap))) { return; } var memberContext = context.CreateElementContext(itemTypeMap, null, sourceElementType, destElementType, 0); DryRunTypeMap(typeMapsChecked, memberContext); } }
public ValidationContext(TypePair types, PropertyMap propertyMap, TypeMap typeMap) : this(types, propertyMap, null, typeMap) { }
public PathMap(LambdaExpression destinationExpression, MemberPath memberPath, TypeMap typeMap) { MemberPath = memberPath; TypeMap = typeMap; DestinationExpression = destinationExpression; }
private static LambdaExpression GenerateTypeMapExpression(MapRequest mapRequest, TypeMap typeMap) { var mapExpression = typeMap.MapExpression; var typeMapSourceParameter = mapExpression.Parameters[0]; var typeMapDestinationParameter = mapExpression.Parameters[1]; var requestedSourceType = mapRequest.RequestedTypes.SourceType; var requestedDestinationType = mapRequest.RequestedTypes.DestinationType; if (typeMapSourceParameter.Type != requestedSourceType || typeMapDestinationParameter.Type != requestedDestinationType) { var requestedSourceParameter = Parameter(requestedSourceType, "source"); var requestedDestinationParameter = Parameter(requestedDestinationType, "typeMapDestination"); var contextParameter = Parameter(typeof(ResolutionContext), "context"); mapExpression = Lambda(ToType(Invoke(typeMap.MapExpression, ToType(requestedSourceParameter, typeMapSourceParameter.Type), ToType(requestedDestinationParameter, typeMapDestinationParameter.Type), contextParameter ), mapRequest.RuntimeTypes.DestinationType), requestedSourceParameter, requestedDestinationParameter, contextParameter); } return(mapExpression); }
public override int GetHashCode() => TypeMap.GetHashCode();
private void ApplyInheritedTypeMap(TypeMap inheritedTypeMap) { foreach (var inheritedMappedProperty in inheritedTypeMap.GetPropertyMaps().Where(m => m.IsMapped())) { var conventionPropertyMap = GetPropertyMaps() .SingleOrDefault(m => m.DestinationProperty.Name == inheritedMappedProperty.DestinationProperty.Name); if (conventionPropertyMap != null && inheritedMappedProperty.HasCustomValueResolver && !conventionPropertyMap.HasCustomValueResolver) { conventionPropertyMap.AssignCustomValueResolver( inheritedMappedProperty.GetSourceValueResolvers().First()); conventionPropertyMap.AssignCustomExpression(inheritedMappedProperty.CustomExpression); } else if (conventionPropertyMap == null) { var propertyMap = new PropertyMap(inheritedMappedProperty); AddInheritedPropertyMap(propertyMap); } } //Include BeforeMap if (inheritedTypeMap.BeforeMap != null) AddBeforeMapAction(inheritedTypeMap.BeforeMap); //Include AfterMap if (inheritedTypeMap.AfterMap != null) AddAfterMapAction(inheritedTypeMap.AfterMap); }
public SourceMappingExpression(TypeMap typeMap, LambdaExpression sourceMember) { var memberInfo = ReflectionHelper.FindProperty(sourceMember); _sourcePropertyConfig = typeMap.FindOrCreateSourceMemberConfigFor(memberInfo); }
public TypeMapConfigErrors(TypeMap typeMap, string[] unmappedPropertyNames) { TypeMap = typeMap; UnmappedPropertyNames = unmappedPropertyNames; }
public IMappingExpression <TSource, TDestination> CreateMap <TSource, TDestination>(string profileName) { TypeMap typeMap = CreateTypeMap(typeof(TSource), typeof(TDestination), profileName); return(CreateMappingExpression <TSource, TDestination>(typeMap)); }
private ValidationContext(TypePair types, PropertyMap propertyMap, IObjectMapper objectMapper, TypeMap typeMap) { ObjectMapper = objectMapper; TypeMap = typeMap; Types = types; PropertyMap = propertyMap; }
private void Configure(TypeMapRegistry typeMapRegistry, TypeMap typeMap) { foreach (var action in AllTypeMapActions) { var expression = new MappingExpression(typeMap.Types, typeMap.ConfiguredMemberList); action(typeMap, expression); expression.Configure(typeMap); } foreach (var action in AllPropertyMapActions) { foreach (var propertyMap in typeMap.GetPropertyMaps()) { var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestinationProperty, typeMap.SourceType); action(propertyMap, memberExpression); memberExpression.Configure(typeMap); } } ApplyBaseMaps(typeMapRegistry, typeMap, typeMap); ApplyDerivedMaps(typeMapRegistry, typeMap, typeMap); }
private IMappingExpression <TSource, TDestination> CreateMappingExpression <TSource, TDestination>(TypeMap typeMap) { IMappingExpression <TSource, TDestination> mappingExp = new MappingExpression <TSource, TDestination>(typeMap, _serviceCtor, this); // Custom Hack var destInfo = new TypeInfo(typeof(TDestination)); foreach (var destProperty in destInfo.GetPublicWriteAccessors()) { object[] attrs = destProperty.GetCustomAttributes(true); if (attrs.Any(x => x is IgnoreMapAttribute)) { mappingExp = mappingExp.ForMember(destProperty.Name, y => y.Ignore()); } } return(mappingExp); }
private void ApplyDerivedMaps(TypeMapRegistry typeMapRegistry, TypeMap baseMap, TypeMap typeMap) { foreach (var inheritedTypeMap in typeMap.IncludedDerivedTypes.Select(typeMapRegistry.GetTypeMap).Where(map => map != null)) { inheritedTypeMap.ApplyInheritedMap(baseMap); ApplyDerivedMaps(typeMapRegistry, baseMap, inheritedTypeMap); } }
public PropertyMap(MemberInfo destinationMember, TypeMap typeMap) { TypeMap = typeMap; DestinationMember = destinationMember; }
public AutoMapperConfigurationException(TypeMap typeMap, string mismatchedPropertyName) : base(string.Format( "The following property on {0} cannot be mapped: \n\t{2}\nAdd a custom mapping expression, ignore, add a custom resolver, or modify the destination type {1}.", typeMap.DestinationType.FullName, typeMap.SourceType.FullName, mismatchedPropertyName)) { }
public PropertyMap(PropertyMap inheritedMappedProperty, TypeMap typeMap) : this(inheritedMappedProperty.DestinationMember, typeMap) => ApplyInheritedPropertyMap(inheritedMappedProperty);
public void ApplyInheritedMap(TypeMap inheritedTypeMap) { _inheritedTypeMaps.Add(inheritedTypeMap); }
public PropertyMap(PropertyMap includedMemberMap, TypeMap typeMap, IncludedMember includedMember) : this(includedMemberMap, typeMap) => IncludedMember = includedMember.Chain(includedMemberMap.IncludedMember);
public AutoMapperMappingException(string message, Exception innerException, TypePair types, TypeMap typeMap) : this(message, innerException, types) { TypeMap = typeMap; }
public TypeMapCreatedEventArgs(TypeMap typeMap) { TypeMap = typeMap; }
public MapperFuncs(MapRequest mapRequest, TypeMap typeMap) : this(mapRequest, GenerateTypeMapExpression(mapRequest, typeMap)) { }
public AutoMapperMappingException(string message, Exception innerException, TypePair types, TypeMap typeMap, PropertyMap propertyMap) : this(message, innerException, types, typeMap) { PropertyMap = propertyMap; }
public bool Equals(TypeMap other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return Equals(other._sourceType, _sourceType) && Equals(other._destinationType, _destinationType); }
public void AssertConfigurationIsValid(TypeMap typeMap) { AssertConfigurationIsValid(Enumerable.Repeat(typeMap, 1)); }
private IMappingExpression <TSource, TDestination> CreateMappingExpression <TSource, TDestination>(TypeMap typeMap) { IMappingExpression <TSource, TDestination> mappingExp = new MappingExpression <TSource, TDestination>(typeMap, _serviceCtor, this); var type = (typeMap.ConfiguredMemberList == MemberList.Destination) ? typeof(TDestination) : typeof(TSource); var destInfo = new TypeInfo(type, ShouldMapProperty, ShouldMapField); foreach (var destProperty in destInfo.PublicWriteAccessors) { var attrs = destProperty.GetCustomAttributes(true); if (attrs.Any(x => x is IgnoreMapAttribute)) { mappingExp = mappingExp.ForMember(destProperty.Name, y => y.Ignore()); } if (_globalIgnore.Contains(destProperty.Name)) { mappingExp = mappingExp.ForMember(destProperty.Name, y => y.Ignore()); } } return(mappingExp); }
private static bool ShouldCheckMap(TypeMap typeMap) { return((typeMap.CustomMapper == null && typeMap.CustomProjection == null && typeMap.DestinationTypeOverride == null) && !FeatureDetector.IsIDataRecordType(typeMap.SourceType)); }
public TypeMapWrapper(TypeMap typeMap) { DestinationType = typeMap.DestinationType; }