public ConstructorOrderInfo(ConstructorInfo constructor, IReadOnlyDictionary <string, IConfigurationSection> availableMembers, IResolver resolver)
{
Constructor = constructor;
var parameters = constructor.GetParameters();
TotalParameters = parameters.Length;
if (TotalParameters == 0)
{
IsInvokableWithoutDefaultParameters = true;
IsInvokableWithDefaultParameters = true;
MissingParameterNames = Enumerable.Empty <string>();
MatchedParameters = 0;
}
else
{
bool HasAvailableValue(ParameterInfo p)
{
return(p.GetNames().Any(availableMembers.ContainsKey) || resolver.CanResolve(p));
}
IsInvokableWithoutDefaultParameters = parameters.Count(HasAvailableValue) == TotalParameters;
IsInvokableWithDefaultParameters = parameters.Count(p => HasAvailableValue(p) || p.HasDefaultValue) == TotalParameters;
MissingParameterNames = parameters.Where(p => !HasAvailableValue(p) && !p.HasDefaultValue).Select(p => p.Name);
MatchedParameters = parameters.Count(HasAvailableValue);
}
}
public bool CanResolve(ResolveContext context)
{
if (_instance != null)
{
return(true);
}
return(_innerResolver.CanResolve(context));
}
public static bool CanResolve(this IResolver resolver, Type contractType, string identifier)
{
return(resolver.CanResolve(new InjectionContext
{
Container = resolver.Container,
ContractType = contractType,
Identifier = identifier
}));
}
protected virtual bool CanResolveParameter(ResolveContext context, ParameterInfo parameterInfo)
{
var type = parameterInfo.ParameterType;
IResolver resolver = _locator.FindResolver(type);
if (resolver == null)
{
return(false);
}
var childContext = new ResolveContext(context, type);
return(resolver.CanResolve(childContext));
}
public object Get(InjectionContext context)
{
if (resolver.CanResolve(context))
{
return(resolver.Resolve(context));
}
else if (parent != null && parent.Resolver.CanResolve(context))
{
return(parent.Resolver.Resolve(context));
}
else if (instantiator.CanInstantiate(context))
{
return(instantiator.Instantiate(context));
}
else if (parent != null && parent.Instantiator.CanInstantiate(context))
{
return(parent.Instantiator.Instantiate(context));
}
else
{
return(null);
}
}
public static bool CanGet(this IResolver resolver, Type type, IConstraint constraint)
{
return(resolver.CanResolve(type, constraint));
}
public static bool CanGet(this IResolver resolver, Type type, string name)
{
return(resolver.CanResolve(type, new NameConstraint(name)));
}
public static bool CanGet(this IResolver resolver, Type type)
{
return(resolver.CanResolve(type, null));
}
public static bool CanGet <T>(this IResolver resolver, IConstraint constraint)
{
return(resolver.CanResolve(typeof(T), constraint));
}
public static bool CanGet <T>(this IResolver resolver, string name)
{
return(resolver.CanResolve(typeof(T), new NameConstraint(name)));
}
public static bool CanGet <T>(this IResolver resolver)
{
return(resolver.CanResolve(typeof(T), null));
}
public static bool CanResolve <TContract>(this IResolver resolver, string identifier)
{
return(resolver.CanResolve(typeof(TContract), identifier));
}
public static bool CanResolve <TContract>(this IResolver resolver)
{
return(resolver.CanResolve(typeof(TContract)));
}
public static bool CanResolve(this IResolver resolver, Type contractType)
{
return(resolver.CanResolve(contractType, ""));
}