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