/// <summary>
/// Creates a new <see cref="Registration"/> instance defining the creation of the
/// specified <paramref name="concreteType"/> with the caching as specified by this lifestyle.
/// This method might fail when run in a partial trust sandbox when <paramref name="concreteType"/>
/// is an internal type.
/// </summary>
/// <param name="concreteType">The concrete type that will be registered.</param>
/// <param name="container">The <see cref="Container"/> instance for which a
/// <see cref="Registration"/> must be created.</param>
/// <returns>A new <see cref="Registration"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when on of the supplied arguments is a null
/// reference (Nothing in VB).</exception>
public Registration CreateRegistration(Type concreteType, Container container)
{
Requires.IsNotNull(concreteType, nameof(concreteType));
Requires.IsNotOpenGenericType(concreteType, nameof(concreteType));
return(this.CreateRegistration(concreteType, concreteType, container));
}
/// <summary>
/// Creates a new <see cref="Registration"/> instance defining the creation of the
/// specified <paramref name="serviceType"/> using the supplied <paramref name="instanceCreator"/>
/// with the caching as specified by this lifestyle.
/// </summary>
/// <param name="serviceType">The interface or base type that can be used to retrieve the instances.</param>
/// <param name="instanceCreator">The delegate that will be responsible for creating new instances.</param>
/// <param name="container">The <see cref="Container"/> instance for which a
/// <see cref="Registration"/> must be created.</param>
/// <returns>A new <see cref="Registration"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when on of the supplied arguments is a null
/// reference (Nothing in VB).</exception>
public Registration CreateRegistration(Type serviceType, Func <object> instanceCreator,
Container container)
{
Requires.IsNotNull(serviceType, nameof(serviceType));
Requires.IsNotNull(instanceCreator, nameof(instanceCreator));
Requires.IsNotNull(container, nameof(container));
Requires.IsReferenceType(serviceType, nameof(serviceType));
Requires.IsNotOpenGenericType(serviceType, nameof(serviceType));
var closedCreateRegistrationMethod = OpenCreateRegistrationTServiceFuncMethod
.MakeGenericMethod(serviceType);
try
{
// Build the following delegate: () => (ServiceType)instanceCreator();
var typeSafeInstanceCreator = ConvertDelegateToTypeSafeDelegate(serviceType, instanceCreator);
return((Registration)closedCreateRegistrationMethod.Invoke(this,
new object[] { typeSafeInstanceCreator, container }));
}
catch (MemberAccessException ex)
{
throw BuildUnableToResolveTypeDueToSecurityConfigException(serviceType, ex, nameof(serviceType));
}
}
/// <summary>
/// Creates a new <see cref="Registration"/> instance defining the creation of the
/// specified <paramref name="implementationType"/> with the caching as specified by this lifestyle.
/// This method might fail when run in a partial trust sandbox when <paramref name="implementationType"/>
/// is an internal type.
/// </summary>
/// <param name="serviceType">The interface or base type that can be used to retrieve the instances.</param>
/// <param name="implementationType">The concrete type that will be registered.</param>
/// <param name="container">The <see cref="Container"/> instance for which a
/// <see cref="Registration"/> must be created.</param>
/// <returns>A new <see cref="Registration"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when on of the supplied arguments is a null
/// reference (Nothing in VB).</exception>
public Registration CreateRegistration(Type serviceType, Type implementationType, Container container)
{
Requires.IsNotNull(serviceType, nameof(serviceType));
Requires.IsNotNull(implementationType, nameof(implementationType));
Requires.IsNotNull(container, nameof(container));
Requires.IsReferenceType(serviceType, nameof(serviceType));
Requires.IsReferenceType(implementationType, nameof(implementationType));
Requires.IsNotOpenGenericType(serviceType, nameof(serviceType));
Requires.IsNotOpenGenericType(implementationType, nameof(implementationType));
Requires.ServiceIsAssignableFromImplementation(serviceType, implementationType,
nameof(implementationType));
var closedCreateRegistrationMethod = OpenCreateRegistrationTServiceTImplementationMethod
.MakeGenericMethod(serviceType, implementationType);
try
{
return((Registration)closedCreateRegistrationMethod.Invoke(this, new object[] { container }));
}
catch (MemberAccessException ex)
{
throw BuildUnableToResolveTypeDueToSecurityConfigException(implementationType, ex,
nameof(implementationType));
}
}
public static void UseMiddleware(
this SimpleInjectorUseOptions options, Type middlewareType, IApplicationBuilder app)
{
Requires.IsNotNull(options, nameof(options));
Requires.IsNotNull(middlewareType, nameof(middlewareType));
Requires.IsNotNull(app, nameof(app));
Requires.ServiceIsAssignableFromImplementation(
typeof(IMiddleware), middlewareType, nameof(middlewareType));
Requires.IsNotOpenGenericType(middlewareType, nameof(middlewareType));
var container = options.Container;
var lifestyle = container.Options.LifestyleSelectionBehavior.SelectLifestyle(middlewareType);
// By creating an InstanceProducer up front, it will be known to the container, and will be part
// of the verification process of the container.
InstanceProducer <IMiddleware> producer =
lifestyle.CreateProducer <IMiddleware>(middlewareType, container);
app.Use((c, next) =>
{
IMiddleware middleware = producer.GetInstance();
return(middleware.InvokeAsync(c, _ => next()));
});
}
/// <summary>
/// Adds a middleware type to the application's request pipeline. The middleware will be resolved from
/// the supplied the Simple Injector <paramref name="container"/>. The middleware will be added to the
/// container for verification.
/// </summary>
/// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>
/// <param name="middlewareType">The middleware type that needs to be applied. This type must
/// implement <see cref="IMiddleware"/>.</param>
/// <param name="container">The container to resolve <paramref name="middlewareType"/> from.</param>
/// <returns>The supplied <see cref="IApplicationBuilder"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when one of the arguments is a null reference.</exception>
/// <exception cref="ArgumentException">Thrown when the <paramref name="middlewareType"/> does not
/// derive from <see cref="IMiddleware"/>, is an open-generic type, or not a concrete constructable
/// type.</exception>
public static IApplicationBuilder UseMiddleware(
this IApplicationBuilder app, Type middlewareType, Container container)
{
Requires.IsNotNull(app, nameof(app));
Requires.IsNotNull(middlewareType, nameof(middlewareType));
Requires.IsNotNull(container, nameof(container));
Requires.ServiceIsAssignableFromImplementation(
typeof(IMiddleware), middlewareType, nameof(middlewareType));
Requires.IsNotOpenGenericType(middlewareType, nameof(middlewareType));
var lifestyle = container.Options.LifestyleSelectionBehavior.SelectLifestyle(middlewareType);
// By creating an InstanceProducer up front, it will be known to the container, and will be part
// of the verification process of the container.
// Note that the middleware can't be registered in the container, because at this point the
// container might already be locked (which will happen when the new ASP.NET Core 3 Host class is
// used).
InstanceProducer <IMiddleware> producer =
lifestyle.CreateProducer <IMiddleware>(middlewareType, container);
app.Use((c, next) =>
{
IMiddleware middleware = producer.GetInstance();
return(middleware.InvokeAsync(c, _ => next()));
});
return(app);
}
/// <summary>
/// Creates a new <see cref="InstanceProducer"/> instance for the given <paramref name="serviceType"/>
/// that will create new instances of specified <paramref name="implementationType"/> with the
/// caching as specified by this lifestyle.
/// </summary>
/// <param name="serviceType">The interface or base type that can be used to retrieve the instances.</param>
/// <param name="implementationType">The concrete type that will be registered.</param>
/// <param name="container">The <see cref="Container"/> instance for which a
/// <see cref="Registration"/> must be created.</param>
/// <returns>A new <see cref="InstanceProducer"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when on of the supplied arguments is a null
/// reference (Nothing in VB).</exception>
public InstanceProducer CreateProducer(Type serviceType, Type implementationType, Container container)
{
Requires.IsNotNull(serviceType, nameof(serviceType));
Requires.IsNotNull(implementationType, nameof(implementationType));
Requires.IsNotNull(container, nameof(container));
Requires.IsNotOpenGenericType(implementationType, nameof(implementationType));
return(new InstanceProducer(serviceType, this.CreateRegistration(implementationType, container)));
}
/// <summary>
/// Creates a new <see cref="Registration"/> instance defining the creation of the
/// specified <paramref name="concreteType"/> with the caching as specified by this lifestyle,
/// or returns an already created <see cref="Registration"/> instance for this container + lifestyle
/// + type combination.
/// This method might fail when run in a partial trust sandbox when <paramref name="concreteType"/>
/// is an internal type.
/// </summary>
/// <param name="concreteType">The concrete type that will be registered.</param>
/// <param name="container">The <see cref="Container"/> instance for which a
/// <see cref="Registration"/> must be created.</param>
/// <returns>A new <see cref="Registration"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when on of the supplied arguments is a null
/// reference (Nothing in VB).</exception>
public Registration CreateRegistration(Type concreteType, Container container)
{
Requires.IsNotNull(concreteType, nameof(concreteType));
Requires.IsNotNull(container, nameof(container));
Requires.IsReferenceType(concreteType, nameof(concreteType));
Requires.IsNotOpenGenericType(concreteType, nameof(concreteType));
return(this.CreateRegistrationInternal(concreteType, container, preventTornLifestyles: true));
}
/// <summary>
/// Creates a new <see cref="InstanceProducer"/> instance for the given <typeparamref name="TService"/>
/// that will create new instances of specified <paramref name="implementationType"/> caching as
/// specified by this lifestyle.
/// </summary>
/// <typeparam name="TService">The interface or base type that can be used to retrieve the instances.</typeparam>
/// <param name="implementationType">The concrete type that will be created.</param>
/// <param name="container">The <see cref="Container"/> instance for which a
/// <see cref="InstanceProducer"/> must be created.</param>
/// <returns>A new <see cref="InstanceProducer"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when either <paramref name="implementationType"/> or
/// <paramref name="container"/> are null references (Nothing in VB).</exception>
public InstanceProducer <TService> CreateProducer <TService>(Type implementationType, Container container)
where TService : class
{
Requires.IsNotNull(implementationType, nameof(implementationType));
Requires.IsNotNull(container, nameof(container));
Requires.IsNotOpenGenericType(implementationType, nameof(implementationType));
Requires.ServiceIsAssignableFromImplementation(typeof(TService), implementationType,
nameof(implementationType));
return(new InstanceProducer <TService>(this.CreateRegistration(implementationType, container)));
}
/// <summary>
/// Conditionally registers that <paramref name="registration"/> will be used every time a
/// <paramref name="serviceType"/> is requested and where the supplied <paramref name="predicate"/>
/// returns true. The predicate will only be evaluated a finite number of times; the predicate is
/// unsuited for making decisions based on runtime conditions.
/// </summary>
/// <param name="serviceType">The base type or interface to register. This can be an open-generic type.</param>
/// <param name="registration">The <see cref="Registration"/> instance to register.</param>
/// <param name="predicate">The predicate that determines whether the
/// <paramref name="registration"/> can be applied for the requested service type. This predicate
/// can be used to build a fallback mechanism where multiple registrations for the same service type
/// are made. Note that the predicate will be called a finite number of times and its result will be cached
/// for the lifetime of the container. It can't be used for selecting a type based on runtime conditions.
/// </param>
/// <exception cref="ArgumentNullException">Thrown when one of the arguments is a null reference
/// (Nothing in VB).</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="serviceType"/> is open generic or
/// <paramref name="registration" /> is not assignable to <paramref name="serviceType"/>.</exception>
/// <exception cref="InvalidOperationException">
/// Thrown when this container instance is locked and can not be altered.
/// </exception>
public void RegisterConditional(Type serviceType, Registration registration,
Predicate <PredicateContext> predicate)
{
Requires.IsNotNull(serviceType, nameof(serviceType));
Requires.IsNotNull(registration, nameof(registration));
Requires.IsNotNull(predicate, nameof(predicate));
Requires.IsNotOpenGenericType(serviceType, nameof(serviceType));
Requires.ServiceIsAssignableFromImplementation(serviceType, registration.ImplementationType,
nameof(serviceType));
this.ThrowWhenContainerIsLockedOrDisposed();
var producer = new InstanceProducer(serviceType, registration, predicate);
this.AddInstanceProducer(producer);
}
internal InstanceProducer(Type serviceType, Registration registration, bool registerExternalProducer)
{
Requires.IsNotNull(serviceType, nameof(serviceType));
Requires.IsNotNull(registration, nameof(registration));
Requires.IsNotOpenGenericType(serviceType, nameof(serviceType));
this.ServiceType = serviceType;
this.Registration = registration;
this.validator = new CyclicDependencyValidator(this);
this.lazyExpression = new LazyEx <Expression>(this.BuildExpressionInternal);
if (registerExternalProducer)
{
registration.Container.RegisterExternalProducer(this);
}
this.instanceCreator = this.BuildAndReplaceInstanceCreatorAndCreateFirstInstance;
}
/// <summary>
/// Registers a dynamic (container uncontrolled) collection of elements of type
/// <paramref name="serviceType"/>. A call to <see cref="GetAllInstances{T}"/> will return the
/// <paramref name="containerUncontrolledCollection"/> itself, and updates to the collection will be
/// reflected in the result. If updates are allowed, make sure the collection can be iterated safely
/// if you're running a multi-threaded application.
/// </summary>
/// <param name="serviceType">The base type or interface for elements in the collection.</param>
/// <param name="containerUncontrolledCollection">The collection of items to register.</param>
/// <exception cref="ArgumentNullException">Thrown when one of the supplied arguments is a null
/// reference (Nothing in VB).</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="serviceType"/> represents an
/// open generic type.</exception>
public void RegisterCollection(Type serviceType, IEnumerable containerUncontrolledCollection)
{
Requires.IsNotNull(serviceType, nameof(serviceType));
Requires.IsNotNull(containerUncontrolledCollection, nameof(containerUncontrolledCollection));
Requires.IsNotOpenGenericType(serviceType, nameof(serviceType));
Requires.IsNotAnAmbiguousType(serviceType, nameof(serviceType));
try
{
this.RegisterContainerUncontrolledCollection(serviceType,
containerUncontrolledCollection.Cast <object>());
}
catch (MemberAccessException ex)
{
// This happens when the user tries to resolve an internal type inside a (Silverlight) sandbox.
throw new ArgumentException(
StringResources.UnableToResolveTypeDueToSecurityConfiguration(serviceType, ex) +
Environment.NewLine + "paramName: " + nameof(serviceType), ex);
}
}
