private static void _resolveProperties(object instance, ResolvingContextExpandingHelper helperContext, TypeResolverTypeMapping mapping, TypeResolverTypeMappingContext context, Type target, List <TypeResolverOption> options) { }
private bool _exists(string name, out TypeResolverTypeMappingContext context) { if (!Mappings.ContainsKey(name)) { context = null; return(false); } context = Mappings[name]; return(true); }
public TypeResolverTypeMappingContext RegisterType(Type type, object[] options, bool addToList = true) { var fullName = type?.FullName; var result = new TypeResolverTypeMappingContext(fullName, null, options) { ToType = type, ToName = fullName, MappingType = MappingType.Resolve }; if (addToList) { RegisterContext(result); } return(result); }
public static void UnBindUnion(TypeResolverTypeMapping mapping, TypeResolverTypeMappingContext context) { HashSet <string> uniques; HashSet <string> optionals; _createKeyHashSet(context, out uniques, out optionals); foreach (var key in uniques) { mapping.Mappings.Remove(key); } foreach (var key in optionals) { mapping.Mappings.Remove(key); } }
public TypeResolverTypeMappingContext RegisterType(Type type, Func <Type, object> factory, bool cacheInstance, object[] options, bool addToList = true) { var fullName = type?.FullName; var result = new TypeResolverTypeMappingContext(fullName, null, options) { ToType = type, ToName = fullName, Factory2 = factory, FactoryCache = cacheInstance, MappingType = MappingType.Factory }; if (addToList) { RegisterContext(result); } return(result); }
public static void BindUnion(TypeResolverTypeMapping mapping, TypeResolverTypeMappingContext context) { HashSet <string> uniques; HashSet <string> optionals; _createKeyHashSet(context, out uniques, out optionals); foreach (var key in uniques) { mapping.Mappings.Add(key, context); } foreach (var key in optionals) { if (!mapping.Mappings.ContainsKey(key)) { mapping.Mappings.Add(key, context); } } }
public TypeResolverTypeMappingContext RegisterType(Type fromType, Type toType, object[] options, bool addToList = true) { var fromFullName = fromType?.FullName; var toFullName = toType?.FullName; var result = new TypeResolverTypeMappingContext(fromFullName, new[] { toFullName }, options) { FromType = fromType, FromName = fromFullName, ToType = toType, ToName = toFullName, MappingType = MappingType.Resolve }; if (addToList) { RegisterContext(result); } return(result); }
private static void _createKeyHashSet( TypeResolverTypeMappingContext context, out HashSet <string> uniques, out HashSet <string> optionals) { uniques = new HashSet <string>(); optionals = new HashSet <string>(); if (context.BindingStrongName != null) { uniques.Add(context.BindingStrongName); } if (context.FromName != null) { uniques.Add(context.FromName); } if (context.ToName != null) { optionals.Add(context.ToName); } if (context.FromType != null) { uniques.Add(context.FromType.FullName); } if (context.ToType != null) { optionals.Add(context.ToType.FullName); } foreach (var name in context.BindingNames) { uniques.Add(name); } }
public void RegisterContext(TypeResolverTypeMappingContext context) { TypeResolverTypeMappingContext.BindUnion(this, context); }
public TypeResolverTypeMappingContextWrapper(TypeResolverTypeMappingContext context) { Context = context; }
private static bool _recursiveCanResolve(TypeResolverTypeMapping mapping, TypeResolverTypeMappingContext context, Type target, List <TypeResolverOption> options) { return(false); }
private static object _recursiveResolve( ResolvingContextExpandingHelper helperContext, TypeResolverTypeMapping mapping, ITypeResolver resolver, TypeResolverTypeMappingContext context, Type target, Type @override, List <TypeResolverOption> options) { var requestedType = @override ?? context.ToType ?? context.FromType; var requestedTypeInfo = requestedType.GetTypeInfo(); if (requestedTypeInfo.IsInterface) { Logger.Default.Log( $"Unable to create an interface, target:{target.FullName}, resolvingType:{requestedType.FullName}"); return(null); } if (requestedTypeInfo.IsAbstract) { Logger.Default.Log( $"Unable to create an abstract class, target:{target.FullName}, resolvingType:{requestedType.FullName}"); return(null); } var constructor = _getConstructor( mapping: mapping, context: helperContext, requestedType: requestedType, requestedTypeInfo: requestedTypeInfo); if (constructor == null) { Logger.Default.Log( $"No suitable constructor found, target:{target.FullName}, resolvingType:{requestedType.FullName}"); return(null); } var parameters = new List <object>(); { foreach (var p in constructor.Parameters) { var pInfo = p.ParameterInfo; var pType = pInfo.ParameterType; if (pType == target) { Logger.Default.Log( $"Circular dependency detected, parameter:{pInfo.Name}({p.Name}) from target:{target.FullName}, resolvingType:{requestedType.FullName}"); return(null); } switch (p.ResolvingHint) { case ValueResolvingSourceHint.CurrentContextMappings: { object objInstance = null; if (helperContext.CurrentContextMapping != null) { var objContext = helperContext.CurrentContextMapping.GetContext(pType); objInstance = objContext.Instance; if (objInstance != null) { parameters.Add(objInstance); } else { objInstance = helperContext.CurrentContextMapping.CreateInstance(resolver, pType, options.Cast <object>().ToArray()); if (objInstance != null) { parameters.Add(objInstance); } } } if (objInstance == null) { Logger.Default.Log( $"Failed to resolve parameter, parameter:{pInfo.Name}({p.Name}) from target:{pType.FullName}, resolvingType:{requestedType.FullName}"); return(null); } break; } case ValueResolvingSourceHint.ValueProvider: var value = p.ValueProvider.ValueProviderFactory( TypeResolverDestinationType.ConstructorParameter, pType, p.Name); //if (value == null) return null; parameters.Add(value); break; case ValueResolvingSourceHint.NamedConstants: parameters.Add(helperContext.NamedValues.First(x => x.ParameterName == p.Name) .ParameterValue); break; case ValueResolvingSourceHint.TypedConstants: parameters.Add( helperContext.TypedValues.First(x => x.ParameterType == pType).ParameterValue); break; case ValueResolvingSourceHint.Mappings: { var resolved = _createInstance(mapping, resolver, pType, options); if (resolved == null) { Logger.Default.Log( $"Failed to resolve parameter, parameter:{pInfo.Name}({p.Name}) from target:{pType.FullName}, resolvingType:{requestedType.FullName}"); return(null); } parameters.Add(resolved); break; } case ValueResolvingSourceHint.DefaultValue: parameters.Add(Activator.CreateInstance(pType)); break; case ValueResolvingSourceHint.ParameterOptionalDefaultValue: parameters.Add(pInfo.DefaultValue); break; case ValueResolvingSourceHint.DefaultConstructor: { var resolved = p.IsDefaultConstructorHint ? TypeResolver.Default.Resolve(pType) : _createInstance(mapping, resolver, pType, options); if (resolved == null) { if (p.UseDefaultValue) { parameters.Add(Activator.CreateInstance(pType)); } else { Logger.Default.Log( $"Failed to resolve parameter using default constructor, parameter:{pInfo.Name}({p.Name}) from target:{pType.FullName}, resolvingType:{requestedType.FullName}" ); return(null); } } else { parameters.Add(resolved); } break; } default: throw new ArgumentOutOfRangeException(); } } } object instance; try { instance = constructor.ConstructorInfo.Invoke(parameters.ToArray()); } catch (Exception ex) { Logger.Default.Log( $"An error has been occured when try to invoke constructor, target:{target.FullName}, resolvingType:{requestedType.FullName}" + Environment.NewLine + $"Original exception:{ex}"); throw; } _resolveProperties(instance, helperContext, mapping, context, target, options); return(instance); }