private Expression VisitAllParametersExpression <T>(Expression <T> expression) { var visitors = ( from t in expression.Parameters let sourceParamType = t.Type from destParamType in _destSubTypes.Where(dt => dt != sourceParamType) let a = destParamType.IsGenericType() ? destParamType.GetTypeInfo().GenericTypeArguments[0] : destParamType let typeMap = _configurationProvider.FindTypeMapFor(a, sourceParamType) where typeMap != null let oldParam = t let newParam = Parameter(a, oldParam.Name) select new MappingVisitor(_configurationProvider, typeMap, oldParam, newParam, this)) .Cast <ExpressionVisitor>() .ToList(); return(visitors.Aggregate(expression as Expression, (e, v) => v.Visit(e))); }
public static string GetMappedOriginField <TEntity, T>(IConfigurationProvider mapper, string fieldName) => mapper ?.FindTypeMapFor <TEntity, T>() ?.PropertyMaps ?.FirstOrDefault(x => fieldName.Equals(x.DestinationName, StringComparison.OrdinalIgnoreCase)) ?.SourceMember ?.Name ?? fieldName;
public static TypeMap CheckIfMapExists(this IConfigurationProvider config, Type sourceType, Type destinationType) { var typeMap = config.FindTypeMapFor(sourceType, destinationType); if (typeMap == null) { throw MissingMapException(sourceType, destinationType); } return(typeMap); }
protected override Expression VisitUnary(UnaryExpression node) { if (node.NodeType == ExpressionType.Convert) { var replacingExpression = Visit(node.Operand); if (replacingExpression.Type != node.Operand.Type) { var typeMap = _configurationProvider.FindTypeMapFor(replacingExpression.Type, node.Type); if (typeMap != null && typeMap.CustomProjection != null) { replacingExpression = typeMap.CustomProjection.ConvertReplaceParameters(replacingExpression); } else if (replacingExpression.Type.CanImplicitConvert(node.Type)) { replacingExpression = Convert(replacingExpression, node.Type); } return(Convert(replacingExpression, node.Type)); } //if (node.Type != node.Operand.Type) //{ // return Convert(node.Operand, node.Operand.Type); //} var call = node.Operand as MethodCallExpression; if (call != null) { //var convertedMethod = GetConvertedMethodCall(call); //if (convertedMethod.Type != node.Type) //{ // return Visit(Convert(convertedMethod, node.Type)); //} //return Visit(convertedMethod); } } return(base.VisitUnary(node)); }
private Expression VisitAllParametersExpression<T>(Expression<T> expression) { var visitors = new List<ExpressionVisitor>(); for (var i = 0; i < expression.Parameters.Count; i++) { var sourceParamType = expression.Parameters[i].Type; foreach (var destParamType in _destSubTypes.Where(dt => dt != sourceParamType)) { var a = destParamType.IsGenericType() ? destParamType.GetTypeInfo().GenericTypeArguments[0]: destParamType; var typeMap = _configurationProvider.FindTypeMapFor(a, sourceParamType); if (typeMap == null) continue; var oldParam = expression.Parameters[i]; var newParam = Expression.Parameter(a, oldParam.Name); visitors.Add(new MappingVisitor(_configurationProvider, typeMap, oldParam, newParam, this)); } } return visitors.Aggregate(expression as Expression, (e, v) => v.Visit(e)); }
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); }
private bool canMap(Type srcType, Type destType) { if (destType.IsAssignableFrom(srcType)) { return(true); } // This is based on code in MappingEngine's IMappingEngineRunner.Map method var context = new ResolutionContext( _mappingConfig.FindTypeMapFor(null, srcType, destType), null, srcType, destType ); return(_mappingConfig.GetMappers().Any(mapper => mapper.IsMatch(context))); }
private static IEnumerable <TypeMap> GetIncludedTypeMaps(IEnumerable <TypePair> includedTypes, IConfigurationProvider configurationProvider) { foreach (var pair in includedTypes) { var typeMap = configurationProvider.FindTypeMapFor(pair); if (typeMap != null) { yield return(typeMap); } typeMap = configurationProvider.ResolveTypeMap(pair); // we want the exact map the user included, but we could instantiate an open generic if (typeMap == null || typeMap.Types != pair || typeMap.IsConventionMap) { throw QueryMapperHelper.MissingMapException(pair); } yield return(typeMap); } }
private void Configure(ITypeMapConfiguration typeMapConfiguration, IConfigurationProvider configurationProvider) { var typeMap = configurationProvider.FindTypeMapFor(typeMapConfiguration.Types); Configure(typeMap, configurationProvider); }
/// <summary> /// 是否已存在映射配置 /// </summary> private static bool Exists(Type sourceType, Type destinationType) { return(_config?.FindTypeMapFor(sourceType, destinationType) != null); }
/// <summary> /// Determines whether [has map for] [the specified source]. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="source">The source.</param> /// <param name="destination">The destination.</param> /// <param name="includeObjectMappers">if set to <c>true</c> [include object mappers].</param> /// <returns> /// <c>true</c> if the ocnfiguration has map for the specified source and destination types; otherwise, <c>false</c>. /// </returns> public static bool HasMapFor(this IConfigurationProvider configuration, Type source, Type destination, bool includeObjectMappers = true) { return(source == destination || (configuration.FindTypeMapFor(source, destination) != null) || includeObjectMappers && configuration.CoveredByObjectMap(source, destination)); }
/// <summary> /// 获取对应源对象和目标对象的映射TypeMap /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <returns></returns> private static TypeMap GetTypeMap(Type source, Type destination) { return(_mapperConfig.FindTypeMapFor(source, destination)); }
private static void SetSealed(IConfigurationProvider cfg) { // If sealed _typeMapCache is filled and should be able to Resolve tye TypeMap // If not sealed _typeMapCache is empty and should return null _sealed = cfg.FindTypeMapFor(typeof(PlaceHolder), typeof(PlaceHolder)) != null; }