/// <summary> /// Begins a new lifetime scope for the given <paramref name="container"/> on the current thread. /// Services, registered with /// <see cref="RegisterLifetimeScope{TService, TImplementation}(Container)">RegisterLifetimeScope</see> or /// using the <see cref="LifetimeScopeLifestyle"/> and are requested within the same thread as where the /// lifetime scope is created, are cached during the lifetime of that scope. /// The scope should be disposed explicitly when the scope ends. /// </summary> /// <param name="container">The container.</param> /// <returns>A new <see cref="Scope"/> instance.</returns> /// <exception cref="ArgumentNullException"> /// Thrown when the <paramref name="container"/> is a null reference.</exception> /// <exception cref="InvalidOperationException">Thrown when <see cref="EnableLifetimeScoping"/> has /// not been called previously.</exception> /// <example> /// <code lang="cs"><![CDATA[ /// using (container.BeginLifetimeScope()) /// { /// var handler container.GetInstance(rootType) as IRequestHandler; /// /// handler.Handle(request); /// } /// ]]></code> /// </example> public static Scope BeginLifetimeScope(this Container container) { Requires.IsNotNull(container, "container"); return(container.GetLifetimeScopeManager().BeginLifetimeScope()); }
/// <summary> /// Gets the <see cref="Scope"/> that is currently in scope or <b>null</b> when no /// <see cref="Scope"/> is currently in scope. /// </summary> /// <example> /// The following example registers a <b>ServiceImpl</b> type as transient (a new instance will be /// returned every time) and registers an initializer for that type that will register that instance /// for disposal in the <see cref="Scope"/> in which context it is created: /// <code lang="cs"><![CDATA[ /// container.Register<IService, ServiceImpl>(); /// container.RegisterInitializer<ServiceImpl>(instance => /// { /// container.GetCurrentLifetimeScope().RegisterForDisposal(instance); /// }); /// ]]></code> /// </example> /// <param name="container">The container.</param> /// <returns>A new <see cref="Scope"/> instance.</returns> /// <exception cref="ArgumentNullException"> /// Thrown when the <paramref name="container"/> is a null reference.</exception> public static Scope GetCurrentLifetimeScope(this Container container) { Requires.IsNotNull(container, "container"); return(container.GetLifetimeScopeManager().CurrentScope); }
internal InjectionTargetInfo(ParameterInfo parameter) { Requires.IsNotNull(parameter, "parameter"); this.Parameter = parameter; }
internal InjectionTargetInfo(PropertyInfo property) { Requires.IsNotNull(property, "property"); this.Property = property; }
public static void EnableLifetimeScoping(this Container container) { // This method has become a no-op. Requires.IsNotNull(container, "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. /// 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)); return(this.CreateRegistration(concreteType, concreteType, container)); }
/// <summary> /// Get service of type <typeparamref name="T"/> from the list of request-specific services of the /// application builder. This preserves the lifestyle of the registered component. /// </summary> /// <typeparam name="T">The type of service object to get.</typeparam> /// <param name="builder">The IApplicationBuilder to retrieve the service object from.</param> /// <returns>A service object of type T or null if there is no such service.</returns> /// <exception cref="InvalidOperationException">Thrown when the method is called outside the /// context of a web request.</exception> public static T GetRequestService <T>(this IApplicationBuilder builder) { Requires.IsNotNull(builder, nameof(builder)); return(GetRequestServiceProvider(builder.GetApplicationServices(), typeof(T)).GetService <T>()); }
internal static string ToCSharpFriendlyName(Type genericTypeDefinition, bool fullyQualifiedName) { Requires.IsNotNull(genericTypeDefinition, nameof(genericTypeDefinition)); return(genericTypeDefinition.ToFriendlyName(fullyQualifiedName, CSharpFriendlyNameArgumentFormatter)); }
/// <summary> /// Gets the <see cref="Scope"/> for the current WCF request or <b>null</b> when no /// <see cref="Scope"/> is currently in scope. /// </summary> /// <example> /// The following example registers a <b>ServiceImpl</b> type as transient (a new instance will be /// returned every time) and registers an initializer for that type that will register that instance /// for disposal in the <see cref="Scope"/> in which context it is created: /// <code lang="cs"><![CDATA[ /// container.Register<IService, ServiceImpl>(); /// container.RegisterInitializer<ServiceImpl>(instance => /// { /// container.GetCurrentWcfOperationScope().RegisterForDisposal(instance); /// }); /// ]]></code> /// </example> /// <param name="container">The container.</param> /// <returns>A new <see cref="Scope"/> instance.</returns> /// <exception cref="ArgumentNullException"> /// Thrown when the <paramref name="container"/> is a null reference.</exception> /// <exception cref="InvalidOperationException">Thrown when the current <paramref name="container"/> /// has both no <b>LifetimeScope</b> registrations. /// </exception> public static Scope GetCurrentWcfOperationScope(this Container container) { Requires.IsNotNull(container, "container"); return(WcfOperationLifestyle.GetCurrentScopeCore()); }
/// <summary> /// Registers all concrete, non-generic, public and internal types in the given /// <paramref name="assembly"/> that implement the given <paramref name="openGenericServiceType"/> /// with the supplied <paramref name="lifestyle"/>. /// <see cref="TypesToRegisterOptions.IncludeDecorators">Decorators</see> and /// <see cref="TypesToRegisterOptions.IncludeGenericTypeDefinitions">generic type definitions</see> /// will be excluded from registration, while /// <see cref="TypesToRegisterOptions.IncludeComposites">composites</see> are included. /// </summary> /// <param name="openGenericServiceType">The definition of the open generic type.</param> /// <param name="assembly">An assembly that will be searched.</param> /// <param name="lifestyle">The lifestyle to register instances with.</param> /// <exception cref="ArgumentNullException">Thrown when one of the arguments contain a null /// reference (Nothing in VB).</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="openGenericServiceType"/> is not /// an open generic type.</exception> /// <exception cref="InvalidOperationException">Thrown when the given /// <paramref name="assembly"/> contain multiple types that implement the same /// closed generic version of the given <paramref name="openGenericServiceType"/>.</exception> public void Register(Type openGenericServiceType, Assembly assembly, Lifestyle lifestyle) { Requires.IsNotNull(assembly, nameof(assembly)); this.Register(openGenericServiceType, new[] { assembly }, lifestyle); }
/// <summary>Initializes a new instance of the <see cref="Scope"/> class.</summary> /// <param name="container">The container instance that the scope belongs to.</param> public Scope(Container container) { Requires.IsNotNull(container, nameof(container)); this.Container = container; }
/// <summary> /// Creates a new <see cref="Registration"/> instance defining the creation of the /// specified <typeparamref name="TConcrete"/> with the caching as specified by this lifestyle. /// </summary> /// <typeparam name="TConcrete">The concrete type that will be registered.</typeparam> /// <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> protected internal override Registration CreateRegistrationCore <TConcrete>(Container container) { Requires.IsNotNull(container, nameof(container)); return(new ScopedRegistration <TConcrete>(this, container)); }
internal ContainerCollectionRegistrator(Container container) { Requires.IsNotNull(container, nameof(container)); this.container = container; }
private static string BuildMessage(IList <DiagnosticResult> errors) { Requires.IsNotNull(errors, "errors"); return(StringResources.DiagnosticWarningsReported(errors)); }
/// <summary> /// Returns the current <see cref="Scope"/> for this lifestyle and the given /// <paramref name="container"/>, or null when this method is executed outside the context of a scope. /// </summary> /// <param name="container">The container instance that is related to the scope to return.</param> /// <returns>A <see cref="Scope"/> instance or null when there is no scope active in this context.</returns> public Scope GetCurrentScope(Container container) { Requires.IsNotNull(container, "container"); return(this.GetCurrentScopeCore(container) ?? container.VerificationScope); }
/// <summary> /// Returns the current <see cref="Scope"/> for this lifestyle and the given /// <paramref name="container"/>, or null when this method is executed outside the context of a scope. /// </summary> /// <param name="container">The container instance that is related to the scope to return.</param> /// <returns>A <see cref="Scope"/> instance or null when there is no scope active in this context.</returns> public Scope?GetCurrentScope(Container container) { Requires.IsNotNull(container, nameof(container)); return(this.GetCurrentScopeInternal(container)); }
/// <summary> /// Creates a new <see cref="Registration"/> instance defining the creation of the /// specified <typeparamref name="TImplementation"/> with the caching as specified by this lifestyle. /// </summary> /// <typeparam name="TService">The interface or base type that can be used to retrieve the instances.</typeparam> /// <typeparam name="TImplementation">The concrete type that will be registered.</typeparam> /// <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> protected override Registration CreateRegistrationCore <TService, TImplementation>(Container container) { Requires.IsNotNull(container, "container"); return(new ScopedRegistration <TService, TImplementation>(this, container, this.disposeInstances)); }
public Registration CreateRegistration(Type serviceType, Type implementationType, Container container) { Requires.IsNotNull(implementationType, nameof(implementationType)); return(this.CreateRegistration(implementationType, container)); }
/// <summary> /// Allows the container to resolve instances with a Per Wcf Operation lifestyle for the given /// <paramref name="container"/>. This is /// enabled automatically when services get registered using one of the <b>RegisterPerWcfRequest</b> /// overloads or when the container passed onto the /// <see cref="SimpleInjectorServiceHostFactory.SetContainer"/> method. /// </summary> /// <param name="container">The container.</param> public static void EnablePerWcfOperationLifestyle(this Container container) { // This method has become a no-op. Requires.IsNotNull(container, "container"); }