private static void _resolvingLazyServicesHandler(object sender, UnregisteredTypeEventArgs e)
{
var type = e.UnregisteredServiceType;
var container = sender as Container;
if (!type.IsGenericType ||
type.GetGenericTypeDefinition() != typeof(Lazy <>))
{
return;
}
Type serviceType = type.GetGenericArguments().First();
InstanceProducer registration = container
.GetRegistration(serviceType, true);
registration.Registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent, "Ignored during automatic Lazy Registration");
Type funcType =
typeof(Func <>).MakeGenericType(serviceType);
Type lazyType =
typeof(Lazy <>).MakeGenericType(serviceType);
var funcExpression = Expression.Lambda(funcType,
registration.BuildExpression());
var lazyDelegate = Expression.Lambda(lazyType,
Expression.New(lazyType.GetConstructor(new[] { funcType }), funcExpression)).Compile();
e.Register(Expression.Constant(lazyDelegate));
}
private void Container_ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
var emptyValidator = Container.GetInstance(e.UnregisteredServiceType);
// Register the instance as singleton.
e.Register(() => emptyValidator);
}
private static void _resolvingFuncFactoriesHandler(object sender, UnregisteredTypeEventArgs e)
{
var type = e.UnregisteredServiceType;
var container = sender as Container;
if (!type.IsGenericType ||
type.GetGenericTypeDefinition() != typeof(Func <>))
{
return;
}
Type serviceType = type.GetGenericArguments().First();
InstanceProducer producer = container
.GetRegistration(serviceType, true);
producer.Registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent, "Ignored during automatic Func Registration");
Type funcType =
typeof(Func <>).MakeGenericType(serviceType);
var factoryDelegate = Expression.Lambda(funcType,
producer.BuildExpression()).Compile();
var registration = Lifestyle.Singleton.CreateRegistration(funcType, () => factoryDelegate, (Container)sender);
e.Register(registration);
}
private static void _resolveCollectionsHandler(object sender, UnregisteredTypeEventArgs e)
{
var container = sender as Container;
// Only handle IEnumerable<>.
// Works only with GetAllInstances
if (!e.UnregisteredServiceType.IsGenericType ||
e.UnregisteredServiceType.GetGenericTypeDefinition() != typeof(IEnumerable <>))
{
return;
}
Type serviceType = e.UnregisteredServiceType.GetGenericArguments()[0];
var registrations = (
from r in container.GetCurrentRegistrations()
where r.ServiceType == r.Registration.ImplementationType && serviceType.IsAssignableFrom(r.Registration.ImplementationType)
select r)
.ToArray();
if (registrations.Any())
{
var instances = registrations.Select(r => r.GetInstance());
var castMethod = typeof(Enumerable).GetMethod("Cast")
.MakeGenericMethod(serviceType);
var castedInstances = castMethod.Invoke(null, new[] { instances });
e.Register(() => castedInstances);
}
}
private void LinkToParentContainer(object sender, UnregisteredTypeEventArgs args)
{
if (!args.Handled)
{
args.Register(() => _parentContainer.GetInstance(args.UnregisteredServiceType));
}
}
private static void ResolveEvent(object sender, UnregisteredTypeEventArgs e)
{
if (e.Handled ||
e.UnregisteredServiceType.GetCustomAttributes <EventAttribute>() == null ||
!(sender is Container container))
{
return;
}
var foundEvent = false;
for (Type current = e.UnregisteredServiceType; current != null; current = current.BaseType)
{
if (current.IsGenericType)
{
Type gen = current.GetGenericTypeDefinition();
if (gen == EventType)
{
foundEvent = true;
break;
}
}
}
if (!foundEvent)
{
return;
}
(ConstructorInfo constructor, Type eventLoopType) =
(from candidate in e.UnregisteredServiceType.GetConstructors()
let parameters = candidate.GetParameters()
where parameters.Length == 1
let parameter = parameters[0]
where !parameter.IsIn && !parameter.IsOut && !parameter.IsRetval &&
EventLoopType.IsAssignableFrom(parameter.ParameterType)
select(candidate, parameter.ParameterType)).FirstOrDefault();
if (constructor == null)
{
return;
}
Expression containerExpression = Expression.Constant(container);
Expression eventLoopExpression = Expression.Call(
containerExpression,
GetInstanceMethod.MakeGenericMethod(eventLoopType)
);
Expression eventExpression = Expression.New(constructor, eventLoopExpression);
Expression convertExpression = Expression.Convert(eventExpression, typeof(object));
var lambda = Expression.Lambda <Func <object> >(convertExpression);
Func <object> instanceCreator = lambda.Compile();
Registration registration = Lifestyle.Singleton.CreateRegistration(
e.UnregisteredServiceType, instanceCreator, container);
e.Register(registration);
}
private void RegisterType(UnregisteredTypeEventArgs e, Type closedGenericImplementation)
{
var registration =
this.GetRegistrationFromCache(e.UnregisteredServiceType, closedGenericImplementation);
this.ThrowWhenExpressionCanNotBeBuilt(registration, closedGenericImplementation);
e.Register(registration);
}
private static void RegisterArrayResolver(UnregisteredTypeEventArgs e, Container container, Type elementType)
{
var producer = container.GetRegistration(typeof(IEnumerable <>).MakeGenericType(elementType));
var enumerableExpression = producer.BuildExpression();
var arrayMethod = typeof(Enumerable).GetMethod("ToArray").MakeGenericMethod(elementType);
var arrayExpression = Expression.Call(arrayMethod, enumerableExpression);
e.Register(arrayExpression);
}
public void RegisterFunc_WithNullArgument_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
Func <object> invalidFunc = null;
// Act
e.Register(invalidFunc);
}
public void RegisterExpression_WithNullArgument_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
Expression invalidExpression = null;
// Act
e.Register(invalidExpression);
}
public void RegisterFunc_CalledTwice_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
e.Register(() => null);
// Act
e.Register(() => null);
}
public void RegisterFunc_CalledAfterCallingRegisterExpression_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
e.Register(Expression.Constant(null));
// Act
e.Register(() => null);
}
public void RegisterFunc_CalledAfterCallingRegisterExpression_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
e.Register(Expression.Constant(null));
// Act
Action action = () => e.Register(() => null);
// Assert
AssertThat.Throws <ActivationException>(action);
}
public void RegisterFunc_CalledTwice_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
e.Register(() => null);
// Act
Action action = () => e.Register(() => null);
// Assert
AssertThat.Throws <ActivationException>(action);
}
public void RegisterExpression_WithNullArgument_ThrowsException()
{
// Arrange
var e = new UnregisteredTypeEventArgs(typeof(IUserRepository));
Expression invalidExpression = null;
// Act
Action action = () => e.Register(invalidExpression);
// Assert
AssertThat.Throws <ArgumentNullException>(action);
}
private static void Container_ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
if (typeof(IPlugin).IsAssignableFrom(e.UnregisteredServiceType))
{
var pluginType = e.UnregisteredServiceType;
var constructor = pluginType.GetConstructors().Single();
var parameters = constructor.GetParameters()
.Select(p => container.GetInstance(p.ParameterType)).ToArray();
e.Register(() => constructor.Invoke(parameters));
//e.Register(() => Activator.CreateInstance(e.UnregisteredServiceType));
}
}
private InstanceProducer?TryGetInstanceProducerThroughResolveUnregisteredTypeEvent(Type serviceType)
{
if (!this.shouldResolveUnregisteredTypes())
{
return(null);
}
var e = new UnregisteredTypeEventArgs(serviceType);
this.resolveUnregisteredType(e);
return(e.Handled
? this.TryGetProducerFromUnregisteredTypeResolutionCacheOrAdd(e)
: null);
}
internal void ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
if (typeof(IEnumerable <>).IsGenericTypeDefinitionOf(e.UnregisteredServiceType))
{
Type closedServiceType = e.UnregisteredServiceType.GetGenericArguments().Single();
if (this.ServiceType.IsGenericTypeDefinitionOf(closedServiceType))
{
var producer = this.GetInstanceProducerFromCache(closedServiceType);
if (producer != null)
{
e.Register(producer.Registration);
}
}
}
}
internal void ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
if (typeof(IEnumerable<>).IsGenericTypeDefinitionOf(e.UnregisteredServiceType))
{
Type closedServiceType = e.UnregisteredServiceType.GetGenericArguments().Single();
if (this.ServiceType.IsGenericTypeDefinitionOf(closedServiceType))
{
var producer = this.GetInstanceProducerFromCache(closedServiceType);
if (producer != null)
{
e.Register(producer.Registration);
}
}
}
}
internal void ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
if (typeof(IEnumerable <>).IsGenericTypeDefinitionOf(e.UnregisteredServiceType))
{
Type closedServiceType = e.UnregisteredServiceType.GetGenericArguments().Single();
if (this.OpenGenericServiceType.IsGenericTypeDefinitionOf(closedServiceType))
{
Registration registration;
if (this.TryGetContainerControlledRegistrationFromCache(closedServiceType, out registration))
{
e.Register(registration);
}
}
}
}
private void OnResolveUnregisteredType(Container container, UnregisteredTypeEventArgs e)
{
if (!e.UnregisteredServiceType.IsGenericType)
{
return;
}
Type genericTypeDef = e.UnregisteredServiceType.GetGenericTypeDefinition();
if (IsSupportedCollectionType(genericTypeDef))
{
Type elementType = e.UnregisteredServiceType.GetGenericArguments().First();
Type newCollection = typeof(List <>).MakeGenericType(elementType);
object instance = Activator.CreateInstance(newCollection);
e.Register(Lifestyle.Singleton.CreateRegistration(newCollection, instance, container));
}
}
internal void ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
if (!this.OpenGenericServiceType.IsGenericTypeDefinitionOf(e.UnregisteredServiceType))
{
return;
}
var builder = new GenericTypeBuilder(e.UnregisteredServiceType, this.OpenGenericImplementation);
var result = builder.BuildClosedGenericImplementation();
if (result.ClosedServiceTypeSatisfiesAllTypeConstraints &&
this.ClosedServiceTypeSatisfiesPredicate(e.UnregisteredServiceType,
result.ClosedGenericImplementation, e.Handled))
{
this.RegisterType(e, result.ClosedGenericImplementation);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
internal static void UnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
var container = Ioc.RecoverContainer();
if (e.UnregisteredServiceType.IsGenericType)
{
var type = e.UnregisteredServiceType
.GetGenericTypeDefinition();
if (type == typeof(IService <>) ||
type == typeof(IApplication <>))
{
if (type.GetCustomAttribute <SingletonAttribute>() != null)
{
e.Register(Lifestyle.Singleton.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
else if (type.GetCustomAttribute <ScopedAttribute>() != null)
{
e.Register(Lifestyle.Scoped.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
else
{
e.Register(Lifestyle.Transient.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
}
else if (type == typeof(IRepository <>))
{
e.Register(Lifestyle.Singleton.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
else if (type == typeof(ITransient <>))
{
e.Register(Lifestyle.Transient.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
else if (type == typeof(ISingleton <>))
{
e.Register(Lifestyle.Singleton.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
else if (type == typeof(ISingleton <>))
{
e.Register(Lifestyle.Scoped.CreateRegistration(e.UnregisteredServiceType.GenericTypeArguments[0], container));
}
}
}
private static void _resolveVariantTypesHandler(object sender, UnregisteredTypeEventArgs e)
{
Type serviceType = e.UnregisteredServiceType;
var container = sender as Container;
if (!serviceType.IsGenericType)
{
return;
}
Type def = serviceType.GetGenericTypeDefinition();
var registrations = (
from r in container.GetCurrentRegistrations()
where r.ServiceType.IsGenericType
where r.ServiceType.GetGenericTypeDefinition() == def
where serviceType.IsAssignableFrom(r.ServiceType)
select r)
.ToArray();
if (!registrations.Any())
{
// No registration found. We're done.
}
else if (registrations.Length == 1)
{
var registration = registrations[0];
registration.Registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent, "Ignored during automatic Variant Registration");
e.Register(registration.BuildExpression());
}
else
{
var names = string.Join(", ", registrations
.Select(r => string.Format("{0}", r.ServiceType)));
throw new ActivationException(string.Format(
"It is impossible to resolve type {0}, because there are {1} " +
"registrations that are applicable. Ambiguous registrations: {2}.",
serviceType, registrations.Length, names));
}
}
internal void ResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
if (typeof(IEnumerable <>).IsGenericTypeDefinitionOf(e.UnregisteredServiceType))
{
Type closedServiceType = e.UnregisteredServiceType.GetGenericArguments().Single();
if (this.OpenGenericServiceType.IsGenericTypeDefinitionOf(closedServiceType))
{
var closedGenericImplementations =
this.GetClosedGenericImplementationsFor(closedServiceType);
if (closedGenericImplementations.Any())
{
var registration = this.GetContainerControlledRegistrationFromCache(
closedServiceType, closedGenericImplementations);
e.Register(registration);
}
}
}
}
private static void TryRegisterValidator(Container container, UnregisteredTypeEventArgs e)
{
// Register only IValidator<> interfaces, registering interfaces that extends IValidator<> is not an option as
// Validator<TModel> does not implement them
if (!e.UnregisteredServiceType.IsGenericType ||
e.UnregisteredServiceType.GetGenericTypeDefinition() != typeof(IValidator <>))
{
return;
}
var validatorType = e.UnregisteredServiceType.GetGenericType(typeof(IValidator <>));
if (validatorType == null)
{
return;
}
var concreteType = typeof(Validator <>).MakeGenericType(validatorType.GenericTypeArguments[0]);
e.Register(Lifestyle.Singleton.CreateRegistration(concreteType, container));
}
private void RaiseResolveUnregisteredType(object sender, UnregisteredTypeEventArgs e)
{
// Simple injector does not allow optional injection of empty Ienumerable. This makes sense in 99.99% of usages but in context where plugins could not even exists and where it is normal, it could be a desirable behaviour
if (typeof(IEnumerable).IsAssignableFrom(e.UnregisteredServiceType))
{
var genericArguments = e.UnregisteredServiceType.GetGenericArguments();
// simple injector use the ResolveUnregisteredType event to resolve Collection, so we have to check if the collection is within registered one in order to call the empty one ONLY if none has been registered
if (genericArguments.All(o => !_collectionRegisteredByTypes.Contains(o)))
{
var validatorType = typeof(EmptyCollection <>).MakeGenericType(genericArguments);
// Register the instance as singleton.
e.Register(Lifestyle.Singleton.CreateRegistration(validatorType, _internalContainer));
return;
}
}
var handler = ResolveUnregisteredType;
handler?.Invoke(sender, e.UnregisteredServiceType);
}
private InstanceProducer?TryGetProducerFromUnregisteredTypeResolutionCacheOrAdd(
UnregisteredTypeEventArgs e)
{
lock (this.resolveUnregisteredTypeRegistrations)
{
if (this.resolveUnregisteredTypeRegistrations.ContainsKey(e.UnregisteredServiceType))
{
// This line will only get hit, in case a different thread came here first.
return(this.resolveUnregisteredTypeRegistrations[e.UnregisteredServiceType].Value);
}
var registration = e.Registration ?? new ExpressionRegistration(e.Expression !, this.container);
// By creating the InstanceProducer after checking the dictionary, we prevent the producer
// from being created twice when multiple threads are running. Having the same duplicate
// producer can cause a torn lifestyle warning in the container.
var producer = new InstanceProducer(e.UnregisteredServiceType, registration);
this.resolveUnregisteredTypeRegistrations[e.UnregisteredServiceType] =
Helpers.ToLazy(producer);
return(producer);
}
}
private static void RegisterArrayResolver(UnregisteredTypeEventArgs e, Container container, Type elementType)
{
var producer = container.GetRegistration(typeof(IEnumerable<>)
.MakeGenericType(elementType));
var enumerableExpression = producer.BuildExpression();
var arrayMethod = typeof(Enumerable).GetMethod("ToArray")
.MakeGenericMethod(elementType);
var arrayExpression = Expression.Call(arrayMethod, enumerableExpression);
e.Register(arrayExpression);
}
public void Handle(object sender, UnregisteredTypeEventArgs e)
{
this.HandlerCalled = true;
}
