/// <summary>
/// 装配
/// </summary>
/// <param name="classType"></param>
/// <param name="type"></param>
/// <param name="context"></param>
/// <param name="typeDescription"></param>
/// <returns></returns>
/// <exception cref="DependencyResolutionException"></exception>
private object Resolve(Type classType, Type type, IComponentContext context, string typeDescription)
{
object obj = null;
if (!string.IsNullOrEmpty(this.Name))
{
context.TryResolveKeyed(this.Name, type, out obj);
}
else
{
if (type.IsGenericEnumerableInterfaceType())
{
var genericType = type.GenericTypeArguments[0];
if (genericType.FullName != null && genericType.FullName.StartsWith("System.Lazy`1"))
{
genericType = genericType.GenericTypeArguments[0];
}
context.TryResolveKeyed("`1System.Collections.Generic.IEnumerable`1" + genericType.FullName, type, out obj);
}
else
{
context.TryResolve(type, out obj);
}
}
if (obj == null && this.Required)
{
throw new DependencyResolutionException($"Autowire error,can not resolve class type:{classType.FullName},${typeDescription} name:{type.Name} "
+ (!string.IsNullOrEmpty(this.Name) ? $",with key:[{this.Name}]" : ""));
}
return(obj);
}
public (bool Successful, object Value) Resolve(IComponentContext context, InjectResolverParam param)
{
var type = param.Type;
var attr = param.Attribute;
var key = attr.Key;
if (key != null)
{
if (context.TryResolveKeyed(key, type, out var value))
{
return(true, value);
}
Assertion.IsTrue(!attr.Required, $"required inject type {type.Name} with key {key} not resolved.");
return(false, null);
}
{
if (context.TryResolve(type, out var value))
{
return(true, value);
}
Assertion.IsTrue(!attr.Required, $"required inject type {type.Name} not resolved.");
return(false, null);
}
}
/// <summary>Resolves a constructor parameter based on keyed service requirements.
/// </summary>
/// <param name="parameter">The specific parameter being resolved that is marked with this attribute.</param>
/// <param name="context">The component context under which the parameter is being resolved.</param>
/// <returns>The instance of the object that should be used for the parameter value.
/// </returns>
/// <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="parameter"/> or <paramref name="context"/> is <see langword="null"/>.</exception>
public override object ResolveParameter(ParameterInfo parameter, IComponentContext context)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
var options = context.Resolve <IOptions>();
var key = "console";
if (!string.IsNullOrEmpty(options.Csv))
{
key = "csv";
}
else if (options.Daemon)
{
key = "daemon";
}
object obj;
context.TryResolveKeyed(key, parameter.ParameterType, out obj);
return(obj);
}
public static TService ResolveKeyedOrAny <TService, TKey>(this IComponentContext instance, TKey key)
{
object service = null;
return(instance.TryResolveKeyed(key, typeof(TService), out service)
? (TService)service
: instance.Resolve <TService>());
}
private static bool TryResolveAtScope(IComponentContext scope, string key, Type serviceType, out object value)
{
if (scope != null)
{
return(key == null
? scope.TryResolve(serviceType, out value)
: scope.TryResolveKeyed(key, serviceType, out value));
}
value = null;
return(false);
}
public static TInterface ResolveClient <TInterface>(IComponentContext cxt, string ept, string providerName)
{
if (providerName == null)
{
providerName = string.Empty;
}
object result = null;
cxt.TryResolveKeyed(ept + providerName, typeof(TInterface), out result); // Not an error if not resolved.
return((TInterface)result);
}
private static object ResolveWithVersioning(ParameterInfo pi, IComponentContext ctx)
{
var versionService = ctx.Resolve <IVersionService>();
string version = versionService.CurrentVersion ?? versionService.DefaultVersion;
object result;
if (ctx.TryResolveKeyed(version, pi.ParameterType, out result))
{
return(result);
}
return(ctx.Resolve(pi.ParameterType));
}
/// <summary>
/// Resolves a constructor parameter based on keyed service requirements.
/// </summary>
/// <param name="parameter">The specific parameter being resolved that is marked with this attribute.</param>
/// <param name="context">The component context under which the parameter is being resolved.</param>
/// <returns>
/// The instance of the object that should be used for the parameter value.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="parameter" /> or <paramref name="context" /> is <see langword="null" />.
/// </exception>
public override object?ResolveParameter(ParameterInfo parameter, IComponentContext context)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.TryResolveKeyed(Key, parameter.ParameterType, out var value);
return(value);
}
/// <summary>
/// Resolves a constructor parameter based on keyed service requirements.
/// </summary>
/// <param name="parameter">The specific parameter being resolved that is marked with this attribute.</param>
/// <param name="context">The component context under which the parameter is being resolved.</param>
/// <returns>
/// The instance of the object that should be used for the parameter value.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="parameter" /> or <paramref name="context" /> is <see langword="null" />.
/// </exception>
public override object ResolveParameter(ParameterInfo parameter, IComponentContext context)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
object value;
context.TryResolveKeyed(this.Key, parameter.ParameterType, out value);
return(value);
}
/// <summary>
/// 装配
/// </summary>
/// <param name="classType"></param>
/// <param name="type"></param>
/// <param name="context"></param>
/// <param name="typeDescription"></param>
/// <returns></returns>
/// <exception cref="DependencyResolutionException"></exception>
private object Resolve(Type classType, Type type, IComponentContext context, string typeDescription)
{
object obj = null;
if (!string.IsNullOrEmpty(this.Name))
{
context.TryResolveKeyed(this.Name, type, out obj);
}
else
{
context.TryResolve(type, out obj);
}
if (obj == null && this.Required)
{
throw new DependencyResolutionException($"Autowire error,can not resolve class type:{classType.FullName},${typeDescription} name:{type.Name} "
+ (!string.IsNullOrEmpty(this.Name) ? $",with key:[{this.Name}]" : ""));
}
return(obj);
}
/// <summary>
/// Resolves a constructor parameter based on keyed service requirements.
/// </summary>
/// <param name="parameter">The specific parameter being resolved that is marked with this attribute.</param>
/// <param name="context">The component context under which the parameter is being resolved.</param>
/// <returns>
/// The instance of the object that should be used for the parameter value.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="parameter" /> or <paramref name="context" /> is <see langword="null" />.
/// </exception>
public override object ResolveParameter(ParameterInfo parameter, IComponentContext context)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
object value;
context.TryResolveKeyed(this.Key, parameter.ParameterType, out value);
return value;
}