static void ignorePropertiesWithIdsMappingToEntities(IMappingExpression mapping, Type source, Type destination) { var idTypes = new[] { typeof(Guid), typeof(Guid?) }; var destinationProps = propertiesOf(destination).ToDictionary(pi => pi.Name); var sourceProps = propertiesOf(source); var whereThePropertyIsAnId = sourceProps.Where(p => idTypes.Contains(p.PropertyType)); var withDestination = whereThePropertyIsAnId.Select(SourceProp => new { SourceProp, DestinationProp = destinationProps.TryGetValue(SourceProp.Name) }); var andTheTargetIsAnEntity = withDestination.Where(x => x.DestinationProp?.PropertyType.IsAssignableTo <IEntity>() ?? false); foreach (var sourceProp in andTheTargetIsAnEntity.Select(x => x.SourceProp.Name)) { mapping.ForMember(sourceProp, x => x.Ignore()); } }
public static void CreateMap(Type a, Type b, IList <string> sources, IList <string> targets) { IMappingExpression expressionA2B = Mapper.CreateMap(a, b); IMappingExpression expressionB2A = Mapper.CreateMap(b, a); if (sources != null && targets != null) { for (int i = 0; i < sources.Count; i++) { string sourceName = sources[i]; string targetName = targets[i]; expressionA2B.ForMember(targetName, opt => opt.MapFrom(sourceName)); expressionB2A.ForMember(sourceName, opt => opt.MapFrom(targetName)); } } }
public static IMappingExpression <TSource, TDestination> MapBaseContentTypeSaveToDisplay <TSource, TPropertyTypeSource, TDestination, TPropertyTypeDestination>( this IMappingExpression <TSource, TDestination> mapping) where TSource : ContentTypeSave <TPropertyTypeSource> where TDestination : ContentTypeCompositionDisplay <TPropertyTypeDestination> where TPropertyTypeDestination : PropertyTypeDisplay where TPropertyTypeSource : PropertyTypeBasic { return(mapping .ForMember(dto => dto.CreateDate, expression => expression.Ignore()) .ForMember(dto => dto.UpdateDate, expression => expression.Ignore()) .ForMember(dto => dto.ListViewEditorName, expression => expression.Ignore()) .ForMember(dto => dto.Notifications, expression => expression.Ignore()) .ForMember(dto => dto.Errors, expression => expression.Ignore()) .ForMember(dto => dto.LockedCompositeContentTypes, exp => exp.Ignore()) .ForMember(dto => dto.Groups, expression => expression.ResolveUsing(new PropertyGroupDisplayResolver <TSource, TPropertyTypeSource, TPropertyTypeDestination>()))); }
public static IMappingExpression <TSource, TDestination> IgnoreAllNonExisting <TSource, TDestination>(this IMappingExpression <TSource, TDestination> expression) { const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; var sourceType = typeof(TSource); var destinationProperties = typeof(TDestination).GetProperties(flags); foreach (var property in destinationProperties) { var propInfoSrc = sourceType.GetProperties().FirstOrDefault(p => p.Name == property.Name); if (propInfoSrc == null) { expression.ForMember(property.Name, opt => opt.Ignore()); } } return(expression); }
public static IMappingExpression <TSource, TDestination> IgnoreReadOnly <TSource, TDestination>( this IMappingExpression <TSource, TDestination> expression) { var destType = typeof(TDestination); foreach (var property in destType.GetProperties()) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(destType)[property.Name]; ReadOnlyAttribute attribute = (ReadOnlyAttribute)descriptor.Attributes[typeof(ReadOnlyAttribute)]; if (attribute.IsReadOnly == true) { expression.ForMember(property.Name, opt => opt.Ignore()); } } return(expression); }
public static IMappingExpression IgnoreAllNonExisting(this IMappingExpression expression) { var mappingExpression = (MappingExpression)expression; var flags = BindingFlags.Public | BindingFlags.Instance; var destinationProperties = mappingExpression.Types.DestinationType.GetProperties(flags); foreach (var property in destinationProperties) { if (mappingExpression.Types.SourceType.GetProperty(property.Name, flags) != null) { continue; } expression.ForMember(property.Name, opt => opt.Ignore()); } return(expression); }
public static IMappingExpression <TSource, TDestination> IgnoreNoMap <TSource, TDestination>( this IMappingExpression <TSource, TDestination> expression) { var sourceType = typeof(TSource); foreach (var property in sourceType.GetProperties()) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(sourceType)[property.Name]; NoMapAttribute attribute = (NoMapAttribute)descriptor.Attributes[typeof(NoMapAttribute)]; if (attribute != null) { expression.ForMember(property.Name, opt => opt.Ignore()); } } return(expression); }
public static IMappingExpression <TServiceModel, TModel> MapReference <TServiceModel, TServiceModelProperty, TModel, TModelProperty>( this IMappingExpression <TServiceModel, TModel> mappingExpression, Expression <Func <TServiceModel, IList <TServiceModelProperty> > > sourceMember, Expression <Func <TModel, IList <TModelProperty> > > destinationMember) where TServiceModel : ServiceModelBase where TServiceModelProperty : ServiceModelBase where TModel : ModelBase where TModelProperty : ModelBase { // in stead of mapping the source property to the destination property, try to retrieve the already stored destination object from the database mappingExpression = mappingExpression.ForMember( destinationMember, options => options.ResolveUsing((serviceModel, model, modelProperty, resolutionContext) => serviceModel.FetchDestination(model, resolutionContext, sourceMember, destinationMember))); return(mappingExpression); }
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); }
/// <summary> /// Instructs the AutoMapper profile to resolve the specified <paramref name="constructorParam"/> by checking the resolution context for an /// already created item matching the <paramref name="keyAttributes"/> of the source's reference property. /// </summary> /// <param name="expression"> /// The expression. /// </param> /// <param name="resolutionSource"> /// The resolution source. /// </param> /// <param name="resolutionTarget"> /// The resolution target. /// </param> /// <param name="constructorParam"> /// The constructor param. /// </param> /// <param name="keyAttributes"> /// The key attributes. /// </param> /// <typeparam name="TSource"> /// The type of item that is the source of the mapping expression. /// </typeparam> /// <typeparam name="TReference"> /// The type of property on the source that will be used as the reference to resolve on the target. /// </typeparam> /// <typeparam name="TDest"> /// The type of item that is the destination of the mapping expression. /// </typeparam> /// <typeparam name="TTarget"> /// The type of property on the destination that will be resolved. /// </typeparam> /// <returns> /// The current <see cref="IMappingExpression{TSource,TDest}"/>. /// </returns> public static IMappingExpression <TSource, TDest> ResolveByKey <TSource, TReference, TDest, TTarget>( [NotNull] this IMappingExpression <TSource, TDest> expression, [NotNull] Expression <Func <TSource, TReference> > resolutionSource, [NotNull] Expression <Func <TDest, TTarget> > resolutionTarget, [NotNull] string constructorParam, [NotNull] params Expression <Func <TReference, object> >[] keyAttributes) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } if (resolutionSource == null) { throw new ArgumentNullException(nameof(resolutionSource)); } if (resolutionTarget == null) { throw new ArgumentNullException(nameof(resolutionTarget)); } if (constructorParam == null) { throw new ArgumentNullException(nameof(constructorParam)); } if (keyAttributes == null) { throw new ArgumentNullException(nameof(keyAttributes)); } expression.ForCtorParam( constructorParam, configurationExpression => configurationExpression.MapFrom( (source, context) => ResolveItem <TReference, TTarget>(context, resolutionSource.Compile().Invoke(source), keyAttributes.ToArray()))); expression.ForMember( resolutionTarget, configurationExpression => configurationExpression.MapFrom( (source, dest, target, context) => ResolveItem <TReference, TTarget>( context, resolutionSource.Compile().Invoke(source), keyAttributes.ToArray()))); return(expression); }
public static IMappingExpression <TSource, TDestination> InheritMappingFromBaseType <TSource, TDestination>( this IMappingExpression <TSource, TDestination> mappingExpression, WithBaseFor baseFor = WithBaseFor.Both, IMappingEngine mappingEngine = null, IConfigurationProvider configurationProvider = null) { Type sourceType = typeof(TSource); Type destinationType = typeof(TDestination); Type sourceParentType = baseFor == WithBaseFor.Both || baseFor == WithBaseFor.Source ? sourceType.BaseType : sourceType; Type destinationParentType = baseFor == WithBaseFor.Both || baseFor == WithBaseFor.Destination ? destinationType.BaseType : destinationType; mappingExpression .BeforeMap((sourceObject, destObject) => { if (mappingEngine != null) { mappingEngine.Map(sourceObject, destObject, sourceParentType, destinationParentType); } else { Mapper.Map(sourceObject, destObject, sourceParentType, destinationParentType); } }); TypeMap baseTypeMap = configurationProvider != null ? configurationProvider.FindTypeMapFor(sourceParentType, destinationParentType) : Mapper.FindTypeMapFor(sourceParentType, destinationParentType); if (baseTypeMap == null) { throw new InvalidOperationException( string.Format("Missing map from {0} to {1}.", new object[] { sourceParentType.Name, destinationParentType.Name })); } foreach (PropertyMap propertyMap in baseTypeMap.GetPropertyMaps()) { mappingExpression.ForMember(propertyMap.DestinationProperty.Name, opt => opt.Ignore()); } return(mappingExpression); }
/// <summary> /// Map destination member using destination and source member expressions /// </summary> /// <typeparam name="TDest">Destination type</typeparam> /// <typeparam name="TSource">Source type</typeparam> /// <param name="mappingExpression">IMappingExpression</param> /// <param name="destinationMember">Destination member</param> /// <param name="sourceMember">Source member</param> /// <param name="memberOptions">Member options</param> /// <returns>Itself</returns> public static IMappingExpression <TSource, TDest> MapTo <TDest, TSource>(this IMappingExpression <TSource, TDest> mappingExpression, Expression <Func <TDest, object?> > destinationMember, Expression <Func <TSource, object?> >?sourceMember = null, Action <IMemberConfigurationExpression <TSource, TDest, object?> >?memberOptions = null) { if (destinationMember is null) { throw new AutoMapperConfigurationException("Destination member expression cannot be null"); } mappingExpression.ForMember(destinationMember, o => { o.MapFrom(sourceMember ?? (s => s)); memberOptions?.Invoke(o); }); return(mappingExpression); }
private static IMappingExpression <TSource, TDestination> Merge <TSource, TDestination> (IMappingExpression <TSource, TDestination> mapping) { var type = typeof(TSource); foreach (var property in type.GetProperties()) { mapping.ForMember(property.Name, action => action.Condition(src => type.IsValueType ? property.GetValue(src).Equals(Activator.CreateInstance(type)) : property.GetValue(src) != null )); } return(mapping); }
public static IMappingExpression MapDisplayValues(this IMappingExpression expression, Type sourceType, Type destinationType) { //List<string> prefixes = new List<string> { "GENCAT_", "PERCAT_", "INSCAT_" }; const string DISPLAY_SUFFIX = "Display"; const string DISPLAY_PROPERTY = ".Descripcion"; var entityProperties = destinationType.GetProperties().Where(p => p.PropertyType == typeof(string) && p.Name.EndsWith(DISPLAY_SUFFIX)); foreach (var prop in entityProperties) { var destPropertyName = prop.Name; var sourcePropertyName = prop.Name.Replace(DISPLAY_SUFFIX, string.Empty).ToUpper() + DISPLAY_PROPERTY; //var destPropertyName = prefixes.GENCAT + prop.Name.ToUpper() ; expression.ForMember(destPropertyName, map => map.MapFrom(sourcePropertyName)); } return(expression); }
public static IMappingExpression <TSource, TDestination> IgnoreAllUnmapped <TSource, TDestination>(this IMappingExpression <TSource, TDestination> expression) { BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; Type sourceType = typeof(TSource); PropertyInfo[] destinationProperties = typeof(TDestination).GetProperties(flags); foreach (PropertyInfo property in destinationProperties) { if (sourceType.GetProperty(property.Name, flags) == null) { expression.ForMember(property.Name, o => o.Ignore()); } } return(expression); }
public static void IngoreNotMapped <TSource, TDestination>(this IMappingExpression <TSource, TDestination> mappingExpression) { if (mappingExpression is null) { throw new ArgumentNullException(nameof(mappingExpression)); } var destprops = typeof(TDestination).GetProperties(); foreach (PropertyInfo item in destprops) { if (item.IsDefined(typeof(AutoNotMapAttribute), true)) { mappingExpression.ForMember(item.Name, opt => opt.Ignore()); } } }
/// <summary> /// 设定除指定字段外的其他所有属性的值 /// </summary> /// <typeparam name="TSource">source</typeparam> /// <typeparam name="TKey">key</typeparam> /// <typeparam name="TDestination">dto</typeparam> /// <param name="destinationMember">member(dto)</param> /// <param name="expression">keys</param> /// <returns></returns> public static IMappingExpression <TSource, TDestination> SetWithoutProperties <TSource, TKey, TDestination>(this IMappingExpression <TSource, TDestination> destinationMember, params Expression <Func <TSource, TKey> >[] expression) { return(destinationMember); var withoutFields = lambdaFields(expression); var destProperties = typeof(TDestination) .GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(w => w.CanRead && w.CanWrite && withoutFields.Contains(w.Name)); foreach (var destProperty in destProperties) { destinationMember.ForMember(destProperty.Name, opts => opts.Ignore()); } return(destinationMember); }
/// <summary> /// Map destination member using name and source member expressions /// </summary> /// <typeparam name="TDest">Destination type</typeparam> /// <typeparam name="TSource">Source type</typeparam> /// <param name="mappingExpression">IMappingExpression</param> /// <param name="destinationMember">Destination member</param> /// <param name="sourceMember">Source member</param> /// <param name="memberOptions">Member options</param> /// <returns>Itself</returns> public static IMappingExpression <TSource, TDest> MapTo <TDest, TSource>(this IMappingExpression <TSource, TDest> mappingExpression, string destinationMember, Expression <Func <TSource, object?> >?sourceMember = null, Action <IMemberConfigurationExpression <TSource, TDest, object?> >?memberOptions = null) { if (string.IsNullOrWhiteSpace(destinationMember)) { throw new AutoMapperConfigurationException("Destination member name cannot be null or empty"); } mappingExpression.ForMember(destinationMember, o => { o.MapFrom(sourceMember ?? (s => s)); memberOptions?.Invoke(o); }); return(mappingExpression); }
public static IMappingExpression <TServiceModel, TModel> MapReference <TServiceModel, TServiceModelProperty, TModel, TModelProperty>( this IMappingExpression <TServiceModel, TModel> mappingExpression, Expression <Func <TServiceModel, TServiceModelProperty> > sourceMember, Expression <Func <TModel, TModelProperty> > destinationMember, bool ignoreNull = false) where TServiceModel : ServiceModelBase where TServiceModelProperty : ServiceModelBase where TModel : ModelBase where TModelProperty : ModelBase { // in stead of mapping the source property to the destination property, try to retrieve the already stored destination object from the database mappingExpression = mappingExpression.ForMember( destinationMember, options => options.ResolveUsing((serviceModel, model, modelProperty, resolutionContext) => { if (ignoreNull) { var func = sourceMember.Compile(); var sourceValue = func(serviceModel); if (sourceValue == null) { return(modelProperty); } } var value = serviceModel.FetchDestination <TServiceModel, TModelProperty, TServiceModelProperty>( resolutionContext, sourceMember); if (value == null) { var dataContext = GetDbContext(resolutionContext); var entry = dataContext.Entry(model); if (entry.State != EntityState.Detached) { entry.Reference(destinationMember.GetPropertyName()).Load(); model.SetPropertyValue(destinationMember, null); } } return(value); })); return(mappingExpression); }
public static IMappingExpression <TSource, TDestination> MapBaseContentTypeSaveToDisplay <TSource, TPropertyTypeSource, TDestination, TPropertyTypeDestination>( this IMappingExpression <TSource, TDestination> mapping) where TSource : ContentTypeSave <TPropertyTypeSource> where TDestination : ContentTypeCompositionDisplay <TPropertyTypeDestination> where TPropertyTypeDestination : PropertyTypeDisplay where TPropertyTypeSource : PropertyTypeBasic { var propertyGroupDisplayResolver = new PropertyGroupDisplayResolver <TSource, TPropertyTypeSource, TPropertyTypeDestination>(); return(mapping .ForMember(dest => dest.CreateDate, opt => opt.Ignore()) .ForMember(dest => dest.UpdateDate, opt => opt.Ignore()) .ForMember(dest => dest.ListViewEditorName, opt => opt.Ignore()) .ForMember(dest => dest.Notifications, opt => opt.Ignore()) .ForMember(dest => dest.Errors, opt => opt.Ignore()) .ForMember(dest => dest.LockedCompositeContentTypes, opt => opt.Ignore()) .ForMember(dest => dest.Groups, opt => opt.MapFrom(src => propertyGroupDisplayResolver.Resolve(src)))); }
public static IMappingExpression <TSource, TDestination> LimitStrings <TSource, TDestination>(this IMappingExpression <TSource, TDestination> expression) { var sourceType = typeof(TSource); var destinationType = typeof(TDestination); var existingMaps = Mapper.Configuration.GetAllTypeMaps().First(b => b.SourceType == sourceType && b.DestinationType == destinationType); var propertyMaps = existingMaps.PropertyMaps.Where(map => !map.Ignored && ((PropertyInfo)map.SourceMember).PropertyType == typeof(string)); foreach (var propertyMap in propertyMaps) { var attr = propertyMap.DestinationMember.GetCustomAttribute <MaxLengthAttribute>(); if (attr != null) { expression.ForMember(propertyMap.DestinationMember.Name, opt => opt.ConvertUsing(new StringLimiter(attr.Length), propertyMap.SourceMember.Name)); } } return(expression); }
/// <summary> /// 增加映射类到解析清单 /// </summary> /// <typeparam name="T">DAO(数据库实体类)</typeparam> /// <typeparam name="T2">DTO(传输实体类)</typeparam> /// <param name="members"></param> /// <returns></returns> private IMappingExpression <T, T2> AddMapper <T, T2>(string members = null) { IMappingExpression <T, T2> profile = _config.CreateMap <T, T2>(MemberList.None); if (string.IsNullOrWhiteSpace(members)) { return(profile); } string[] memberSet = members.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (string member in memberSet) { string[] memberExp = member.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries); string memberDTO = memberExp.First(); string memberDAO = memberExp.Last(); profile.ForMember(memberDTO, _ => _.MapFrom(memberDAO)); } ; return(profile); }
/// <summary> /// 忽略 目标对象 所有 存在于ignores中的字段 /// </summary> /// <param name="mapping"></param> /// <param name="ignores">需要忽略的字段</param> /// <returns></returns> internal static IMappingExpression IgnoreAllExisting(this IMappingExpression mapping, IReadOnlyList <string> ignores) { if (mapping == null) { return(mapping); } //获取需要忽略的字段 if (ignores != null && ignores.Count() > 0) { foreach (var item in ignores) { if (!string.IsNullOrWhiteSpace(item)) { mapping.ForMember(item, opton => opton.Ignore()); } } } return(mapping); }
private static void IgnoreUnmappedProperties(TypeMap map, IMappingExpression expr) { foreach (string propName in map.GetUnmappedPropertyNames()) { var srcPropInfo = map.SourceType.GetProperty(propName); if (srcPropInfo != null) { expr.ForSourceMember(propName, opt => opt.DoNotValidate()); } var destPropInfo = map.DestinationType.GetProperty(propName); if (destPropInfo != null) { expr.ForMember(propName, opt => opt.Ignore()); } } }
public static IMappingExpression <S, D> MapMember <S, D, TTo, TMember>( this IMappingExpression <S, D> map, Expression <Func <D, TTo> > to, Expression <Func <S, TMember> > from, Action <IMemberConfigurationExpression <S, D, TTo> > opts = null, bool skipEnsureMapping = false ) { map.ForMember(to, o => { o.MapFrom(from); if (opts != null) { opts(o); } }); return(map); }
public static IMappingExpression <TSource, TDestination> IgnoreChildEntityLists <TSource, TDestination>( this IMappingExpression <TSource, TDestination> expression) { var sourceType = typeof(TSource); foreach (var property in sourceType.GetProperties()) { if (property.PropertyType.IsSubtypeOfGeneric(typeof(IList <>))) { var genericArgument = property.PropertyType.GenericTypeArguments.FirstOrDefault(); if (genericArgument?.GetInterfaces().Contains(typeof(IEntity)) == true) { expression.ForMember(property.Name, opt => opt.Ignore()); } } } return(expression); }
public static IMappingExpression <TSource, TDestination> IgnoreReadOnly <TSource, TDestination>( this IMappingExpression <TSource, TDestination> expression) { var sourceType = typeof(TSource); var destProperties = typeof(TDestination).GetProperties(); foreach (var property in sourceType.GetProperties()) { if (destProperties.Where(x => x.Name == property.Name).FirstOrDefault() != null) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(sourceType)[property.Name]; ReadOnlyAttribute attribute = (ReadOnlyAttribute)descriptor.Attributes[typeof(ReadOnlyAttribute)]; if (attribute.IsReadOnly == true) { expression.ForMember(property.Name, opt => opt.Ignore()); } } } return(expression); }
/// <summary> /// 忽略所有未存在的 Mapping /// </summary> /// <typeparam name="TSource"></typeparam> /// <typeparam name="TDestination"></typeparam> /// <param name="expression"></param> /// <returns></returns> public static IMappingExpression <TSource, TDestination> IgnoreAllNonExisting <TSource, TDestination>(this IMappingExpression <TSource, TDestination> expression) { var sourceType = typeof(TSource); var destinationType = typeof(TDestination); try { var existMaps = Mapper.Instance.ConfigurationProvider.GetAllTypeMaps().First(x => x.SourceType.Equals(sourceType) && x.DestinationType.Equals(destinationType)); foreach (var property in existMaps.GetUnmappedPropertyNames()) { expression.ForMember(property, opt => opt.Ignore()); } } catch { // Do nothing } return(expression); }
public static IMappingExpression <TSource, TDest> MapCommon <TSource, TDest>(this IMappingExpression <TSource, TDest> mappingExpression) where TSource : PaymentsEvent where TDest : PaymentsEventModel { return(mappingExpression .ForMember(dest => dest.EventId, opt => opt.MapFrom(source => source.EventId)) .ForMember(dest => dest.CollectionPeriod, opt => opt.MapFrom(source => source.CollectionPeriod.Period)) .ForMember(dest => dest.AcademicYear, opt => opt.MapFrom(source => source.CollectionPeriod.AcademicYear)) .ForMember(dest => dest.EventTime, opt => opt.MapFrom(source => source.EventTime)) .ForMember(dest => dest.IlrSubmissionDateTime, opt => opt.MapFrom(source => source.IlrSubmissionDateTime)) .ForMember(dest => dest.JobId, opt => opt.MapFrom(source => source.JobId)) .ForMember(dest => dest.LearnerReferenceNumber, opt => opt.MapFrom(source => source.Learner.ReferenceNumber)) .ForMember(dest => dest.LearnerUln, opt => opt.MapFrom(source => source.Learner.Uln)) .ForMember(dest => dest.LearningAimPathwayCode, opt => opt.MapFrom(source => source.LearningAim.PathwayCode)) .ForMember(dest => dest.LearningAimFrameworkCode, opt => opt.MapFrom(source => source.LearningAim.FrameworkCode)) .ForMember(dest => dest.LearningAimFundingLineType, opt => opt.MapFrom(source => source.LearningAim.FundingLineType)) .ForMember(dest => dest.LearningAimProgrammeType, opt => opt.MapFrom(source => source.LearningAim.ProgrammeType)) .ForMember(dest => dest.LearningAimReference, opt => opt.MapFrom(source => source.LearningAim.Reference)) .ForMember(dest => dest.LearningAimStandardCode, opt => opt.MapFrom(source => source.LearningAim.StandardCode))); }
public static IMappingExpression <TSource, TDestination> IgnoreAllNonExisting <TSource, TDestination> (this IMappingExpression <TSource, TDestination> expression) { var sourceType = typeof(TSource); var destinationType = typeof(TDestination); var existingMaps = expression.TypeMap; foreach (var property in existingMaps.GetUnmappedPropertyNames()) { if (sourceType.GetProperty(property) != null) { expression.ForSourceMember(property, o => o.Ignore()); } if (destinationType.GetProperty(property) != null) { expression.ForMember(property, opt => opt.Ignore()); } } return(expression); }
private static IMappingExpression MappingCore(IMappingExpression coreMap, Type resolveActionType, string destName, string srcName) { if (resolveActionType == null) coreMap = coreMap.ForMember(destName, map => map.MapFrom(srcName)); else coreMap = coreMap.ForMember(destName, map => map.ResolveUsing(resolveActionType).FromMember(srcName)); return coreMap; }