/// <summary>
/// Gets a Dictionary of errors and their corresponding types to help diagnose possible issues
/// that resulted in the ContainerResolutionException.
/// </summary>
/// <returns>A <see cref="Dictionary{Type, Exception}"/> mapping types that encountered given exceptions in the resolution process.</returns>
public ContainerResolutionErrorCollection GetErrors()
{
var errors = new ContainerResolutionErrorCollection();
if (IsKnownIssue)
{
return(errors);
}
var implementingType = TryFindImplementingType();
if (implementingType is null)
{
errors.Add(ServiceType, new ContainerResolutionException(ServiceType, MissingRegistration));
return(errors);
}
else if (implementingType.IsAbstract)
{
errors.Add(ServiceType, new ContainerResolutionException(implementingType, CannotResolveAbstractType));
}
PopulateErrors(implementingType, ref errors);
return(errors);
}
static void PopulateErrors(Type implementingType, ref ContainerResolutionErrorCollection errors)
{
var ctors = implementingType.GetConstructors();
if (ctors.Length > 1)
{
errors.Add(implementingType, new ContainerResolutionException(implementingType, MultipleConstructors));
}
else if (ctors.Length == 0)
{
errors.Add(implementingType, new ContainerResolutionException(implementingType, NoPublicConstructors));
return;
}
var ctor = ctors.OrderByDescending(x => x.GetParameters().Length).FirstOrDefault();
var parameters = ctor.GetParameters();
var parameterInstances = new List <object>();
var container = ContainerLocator.Current;
foreach (var parameter in parameters)
{
try
{
var defaultImplementingType = IsConcreteType(parameter.ParameterType) ? parameter.ParameterType : null;
var parameterImplementingType = container.GetRegistrationType(parameter.ParameterType);
if (parameterImplementingType is null)
{
throw new ContainerResolutionException(parameter.ParameterType, MissingRegistration);
}
var instance = container.Resolve(parameter.ParameterType);
parameterInstances.Add(instance);
}
catch (Exception ex)
{
// TODO: Add Exceptions Extensions lookup here to get root Exception
errors.Add(parameter.ParameterType, ex);
if (ex is ContainerResolutionException cre && !cre.IsKnownIssue)
{
foreach (var subError in cre.GetErrors())
{
errors.Add(subError.Key, subError.Value);
}
}
}
}
// Return if we had an error with any children
if (parameters.Length != parameterInstances.Count)
{
return;
}
try
{
// We generally expect some sort of InvokationException Exception here...
ctor.Invoke(parameterInstances.ToArray());
// If we managed to create an instance for every parameter and the
// constructor didn't throw an exception when activating the instance
// we really aren't sure what allowed us to get here...
throw new ContainerResolutionException(implementingType, UnknownError);
}
catch (TargetInvocationException tie)
{
errors.Add(implementingType, tie);
if (tie.InnerException != null)
{
errors.Add(implementingType, tie.InnerException);
}
}
catch (Exception ex)
{
errors.Add(implementingType, ex);
}
}