private static void Validate(ValidationTarget validationTarget, ServiceMap serviceMap, ICollection <ValidationResult> result)
{
var registration = GetServiceRegistration(serviceMap, validationTarget);
if (registration == null)
{
if (validationTarget.ServiceType.IsFunc() || validationTarget.ServiceType.IsLazy())
{
var serviceType = validationTarget.ServiceType.GenericTypeArguments[0];
var underlyingvalidationTarget = validationTarget.WithServiceDescription(serviceType, string.Empty);
registration = GetServiceRegistration(serviceMap, underlyingvalidationTarget);
if (registration != null)
{
return;
}
if (serviceMap.ContainsAmbiguousRegistrationFor(serviceType))
{
result.Add(new ValidationResult("", ValidationSeverity.Ambiguous, underlyingvalidationTarget));
}
else
{
string message = string.Format(MissingDeferredDependency, validationTarget.ServiceType, underlyingvalidationTarget.ServiceType);
result.Add(new ValidationResult(message, ValidationSeverity.MissingDependency, underlyingvalidationTarget));
}
}
else if (validationTarget.ServiceType.IsGenericType && validationTarget.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
var serviceType = validationTarget.ServiceType.GenericTypeArguments[0];
var underlyingvalidationTarget = validationTarget.WithServiceDescription(serviceType, string.Empty);
var registrations = GetServiceRegistrations(serviceMap, underlyingvalidationTarget);
if (registrations.Any())
{
return;
}
// strict: there has to be at least 1
string message = string.Format(MissingDeferredDependency, validationTarget.ServiceType, underlyingvalidationTarget.ServiceType);
result.Add(new ValidationResult(message, ValidationSeverity.MissingDependency, underlyingvalidationTarget));
}
else
{
if (serviceMap.ContainsAmbiguousRegistrationFor(validationTarget.ServiceType))
{
result.Add(new ValidationResult("", ValidationSeverity.Ambiguous, validationTarget));
}
else
{
result.Add(new ValidationResult("", ValidationSeverity.MissingDependency, validationTarget));
}
}
}
else
{
ValidateDisposable(validationTarget, result, registration);
ValidateLifetime(validationTarget, registration, result);
}
}
private static void ValidateLifetime(ValidationTarget validationTarget, ServiceRegistration dependencyRegistration, ICollection <ValidationResult> result)
{
if (GetLifespan(validationTarget.DeclaringService.Lifetime) > GetLifespan(dependencyRegistration.Lifetime))
{
var message = string.Format(CaptiveDependency, dependencyRegistration.ServiceType,
validationTarget.DeclaringService.ServiceType, GetLifetimeName(dependencyRegistration.Lifetime),
GetLifetimeName(validationTarget.DeclaringService.Lifetime));
result.Add(new ValidationResult(message, ValidationSeverity.Captive, validationTarget));
}
}
private static IReadOnlyCollection <ValidationResult> ValidateConstructor(ServiceMap serviceMap,
ServiceRegistration serviceRegistration, ConstructorInfo constructorInfo)
{
var result = new Collection <ValidationResult>();
foreach (var parameter in constructorInfo.GetParameters())
{
var validationTarget = new ValidationTarget(serviceRegistration, parameter);
Validate(validationTarget, serviceMap, result);
}
return(result);
}
private static void ValidateDisposable(ValidationTarget validationTarget, ICollection <ValidationResult> result,
ServiceRegistration registration)
{
if (registration.ServiceType.Implements <IDisposable>())
{
var message = string.Format(NotDisposeMessageServiceType, registration.ServiceType,
validationTarget.DeclaringService.ImplementingType);
result.Add(new ValidationResult(message, ValidationSeverity.NotDisposed, validationTarget));
}
else if (registration.ImplementingType != null && registration.ImplementingType.Implements <IDisposable>())
{
var message = string.Format(NotDisposeMessageImplementingType, registration.ImplementingType,
registration.ServiceType,
validationTarget.DeclaringService.ImplementingType);
result.Add(new ValidationResult(message, ValidationSeverity.NotDisposed, validationTarget));
}
}
public ValidationResult(string message, ValidationSeverity severity, ValidationTarget validationTarget)
{
Message = message;
Severity = severity;
ValidationTarget = validationTarget;
}
private static ServiceRegistration GetServiceRegistration(ServiceMap serviceMap, ValidationTarget validationTarget)
{
if (!serviceMap.TryGetValue(validationTarget.ServiceType, out var registrations))
{
return(null);
}
if (registrations.TryGetValue(string.Empty, out var registration))
{
return(registration);
}
if (registrations.Count == 1)
{
return(registrations.Values.First());
}
if (registrations.TryGetValue(validationTarget.ServiceName, out registration))
{
return(registration);
}
return(null);
}
private static IEnumerable <ServiceRegistration> GetServiceRegistrations(ServiceMap serviceMap, ValidationTarget validationTarget)
{
return(serviceMap.Where(x => validationTarget.ServiceType.IsAssignableFrom(x.Key)).SelectMany(x => x.Value.Values));
}
