\n\nYou can build up a hierarchical tree structure from containers by creating more child containers with the `.CreateChildContainer()` method.\n\n
\n\n\n```cs\nusing var container = new StashboxContainer();\n\nvar child1 = container.CreateChildContainer();\nvar child2 = child1.CreateChildContainer();\n```\n\n
\n\n\nYou have the option to register multiple decorators for a service to extend its functionality.\n\nThe decoration order will be the same as the registration order of the decorators. The first registered decorator will decorate the service itself. Then, all the subsequent decorators will wrap the already decorated service.\n\n
\n\n\n```cs\ncontainer.Register();\ncontainer.RegisterDecorator();\ncontainer.RegisterDecorator();\n\n// new ValidatorProcessor(new LoggerProcessor(new GeneralProcessor()));\nvar processor = container.Resolve(); \n```\n\n
\n\n\nJust as other registrations, decorators also can have their lifetime. It means, in addition to the service's lifetime, all decorator's lifetime will be applied to the wrapped service.\n\n:::note\nWhen you don't set a decorator's lifetime, it'll implicitly inherit the decorated service's lifetime.\n:::\n\n
\n\n\n```cs\ncontainer.Register();\n// singleton decorator will change the transient \n// decorated service's lifetime to singleton.\ncontainer.RegisterDecorator(options => \n options.WithLifetime(Lifetimes.Singleton));\n// Singleton[new ValidatorProcessor()](Transien[new GeneralEventProcessor()]) \nvar processor = container.Resolve(); \n```\n\n
\n\n\nDecorators are also applied to wrapped services. It means, in addition to the decoration, you can wrap your services in supported [wrappers](/docs/advanced/wrappers-resolvers#wrappers).\n\n
\n\n\n```cs\ncontainer.Register();\ncontainer.RegisterDecorator();\n// () => new ValidatorProcessor(new GeneralEventProcessor())\nvar processor = container.Resolve>();\n```\n\n
\n\n\nThe registration of a closed-generic type does not differ from registering a simple non-generic service.\n\nYou have all options available that you saw at the [basic](/docs/guides/basics) and [advanced registration](/docs/guides/advanced-registration) flows.\n\n
\n\n\n\n\n\n```cs\ncontainer.Register, UserValidator>();\nIValidator validator = container.Resolve>();\n```\n\n \n\n\n```cs\ncontainer.Register(typeof(IValidator), typeof(UserValidator));\nobject validator = container.Resolve(typeof(IValidator));\n```\n\n \n \n
\n\n\nOpen-generic types could help in such scenarios where you have generic interface-implementation pairs with numerous generic parameter variations. The registration of those different versions would look like this: \n\n
\n\n\n```cs\ncontainer.Register, Validator>();\ncontainer.Register, Validator>();\ncontainer.Register, Validator>();\n// and so on...\n```\n\n
\n\n\nRather than doing that, you can register your type's generic definition and let Stashbox bind the type parameters for you. When a matching closed [service type](/docs/getting-started/glossary#service-type--implementation-type) is requested, the container will construct an equivalent closed-generic implementation.\n\n
\n\n\n```cs\ncontainer.Register(typeof(IValidator<>), typeof(Validator<>));\n// Validator will be returned.\nIValidator userValidator = container.Resolve>();\n// Validator will be returned.\nIValidator roleValidator = container.Resolve>();\n```\n\n
\n\n\nA registered closed-generic type always has priority over an open-generic type at service selection.\n\n
\n\n\n```cs\ncontainer.Register, UserValidator>();\ncontainer.Register(typeof(IValidator<>), typeof(Validator<>));\n// UserValidator will be returned.\nIValidator validator = container.Resolve>();\n```\n
\n\n\n### Enumerable\nStashbox can compose a collection from each implementation registered to a [service type](/docs/getting-started/glossary#service-type--implementation-type). The requested type can be wrapped by any of the collection interfaces that a .NET `Array` implements.\n\n
\n\n\n```cs\nIJob[] jobs = container.Resolve();\nIEnumerable jobs = container.Resolve>();\nIList jobs = container.Resolve>();\nICollection jobs = container.Resolve>();\nIReadOnlyList jobs = container.Resolve>();\nIReadOnlyCollection jobs = container.Resolve>();\n```\n\n
\n\n\n### Lazy\nWhen requesting `Lazy<>`, the container implicitly constructs a new `Lazy<>` instance with a factory delegate as its constructor argument used to instantiate the underlying service. \n\n
\n\n\n```cs\ncontainer.Register();\n\n// new Lazy(() => new DbBackup())\nLazy lazyJob = container.Resolve>();\nIJob job = lazyJob.Value;\n```\n
\n\n\n### Delegate\n\nWhen requesting a `Delegate`, the container implicitly creates a factory used to instantiate the underlying service.\n\nIt's possible to request a delegate that expects some or all of the dependencies as delegate parameters.\nParameters are used for sub-dependencies as well, like: `(arg) => new A(new B(arg))`\n\nWhen a dependency is not available as a parameter, it will be resolved from the container directly.\n\n
\n\n\n\n\n\n```cs\ncontainer.Register();\n\n// (conn, logger) => new DbBackup(conn, logger)\nFunc funcOfJob = container\n .Resolve>();\n \nIJob job = funcOfJob(config[\"connectionString\"], new ConsoleLogger());\n```\n\n \n\n\n```cs\nprivate delegate IJob JobFactory(string connectionString, ILogger logger);\n\ncontainer.Register();\n\nvar jobDelegate = container.Resolve();\nIJob job = jobDelegate(config[\"connectionString\"], new ConsoleLogger());\n```\n\n \n \n
\n\n\n### Metadata & Tuple\nWith the `.WithMetadata()` registration option, you can attach additional information to a service.\nTo gather this information, you can request the service wrapped in either `Metadata<,>`, `ValueTuple<,>`, or `Tuple<,>`.\n\n`Metadata<,>` is a type from the `Stashbox` package, so you might prefer using `ValueTuple<,>` or `Tuple<,>` if you want to avoid referencing Stashbox in certain parts of your project.\n\nYou can also filter a collection of services by their metadata. Requesting `IEnumerable>` will yield only those services that have the given type of metadata.\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .WithMetadata(\"connection-string-to-db\"));\n\nvar jobWithConnectionString = container.Resolve>();\n// prints: \"connection-string-to-db\"\nConsole.WriteLine(jobWithConnectionString.Data);\n\nvar alsoJobWithConnectionString = container.Resolve>();\n// prints: \"connection-string-to-db\"\nConsole.WriteLine(alsoJobWithConnectionString.Item2);\n\nvar stillJobWithConnectionString = container.Resolve>();\n// prints: \"connection-string-to-db\"\nConsole.WriteLine(stillJobWithConnectionString.Item2);\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .WithMetadata(\"meta-1\"));\ncontainer.Register(options => options\n .WithMetadata(\"meta-2\"));\ncontainer.Register(options => options\n .WithMetadata(5));\n\n// the result is: [Service1, Service2]\nvar servicesWithStringMetadata = container.Resolve[]>();\n\n// the result is: [Service3]\nvar servicesWithIntMetadata = container.Resolve[]>();\n```\n\n \n \n
\n\n\n### KeyValuePair & ReadOnlyKeyValue\nWith named registration, you can give your service unique identifiers. Requesting a service wrapped in a `KeyValuePair` or `ReadOnlyKeyValue` returns the requested service with its identifier as key.\n\n`ReadOnlyKeyValue<,>` is a type from the `Stashbox` package, so you might prefer using `KeyValuePair<,>` if you want to avoid referencing Stashbox in certain parts of your project.\n\nRequesting an `IEnumerable>` will return all services of the requested type along their identifiers. When a service don't have an identifier the `Key` will be set to `null`.\n\n
\n\n\n```cs\ncontainer.Register(\"FirstServiceId\");\ncontainer.Register(\"SecondServiceId\");\ncontainer.Register();\n\nvar serviceKeyValue1 = container\n .Resolve>(\"FirstServiceId\");\n// prints: \"FirstServiceId\"\nConsole.WriteLine(serviceKeyValue1.Key);\n\nvar serviceKeyValue2 = container\n .Resolve>(\"SecondServiceId\");\n// prints: \"SecondServiceId\"\nConsole.WriteLine(serviceKeyValue2.Key);\n\n// [\"FirstServiceId\": Service1, \"SecondServiceId\": Service2, null: Service3 ]\nvar servicesWithKeys = container.Resolve[]>();\n```\n
\n\n\nThe container's constructor has an `Action` parameter used to configure its behavior.\n\nThe configuration API is fluent, which means you can chain the configuration methods after each other.\n\n
\n\n\n```cs\nvar container = new StashboxContainer(options => options\n .WithDisposableTransientTracking()\n .WithConstructorSelectionRule(Rules.ConstructorSelection.PreferLeastParameters)\n .WithRegistrationBehavior(Rules.RegistrationBehavior.ThrowException));\n```\n\n
\n\n\n**Re-configuration** of the container is also supported by calling its `.Configure()` method.\n\n
\n\n\n```cs\nvar container = new StashboxContainer();\ncontainer.Configure(options => options.WithDisposableTransientTracking());\n```\n\n
\n\n\nWith this option, you can enable or disable the tracking of disposable transient objects.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithDisposableTransientTracking());\n```\n\n
\n\n\n### `PropertiesWithPublicSetter`\nWith this flag, the container will perform auto-injection on properties with public setters.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAutoMemberInjection(\n Rules.AutoMemberInjectionRules.PropertiesWithPublicSetter));\n```\n\n
\n\n\n### `PropertiesWithLimitedAccess`\nWith this flag, the container will perform auto-injection on properties even when they don't have a public setter.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAutoMemberInjection(\n Rules.AutoMemberInjectionRules.PropertiesWithLimitedAccess));\n```\n\n
\n\n\n### `PrivateFields`\nWith this flag, the container will perform auto-injection on private fields too.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAutoMemberInjection(\n Rules.AutoMemberInjectionRules.PrivateFields));\n```\n\n
\n\n\n### Combined rules\nYou can also combine these flags with bitwise logical operators to get a merged ruleset.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAutoMemberInjection(Rules.AutoMemberInjectionRules.PrivateFields | \n Rules.AutoMemberInjectionRules.PropertiesWithPublicSetter));\n```\n\n
\n\n\n#### Member selection filter\nYou can pass your own member selection logic to control which members should be auto injected.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAutoMemberInjection(\n filter: member => member.Type != typeof(ILogger)));\n```\n\n
\n\n\nWith this option, you can enable or disable the auto injection of members defined with C# 11's [`required`](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required) keyword.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithRequiredMemberInjection(enabled: false));\n```\n\n
\n\n\n### `PreferMostParameters`\nIt prefers the constructor which has the most extended parameter list.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithConstructorSelectionRule(\n Rules.ConstructorSelection.PreferMostParameters));\n```\n\n
\n\n\n### `PreferLeastParameters`\nIt prefers the constructor which has the shortest parameter list.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithConstructorSelectionRule(\n Rules.ConstructorSelection.PreferLeastParameters));\n```\n\n
\n\n\n### `SkipDuplications`\nThe container will skip new registrations when the given [implementation type](/docs/getting-started/glossary#service-type--implementation-type) is already registered.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithRegistrationBehavior(\n Rules.RegistrationBehavior.SkipDuplications));\n```\n\n
\n\n\n### `ThrowException`\nThe container throws an [exception](/docs/diagnostics/validation#servicealreadyregisteredexception) when the given [implementation type](/docs/getting-started/glossary#service-type--implementation-type) is already registered.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithRegistrationBehavior(\n Rules.RegistrationBehavior.ThrowException));\n```\n\n
\n\n\n### `ReplaceExisting`\nThe container will replace the already [registered service](/docs/getting-started/glossary#service-registration--registered-service) with the given one when they have the same [implementation type](/docs/getting-started/glossary#service-type--implementation-type).\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithRegistrationBehavior(\n Rules.RegistrationBehavior.ReplaceExisting));\n```\n\n
\n\n\n### `PreserveDuplications`\nThe container will keep registering the new services with the same [implementation type](/docs/getting-started/glossary#service-type--implementation-type).\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithRegistrationBehavior(\n Rules.RegistrationBehavior.PreserveDuplications));\n```\n\n
\n\n\nWith this option, you can set the default lifetime used when a service doesn't have a configured one.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithDefaultLifetime(Lifetimes.Scoped));\n```\n\n
\n\n\nWith this option, you can enable or disable the life-span and [root scope](/docs/getting-started/glossary#root-scope) resolution [validation](/docs/diagnostics/validation#lifetime-validation) on the dependency tree.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithLifetimeValidation());\n```\n\n
\n\n\nWith this option, you can enable or disable the check for [generic covariance and contravariance](/docs/advanced/generics#variance) during the resolution of generic type collections. \n\n_This option is enabled by default_.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithVariantGenericTypes());\n```\n\n
\n\n\nWith this option, you can enable or disable the throwing of a `ResolutionFailedException` when no services are found for a collection resolution request. When this feature is disabled _(default)_, the container returns an empty array for those request.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithExceptionOverEmptyCollection());\n```\n\n
\n\n\nWith this option, you can enable or disable conventional resolution, which means the container treats the constructor/method parameter or member names as dependency names used by [named resolution](/docs/getting-started/glossary#named-resolution).\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .TreatParameterAndMemberNameAsDependencyName());\n```\n\n
\n\n\nWith this option, you can enable or disable the selection of named registrations when the resolution request is un-named but with the same type.\n\nThe `enabledForCollectionRequests` argument controls whether named registrations should be returned for an unnamed collection resolution request. It's **enabled** by default.\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithNamedDependencyResolutionForUnNamedRequests(\n enabled: true,\n enabledForCollectionRequests: true\n ));\n```\n\n
\n\n\n### `WithUniversalName`\nSets the universal name that represents a special name which allows named resolution work for any given name.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithUniversalName(\"Any\"));\n```\n\n
\n\n\n### `WithAdditionalDependencyNameAttribute`\nAdds an attribute type that is considered a dependency name indicator just like the [`DependencyName` attribute](/docs/guides/service-resolution#attributes).\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAdditionalDependencyNameAttribute());\n```\n\n
\n\n\n### `WithAdditionalDependencyAttribute`\nAdds an attribute type that is considered a dependency indicator just like the [`Dependency` attribute](/docs/guides/service-resolution#attributes).\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithAdditionalDependencyAttribute());\n```\n\n
\n\n\n### `WithIgnoreServicesWithUniversalNameForUniversalNamedRequests`\nEnables or disables the selection of services with `UniversalName` for a universal named resolution request.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithIgnoreServicesWithUniversalNameForUniversalNamedRequests());\n```\n\n
\n\n\n### `WithForceThrowWhenNamedDependencyIsNotResolvable`\nEnables or disables throwing a `ResolutionFailedException` when a named dependency is not resolvable. Requests initiated by `.ResolveOrDefault()` may also throw when a named subdependency is not resolvable for example through the `Dependency` attribute.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithForceThrowWhenNamedDependencyIsNotResolvable());\n```\n\n
\n\n\nWith this option, you can override the default `ResolutionFailedException` type thrown when the service resolution fails.\nThe details of the exception remain the same, only the type gets overridden.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .OverrideResolutionFailedExceptionWith());\n```\n\n
\n\n\nWith this option, you can enable or disable the default value injection.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithDefaultValueInjection());\n```\n\n
\n\n\nWith this option, you can enable or disable the resolution of unregistered types. You can also use a configurator delegate to configure the registrations the container will create from the unknown types.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithUnknownTypeResolution(config => config.AsImplementedTypes()));\n```\n\n
\n\n\nWith this option, you can set an external expression tree compiler. It can be useful on platforms where the IL generator modules are not available; therefore, the expression compiler in Stashbox couldn't work.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithExpressionCompiler(\n Rules.ExpressionCompilers.MicrosoftExpressionCompiler));\n```\n\n
\n\n\nWith this option, you can enable or disable the re-building of singletons in child containers. It allows the child containers to override singleton dependencies in the parent.\n\n
\n\n\n```cs\nnew StashboxContainer(options => options\n .WithReBuildSingletonsInChildContainer());\n```\n\n
\n\n\nMost of the registration methods have an `Action` parameter, enabling several customization options on the given registration.\n\nHere are three examples that show how the API's usage looks like. \nThey cover the exact functionalities you've read about in the [basics](/docs/guides/basics) section but are achieved with the options API.\n\n
\n\n\n\n\n\nThis is how you can use the options API to set a registration's name:\n```cs\ncontainer.Register(options => options\n .WithName(\"DbBackup\"));\n```\n\n \n\n\nIt was mentioned in the [Lifetime shortcuts](/docs/guides/basics#lifetime-shortcuts) section, that those methods are only sugars; under the curtain, they are also using this API:\n```cs\ncontainer.Register(options => options\n .WithLifetime(Lifetimes.Singleton));\n```\n\n \n\n\nAn example of how you can register an instance with the options API:\n```cs\ncontainer.Register(options => options\n .WithInstance(new DbBackup()));\n```\n\n \n \n
\n\n\nThe registration configuration API is fluent, which means all option methods can be chained after each other. \nThis provides an easier way to configure complicated registrations.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithName(\"DbBackup\")\n .WithLifetime(Lifetimes.Singleton)\n .WithoutDisposalTracking());\n```\n\n
\n\n\n### `WithName`\nSets the name identifier of the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .WithName(\"Console\"));\n```\n\n
\n\n\n### `WithInstance`\nSets an existing instance for the registration. \n\nPassing true for the `wireUp` parameter means that the container performs member / method injection on the registered instance.\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .WithInstance(new ConsoleLogger()));\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .WithInstance(new ConsoleLogger(), wireUp: true));\n```\n\n \n \n
\n\n\n### `WithoutDisposalTracking`\nForce disables the disposal tracking on the registration.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithoutDisposalTracking());\n```\n\n
\n\n\n### `WithMetadata`\nSets additional metadata for the registration. It's attached to the service upon its resolution through `ValueTuple<,>`, `Tuple<,>`, or `Metadata<,>` wrappers.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithMetadata(connectionString));\n\nvar jobWithConnectionString = container.Resolve>();\nConsole.WriteLine(jobWithConnectionString.Item2); // prints the connection string.\n\n```\n\n
\n\n\n### `WithDynamicResolution`\nIndicates that the service's resolution should be handled by a dynamic `Resolve()` call on the current `IDependencyResolver` instead of a pre-built instantiation expression.\n\n
\n\n\n```cs\ncontainer.Register();\ncontainer.Register(options => options\n .WithDynamicResolution());\n\n// new DbBackup(currentScope.Resolve());\nvar job = container.Resolve();\n\n```\n\n
\n\n\n### `HasServiceType`\nUsed to build conditions based on service type in batch/assembly registrations.\nIt determines whether the registration is mapped to the given service type.\n\n
\n\n\n```cs\ncontainer.RegisterAssemblyContaining(configurator: options =>\n {\n if (options.HasServiceType())\n options.WithScopedLifetime();\n });\n\n```\n\n
\n\n\n### `WithFinalizer`\nSets a custom cleanup delegate that will be invoked when the scope / container holding the instance is being disposed.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithFinalizer(logger => logger\n .CloseFile()));\n```\n\n
\n\n\n### `WithInitializer`\nSets a custom initializer delegate that will be invoked when the given service is being instantiated.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithInitializer((logger, resolver) => logger\n .OpenFile()));\n```\n\n
\n\n\n### `AsImplementedTypes`\nThe service will be mapped to all of its implemented interfaces and base types.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .AsImplementedTypes());\n```\n\n
\n\n\n### `AsServiceAlso`\nBinds the currently configured registration to an additional [service type](/docs/getting-started/glossary#service-type--implementation-type). The registered type must implement or extend the additional [service type](/docs/getting-started/glossary#service-type--implementation-type).\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .AsServiceAlso()\n // or\n .AsServiceAlso(typeof(IRepository)));\n```\n\n
\n\n\n### `WithSingletonLifetime`\nSets a singleton lifetime for the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .WithSingletonLifetime());\n```\n\n
\n\n\n### `WithScopedLifetime`\nSets a scoped lifetime for the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .WithScopedLifetime());\n```\n\n
\n\n\n### `WithPerRequestLifetime`\nSets the lifetime to `PerRequestLifetime`. This lifetime will create a new instance between resolution requests. Within the request the same instance will be re-used.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithPerRequestLifetime());\n```\n\n
\n\n\n### `WithAutoLifetime`\nSets the lifetime to auto lifetime. This lifetime aligns to the lifetime of the resolved service's dependencies. When the underlying service has a dependency with a higher lifespan, this lifetime will inherit that lifespan up to a given boundary.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithAutoLifetime(Lifetimes.Scoped /* boundary lifetime */));\n```\n\n
\n\n\n### `WithLifetime`\nSets a custom lifetime for the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .WithLifetime(new CustomLifetime()));\n```\n\n
\n\n\n### `WhenHas`\nSets an attribute condition for the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .WhenHas());\n```\n\n
\n\n\n### `WhenResolutionPathHas`\nSets a resolution path condition for the registration. The service will be selected only in the resolution path of the target that has the given attribute.\nThis means that only the direct and sub-dependencies of the target type that has the given attribute will get the configured service.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n // Each direct and sub-dependency of any service that has\n // a ConsoleAttribute will get FileLogger wherever they \n // depend on ILogger. \n .WhenResolutionPathHas());\n```\n\n
\n\n\n### `WhenDependantIs`\nSets a parent target condition for the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .WhenDependantIs());\n```\n\n
\n\n\n### `WhenInResolutionPathOf`\nSets a resolution path condition for the registration. The service will be selected only in the resolution path of the given target.\nThis means that only the direct and sub-dependencies of the target type will get the configured service.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n // Each direct and sub-dependency of UserRepository\n // will get FileLogger wherever they depend on ILogger. \n .WhenInResolutionPathOf());\n```\n\n
\n\n\n### `When`\nSets a custom user-defined condition for the registration.\n\n
\n\n\n```cs\ncontainer.Register(config => config\n .When(typeInfo => typeInfo.ParentType == typeof(UserRepository)));\n```\n\n
\n\n\n### `WithConstructorSelectionRule`\nSets the constructor selection rule for the registration.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithConstructorSelectionRule(...));\n```\n\n
\n\n\n#### PreferMostParameters\nSelects the constructor which has the longest parameter list.\n\n
\n\n\n```cs\noptions.WithConstructorSelectionRule(\n Rules.ConstructorSelection.PreferMostParameters)\n```\n\n
\n\n\n#### PreferLeastParameters\nSelects the constructor which has the shortest parameter list.\n\n
\n\n\n```cs\noptions.WithConstructorSelectionRule(\n Rules.ConstructorSelection.PreferLeastParameters)\n```\n\n
\n\n\n#### Custom\nYou can set your own custom constructor ordering logic.\n\n
\n\n\n```cs\noptions.WithConstructorSelectionRule(\n constructors => { /* custom constructor sorting logic */ })\n```\n\n
\n\n\n### `WithConstructorByArgumentTypes`\nSelects a constructor by its argument types.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithConstructorByArgumentTypes(typeof(ILogger)));\n```\n\n
\n\n\n### `WithConstructorByArguments`\nSelects a constructor by its arguments to use during resolution. These arguments are used to invoke the selected constructor.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithConstructorByArguments(new ConsoleLogger()));\n```\n\n
\n\n\n### `WithAutoMemberInjection`\nEnables the auto member injection and sets the rule for it.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithAutoMemberInjection(...));\n```\n\n
\n\n\n#### PropertiesWithPublicSetter\nWith this flag, the container will perform auto-injection on properties with a public setter.\n\n
\n\n\n```cs\noptions.WithAutoMemberInjection(\n Rules.AutoMemberInjectionRules.PropertiesWithPublicSetter)\n```\n\n
\n\n\n#### PropertiesWithLimitedAccess\nWith this flag, the container will perform auto-injection on properties which has a non-public setter as well.\n\n
\n\n\n```cs\noptions.WithAutoMemberInjection(\n Rules.AutoMemberInjectionRules.PropertiesWithLimitedAccess)\n```\n\n
\n\n\n#### PrivateFields\nWith this flag, the container will perform auto-injection on private fields too.\n\n
\n\n\n```cs\noptions.WithAutoMemberInjection(\n Rules.AutoMemberInjectionRules.PrivateFields)\n```\n\n
\n\n\n#### Combined rules\nAs these rules are [bit flags](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/enum#enumeration-types-as-bit-flags), you can use them combined together with bitwise logical operators.\n\n
\n\n\n```cs\noptions.WithAutoMemberInjection(Rules.AutoMemberInjectionRules.PrivateFields | \n Rules.AutoMemberInjectionRules.PropertiesWithPublicSetter)\n```\n\n
\n\n\n#### Member selection filter\nYou can pass your own member selection logic to control which members should be auto injected.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithAutoMemberInjection(filter: member => member.Type != typeof(ILogger)));\n```\n\n
\n\n\nWith this option, you can enable or disable the auto injection of members defined with C# 11's [`required`](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required) keyword.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithRequiredMemberInjection(enabled: false));\n```\n\n
\n\n\n### `WithInjectionParameters`\nSets multiple injection parameters for the registration.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithInjectionParameters(new KeyValuePair(\"logger\", new ConsoleLogger()));\n```\n\n
\n\n\n### `WithInjectionParameter`\nSets a single injection parameter for the registration.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithInjectionParameter(\"logger\", new ConsoleLogger());\n```\n\n
\n\n\n### `InNamedScope`\nSets a scope name condition for the registration; it will be used only when a scope with the same name requests it.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .InNamedScope(\"UserRepo\"));\n```\n\n
\n\n\n### `InScopeDefinedBy`\nSets a condition for the registration; it will be used only within the scope defined by the given type.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .InScopeDefinedBy());\ncontainer.Register(options => options\n .DefinesScope());\n```\n\n
\n\n\n### `DefinesScope`\nThis registration is used as a logical scope for it's dependencies. Dependencies registered with `InNamedScope()` with the same name are preferred during resolution. \nWhen the `name` is not set, the [service type](/docs/getting-started/glossary#service-type--implementation-type) is used as the name. Dependencies registered with `InScopeDefinedBy()` are selected.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .DefinesScope(\"UserRepo\"));\n\n// or\ncontainer.Register(options => options\n .DefinesScope());\n```\n\n
\n\n\n### `WhenDecoratedServiceIs`\nSets a decorated target condition for the registration.\n\n
\n\n\n```cs\ncontainer.RegisterDecorator(options => options\n .WhenDecoratedServiceIs());\n```\n\n
\n\n\n### `WhenDecoratedServiceHas`\nSets an attribute condition that the decorated target has to satisfy.\n\n
\n\n\n```cs\ncontainer.RegisterDecorator(options => options\n .WhenDecoratedServiceHas());\n```\n\n
\n\n\n### `SetImplementationType`\nSets the current registration's [implementation type](/docs/getting-started/glossary#service-type--implementation-type).\n\n
\n\n\n```cs\nvar container = new StashboxContainer(c => c.WithUnknownTypeResolution(config =>\n{\n if (config.ServiceType == typeof(IService))\n config.SetImplementationType(typeof(Service));\n}));\n```\n\n
\n\n\n### `Skip`\nMarks the current unknown type registration as skipped.\n\n
\n\n\n```cs\nvar container = new StashboxContainer(c => c.WithUnknownTypeResolution(config =>\n{\n if (config.ServiceType == typeof(IService))\n config.Skip();\n}));\n```\n\n
\n\n\nWith the `IsRegistered()` function, you can find out whether a service is registered into the container or not.\n\nIt returns `true` only when the container has a registration with the given type (and name). It only checks the actual container's registrations. For every cases, you should use the `CanResolve()` method.\n\n
\n\n\n\n\n\n```cs\nbool isIJobRegistered = container.IsRegistered();\n```\n\n \n\n\n```cs\nbool isIJobRegistered = container.IsRegistered(typeof(IJob));\n```\n\n \n\n\n#### **Named**\n```cs\nbool isIJobRegistered = container.IsRegistered(\"DbBackup\");\n```\n\n \n \n
\n\n\nThere might be cases when you are more interested in whether a service is resolvable from the container's actual state rather than finding out whether it's registered.\n\n`CanResolve()` returns `true` only when at least one of the following is true:\n- The requested type is registered in the current or one of the parent containers.\n- The requested type is a closed generic type, and its open generic definition is registered.\n- The requested type is a wrapper (`IEnumerable<>`, `Lazy<>`, `Func<>`, `KeyValuePair<,>`, `ReadOnlyKeyValue<,>`, `Metadata<,>`, `ValueTuple<,>`, or `Tuple<,>`), and the underlying type is registered.\n- The requested type is not registered, but it's resolvable, and [unknown type resolution](/docs/configuration/container-configuration#unknown-type-resolution) is enabled.\n\n
\n\n\n\n\n\n```cs\nbool isIJobResolvable = container.CanResolve();\n```\n\n \n\n\n```cs\nbool isIJobResolvable = container.CanResolve(typeof(IJob));\n```\n\n \n\n\n```cs\nbool isIJobResolvable = container.CanResolve(\"DbBackup\");\n```\n\n \n \n
\n\n\nYou can get all registrations in a key-value pair collection (where the key is the [service type](/docs/getting-started/glossary#service-type--implementation-type) and the value is the actual registration) by calling the `.GetRegistrationMappings()` method.\n\n
\n\n\n```cs\nIEnumerable> mappings = \n container.GetRegistrationMappings();\n```\n\n
\n\n\nYou can get a much more readable version of the registration mappings by calling the `.GetRegistrationDiagnostics()` method.\n\n`RegistrationDiagnosticsInfo` has an overridden `.ToString()` method that returns the mapping details formatted in a human-readable form.\n\n
\n\n\n```cs\ncontainer.Register(\"DbBackupJob\");\ncontainer.Register(typeof(IEventHandler<>), typeof(EventHandler<>));\n\nIEnumerable diagnostics = \n container.GetRegistrationDiagnostics();\n\ndiagnostics.ForEach(Console.WriteLine);\n// output:\n// IJob => DbBackup, name: DbBackupJob\n// IEventHandler<> => EventHandler<>, name: null\n```\n\n
\n\n\nExample where a *Service type* is mapped to an *Implementation type*:\n\n
\n\n\n```cs\ncontainer.Register();\n```\n\n
\n\n\nThe *Service type* used for requesting a service from the container:\n\n
\n\n\n```cs\ncontainer.Resolve(); // returns Implementation\n```\n\n
\n\n\nIn this example, we are registering a named service. The container will create a service registration entity to store the type mapping and the name. During resolution, the container will find the registration by checking for the *Service type* and the *name*.\n\n
\n\n\n```cs\n// the registration entity will look like: \n// IService => Implementation, name: Example\ncontainer.Register(\"Example\");\nvar service = container.Resolve(\"Example\");\n```\n\n
\n\n\nIt's a constructor/method argument or a property/field of a registered *Implementation type* that gets evaluated (*injected*) by Stashbox during the service's construction.\n\nIn this example, `Implementation` has an `IDependency` *injectable dependency* in its constructor.\n\n
\n\n\n```cs\nclass Implementation : IService\n{\n public Implementation(IDependency dependency) \n { }\n}\n```\n\n
\n\n\nIt's a resolution request for a named service. The same applies, when the container sees a dependency in the resolution tree with a name (set by [attributes](/docs/guides/service-resolution#attributes) or [bindings](/docs/guides/service-resolution#dependency-binding)); it will search for a matching [Named registration](/docs/guides/basics#named-registration) to inject.\n\n
\n\n\n```cs\ncontainer.Register(\"Example\");\n// the named request.\nvar service = container.Resolve(\"Example\");\n```\n\n
\n\n\nIt's a service registration that's mapped to itself. This means its service and implementation type is the same.\n\n
\n\n\n```cs\n// equivalent to container.Register();\ncontainer.Register();\n```\n\n
\n\n\nYou can bind a factory delegate to a registration that the container will invoke directly to instantiate your service. \n\nYou can use parameter-less and custom parameterized delegates as a factory. [Here](/docs/configuration/registration-configuration#factory) is the list of all available options.\n\nYou can also get the current [dependency resolver](/docs/getting-started/glossary#dependency-resolver) as a delegate parameter to resolve any additional dependencies required for the service construction.\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .WithFactory(() => new ConsoleLogger());\n\n// the container uses the factory for instantiation.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .WithFactory(logger => new DbBackup(logger));\n\n// the container uses the factory for instantiation.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .WithFactory(resolver => new DbBackup(resolver.Resolve()));\n \n// the container uses the factory for instantiation.\nIJob job = container.Resolve();\n```\n\n \n \n
\n\n\nDelegate factories are useful when your service's instantiation is not straight-forward for the container, like when it depends on something that is not available at resolution time. E.g., a connection string.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithFactory(logger => \n new DbBackup(Configuration[\"DbConnectionString\"], logger));\n```\n\n
\n\n\n### Factories with parameter overrides\nStashbox can implicitly [wrap](/docs/advanced/wrappers-resolvers#delegate) your service in a `Delegate` and lets you pass parameters that can override your service's dependencies. Moreover, you can register your own custom delegate that the container will resolve when you request your service wrapped in a `Delegate`.\n\n
\n\n\n\n\n\n```cs\ncontainer.RegisterFunc((connectionString, resolver) => \n new DbBackup(connectionString, resolver.Resolve()));\n\nFunc backupFactory = container.Resolve>();\nIJob dbBackup = backupFactory(Configuration[\"ConnectionString\"]);\n```\n\n \n\n\n```cs\ncontainer.RegisterFunc((connectionString, resolver) => \n new DbBackup(connectionString, resolver.Resolve()));\n\nDelegate backupFactory = container.ResolveFactory(typeof(IJob), \n parameterTypes: new[] { typeof(string) });\nIJob dbBackup = backupFactory.DynamicInvoke(Configuration[\"ConnectionString\"]);\n```\n\n\n \n \n
\n\n\nIf a service has multiple constructors, the container visits those first, that has matching parameters passed to the factory, with respecting the additional [constructor selection rules](/docs/configuration/registration-configuration#constructor-selection).\n\n
\n\n\n```cs\nclass Service\n{\n public Service(int number) { }\n public Service(string text) { }\n}\n\ncontainer.Register();\n\n// create the factory with an int input parameter.\nvar func = constainer.Resolve>();\n\n// the constructor with the int param \n// is used for instantiation.\nvar service = func(2);\n```\n
\n\n\n### Consider this before using the resolver parameter inside a factory\nDelegate factories are a black-box for the container. It doesn't have control over what's happening inside a delegate, which means when you resolve additional dependencies with the [dependency resolver](/docs/getting-started/glossary#dependency-resolver) parameter, they could easily bypass the [lifetime](/docs/diagnostics/validation#lifetime-validation) and [circular dependency](/docs/diagnostics/validation#circular-dependency) validations. Fortunately, you have the option to keep them validated anyway with parameterized factory delegates.\n\n#### Delegates with dependencies passed as parameters\nRather than using the [dependency resolver](/docs/getting-started/glossary#dependency-resolver) parameter inside the factory, let the container inject the dependencies into the delegate as parameters. This way, the [resolution tree's](/docs/getting-started/glossary#resolution-tree) integrity remains stable because no service resolution happens inside the black-box, and each parameter is validated.\n\n
\n\n\n\n```cs\ninterface IEventProcessor { }\n\nclass EventProcessor : IEventProcessor\n{\n public EventProcessor(ILogger logger, IEventValidator validator)\n { }\n}\n\ncontainer.Register();\ncontainer.Register();\n\ncontainer.Register(options => options\n // Ilogger and IEventValidator instances are injected\n // by the container at resolution time, so they will be\n // validated against circular and captive dependencies.\n .WithFactory((logger, validator) => \n new EventProcessor(logger, validator));\n\n// the container resolves ILogger and IEventValidator first, then\n// it passes them to the factory as delegate parameters.\nIEventProcessor processor = container.Resolve();\n```\n\n
\n\n\n### Accessing the currently resolving type in factories\n\nTo access the currently resolving type in factory delegates, you can set the `TypeInformation` type as an input parameter of the factory.\nThe `TypeInformation` holds every reflected context information about the currently resolving type. \n\nThis can be useful when the resolution is, e.g., in an open generic context, and we want to know which closed generic variant is requested.\n\n
\n\n\n\n```cs\ninterface IService { }\n\nclass Service : IService { }\n\ncontainer.Register(typeof(IService<>), typeof(Service<>), options => \n options.WithFactory(typeInfo => \n {\n // typeInfo.Type here holds the actual type like\n // IService based on the resolution request below.\n }));\n \ncontainer.Resolve>();\n```\n\n
\n\n\nAs we previously saw in the [Named registration](/docs/guides/basics#named-registration) topic, Stashbox allows you to have multiple implementations bound to a particular [service type](/docs/getting-started/glossary#service-type--implementation-type). You can use names to distinguish them, but you can also access them by requesting a typed collection using the [service type](/docs/getting-started/glossary#service-type--implementation-type).\n\n:::note \nThe returned collection is in the same order as the services were registered.\nAlso, to request a collection, you can use any interface implemented by an array.\n:::\n\n
\n\n\n```cs\ncontainer.Register();\ncontainer.Register();\ncontainer.Register();\n```\n\n\n\n\n```cs\n// jobs contain all three services in registration order.\nIEnumerable jobs = container.ResolveAll();\n```\n\n \n\n\n```cs\n// jobs contain all three services in registration order.\nIJob[] jobs = container.Resolve();\n```\n\n \n\n\n```cs\n// jobs contain all three services in registration order.\nIEnumerable jobs = container.Resolve>();\n```\n\n \n\n\n```cs\n// jobs contain all three services in registration order.\nIList jobs = container.Resolve>();\n```\n\n \n\n\n```cs\n// jobs contain all three services in registration order.\nICollection jobs = container.Resolve>();\n```\n\n \n \n
\n\n\nWhen you have multiple implementations registered to a service, a request to the [service type](/docs/getting-started/glossary#service-type--implementation-type) without a name will return the **last registered implementation**.\n\n:::info\nNot only names can be used to distinguish registrations, [conditions](/docs/guides/service-resolution#conditional-resolution), [named scopes](/docs/guides/scopes#named-scopes), and [metadata](/docs/advanced/wrappers-resolvers#metadata--tuple) can also influence the results.\n:::\n\n
\n\n\n```cs\ncontainer.Register();\ncontainer.Register();\ncontainer.Register();\n\n// job will be the ImageProcess.\nIJob job = container.Resolve();\n```\n\n
\n\n\nWhen you have a service that implements multiple interfaces, you have the option to bind its registration to all or some of those additional interfaces or base types.\n\nSuppose we have the following class declaration:\n```cs\nclass DbBackup : IJob, IScheduledJob\n{ \n public DbBackup() { }\n}\n```\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .AsServiceAlso());\n\nIJob job = container.Resolve(); // DbBackup\nIScheduledJob job = container.Resolve(); // DbBackup\nDbBackup job = container.Resolve(); // error, not found\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .AsImplementedTypes());\n\nIJob job = container.Resolve(); // DbBackup\nIScheduledJob job = container.Resolve(); // DbBackup\nDbBackup job = container.Resolve(); // DbBackup\n```\n\n \n \n
\n\n\nYou have the option to register multiple services in a single registration operation. \n\n**Filters (optional):**\nFirst, the container will use the *implementation filter* action to select only those types from the collection we want to register. When we have those, the container will execute the *service filter* on their implemented interfaces and base classes to select which [service type](/docs/getting-started/glossary#service-type--implementation-type) they should be mapped to.\n\n:::note\nFramework types like `IDisposable` are excluded from being considered as a [service type](/docs/getting-started/glossary#service-type--implementation-type) by default.\n:::\n\n:::tip \nYou can use the registration configuration API to configure individual registrations.\n:::\n\n
\n\n\n\n\n\nThis example will register three types to all their implemented interfaces, extended base classes, and to themselves ([self registration](/docs/getting-started/glossary#self-registration)) without any filter:\n```cs\ncontainer.RegisterTypes(new[] \n { \n typeof(DbBackup), \n typeof(ConsoleLogger), \n typeof(StorageCleanup) \n });\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nILogger logger = container.Resolve(); // ConsoleLogger\nIJob job = container.Resolve(); // StorageCleanup\nDbBackup backup = container.Resolve(); // DbBackup\n```\n\n \n\n\nIn this example, we assume that `DbBackup` and `StorageCleanup` are implementing `IDisposable` besides `IJob` and also extending a `JobBase` abstract class.\n```cs\ncontainer.RegisterTypes(new[] \n { typeof(DbBackup), typeof(ConsoleLogger), typeof(StorageCleanup) },\n // implementation filter, only those implementations that implements IDisposable\n impl => typeof(IDisposable).IsAssignableFrom(impl),\n // service filter, register them to base classes only\n (impl, service) => service.IsAbstract && !service.IsInterface);\n\nIEnumerable jobs = container.ResolveAll(); // 0 items\nIEnumerable jobs = container.ResolveAll(); // 2 items\nILogger logger = container.Resolve(); // error, not found\nDbBackup backup = container.Resolve(); // DbBackup\n```\n\n \n\n\nThis example ignores the [self registrations](/docs/getting-started/glossary#self-registration) completely:\n```cs\ncontainer.RegisterTypes(new[] \n { \n typeof(DbBackup), \n typeof(ConsoleLogger), \n typeof(StorageCleanup)\n },\n registerSelf: false);\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nILogger logger = container.Resolve(); // ConsoleLogger\nDbBackup backup = container.Resolve(); // error, not found\nConsoleLogger logger = container.Resolve(); // error, not found\n```\n\n \n\n\nThis example will configure all registrations mapped to `ILogger` as `Singleton`:\n```cs\ncontainer.RegisterTypes(new[] \n { \n typeof(DbBackup), \n typeof(ConsoleLogger), \n typeof(StorageCleanup)\n },\n configurator: options => \n {\n if (options.HasServiceType())\n options.WithSingletonLifetime();\n });\n\nILogger logger = container.Resolve(); // ConsoleLogger\nILogger newLogger = container.Resolve(); // the same ConsoleLogger\nIEnumerable jobs = container.ResolveAll(); // 2 items\n```\n\n \n \n\n
\n\n\nAnother type of service filter is the `.RegisterTypesAs()` method, which registers only those types that implements the `T` [service type](/docs/getting-started/glossary#service-type--implementation-type).\n\n:::note \nThis method also accepts an implementation filter and a registration configurator action like `.RegisterTypes()`.\n:::\n\n:::caution\n`.RegisterTypesAs()` doesn't create [self registrations](/docs/getting-started/glossary#self-registration) as it only maps the implementations to the given `T` [service type](/docs/getting-started/glossary#service-type--implementation-type).\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.RegisterTypesAs(new[] \n { \n typeof(DbBackup), \n typeof(ConsoleLogger), \n typeof(StorageCleanup) \n });\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nILogger logger = container.Resolve(); // error, not found\nIJob job = container.Resolve(); // StorageCleanup\nDbBackup backup = container.Resolve(); // error, not found\n```\n\n \n\n\n```cs\ncontainer.RegisterTypesAs(typeof(IJob), new[] \n { \n typeof(DbBackup), \n typeof(ConsoleLogger), \n typeof(StorageCleanup) \n });\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nILogger logger = container.Resolve(); // error, not found\nIJob job = container.Resolve(); // StorageCleanup\nDbBackup backup = container.Resolve(); // error, not found\n```\n\n \n \n
\n\n\nThe batch registration API *(filters, registration configuration action, self-registration)* is also usable for registering services from given assemblies.\n\nIn this example, we assume that the same three services we used in the [batch registration](#batch-registration) section are in the same assembly.\n\n:::info\nThe container also detects and registers open-generic definitions (when applicable) from the supplied type collection. You can read about [open-generics here](/docs/advanced/generics#open-generics).\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.RegisterAssembly(typeof(DbBackup).Assembly,\n // service filter, register to interfaces only\n serviceTypeSelector: (impl, service) => service.IsInterface,\n registerSelf: false,\n configurator: options => options.WithoutDisposalTracking()\n);\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nIEnumerable jobs = container.ResolveAll(); // 0 items\nILogger logger = container.Resolve(); // ConsoleLogger\nDbBackup backup = container.Resolve(); // error, not found\n```\n\n \n\n\n```cs\ncontainer.RegisterAssemblies(new[] \n { \n typeof(DbBackup).Assembly, \n typeof(JobFromAnotherAssembly).Assembly \n },\n // service filter, register to interfaces only\n serviceTypeSelector: (impl, service) => service.IsInterface,\n registerSelf: false,\n configurator: options => options.WithoutDisposalTracking()\n);\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nIEnumerable jobs = container.ResolveAll(); // 0 items\nILogger logger = container.Resolve(); // ConsoleLogger\nDbBackup backup = container.Resolve(); // error, not found\n```\n\n \n\n\n```cs\ncontainer.RegisterAssemblyContaining(\n // service filter, register to interfaces only\n serviceTypeSelector: (impl, service) => service.IsInterface,\n registerSelf: false,\n configurator: options => options.WithoutDisposalTracking()\n);\n\nIEnumerable jobs = container.ResolveAll(); // 2 items\nIEnumerable jobs = container.ResolveAll(); // 0 items\nILogger logger = container.Resolve(); // ConsoleLogger\nDbBackup backup = container.Resolve(); // error, not found\n```\n\n \n \n
\n\n\nThe [Composition Root](https://blog.ploeh.dk/2011/07/28/CompositionRoot/) is an entry point where all services required to make a component functional are wired together.\n\nStashbox provides an `ICompositionRoot` interface that can be used to define an entry point for a given component or even for an entire assembly. \n\nYou can wire up your *composition root* implementation with `ComposeBy()`, or you can let the container find and execute all available *composition root* implementations within an assembly.\n\n:::note\nYour `ICompositionRoot` implementation also can have dependencies that the container will resolve.\n:::\n\n
\n\n\n\n```cs\nclass ExampleRoot : ICompositionRoot\n{\n public ExampleRoot(IDependency rootDependency)\n { }\n\n public void Compose(IStashboxContainer container)\n {\n container.Register();\n container.Register();\n }\n}\n```\n\n\n\n\n```cs\n// compose a single root.\ncontainer.ComposeBy();\n```\n\n \n\n\n```cs\n// compose every root in the given assembly.\ncontainer.ComposeAssembly(typeof(IServiceA).Assembly);\n```\n\n \n\n\n```cs\n// compose a single root with dependency override.\ncontainer.ComposeBy(new CustomRootDependency());\n```\n\n \n \n
\n\n\nIf you have pre-evaluated dependencies you'd like to inject at resolution time, you can set them as injection parameters during registration. \n\n:::note\nInjection parameter names are matched to constructor arguments or field/property names.\n:::\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithInjectionParameter(\"logger\", new ConsoleLogger())\n .WithInjectionParameter(\"eventBroadcaster\", new MessageBus());\n\n// the injection parameters will be passed to DbBackup's constructor.\nIJob backup = container.Resolve();\n```\n
\n\n\nThe container provides specific extension points to let you react to lifetime events of an instantiated service. \n\nFor this reason, you can specify *Initializer* and *Finalizer* delegates. The *finalizer* is called upon the service's [disposal](/docs/guides/scopes#disposal), and the *initializer* is called upon the service's construction.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n // delegate that called right after instantiation.\n .WithInitializer((logger, resolver) => logger.OpenFile())\n // delegate that called right before the instance's disposal.\n .WithFinalizer(logger => logger.CloseFile()));\n```\n
\n\n\nStashbox allows registration operations via the `Register()` methods. \n\nDuring registration, the container checks whether the [service type](/docs/getting-started/glossary#service-type--implementation-type) is assignable from the [implementation type](/docs/getting-started/glossary#service-type--implementation-type) and if not, the container throws an [exception](/docs/diagnostics/validation#registration-validation). \n\nAlso, when the implementation is not resolvable, the container throws the same [exception](/docs/diagnostics/validation#registration-validation).\n\nThe example registers `DbBackup` to be returned when `IJob` is requested.\n\n
\n\n\n\n\n\n\n```cs\ncontainer.Register();\nIJob job = container.Resolve();\n// throws an exception because ConsoleLogger doesn't implement IJob.\ncontainer.Register();\n// throws an exception because IJob is not a valid implementation.\ncontainer.Register();\n```\n\n \n\n\n```cs\ncontainer.Register(typeof(IJob), typeof(DbBackup));\nobject job = container.Resolve(typeof(IJob));\n// throws an exception because ConsoleLogger doesn't implement IJob.\ncontainer.Register(typeof(IJob), typeof(ConsoleLogger));\n// throws an exception because IJob is not a valid implementation.\ncontainer.Register(typeof(IJob), typeof(IJob));\n```\n\n \n \n
\n\n\nYou can register a service to itself without specifying a [service type](/docs/getting-started/glossary#service-type--implementation-type), only the implementation ([self registration](/docs/getting-started/glossary#self-registration)). \n\nIn this case, the given implementation is considered the [service type](/docs/getting-started/glossary#service-type--implementation-type) and must be used to request the service (`DbBackup` in the example).\n\n
\n\n\n\n\n```cs\ncontainer.Register();\nDbBackup backup = container.Resolve();\n```\n\n \n\n\n```cs\ncontainer.Register(typeof(DbBackup));\nobject backup = container.Resolve(typeof(DbBackup));\n```\n \n \n
\n\n\nThe container's API is fluent, which means you can chain the calls on its methods after each other.\n\n
\n\n\n```cs\nvar job = container.Register()\n .Register()\n .Resolve();\n```\n\n
\n\n\nThe example shows how you can bind more implementations to a [service type](/docs/getting-started/glossary#service-type--implementation-type) using names for identification. \n\nThe same name must be used to resolve the named service.\n\n:::note\nThe name is an `object` type.\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(\"DbBackup\");\ncontainer.Register(\"StorageCleanup\");\nIJob cleanup = container.Resolve(\"StorageCleanup\");\n```\n\n \n\n\n```cs\ncontainer.Register(typeof(IJob), typeof(DbBackup), \"DbBackup\");\ncontainer.Register(typeof(IJob), typeof(StorageCleanup), \"StorageCleanup\");\nobject cleanup = container.Resolve(typeof(IJob), \"StorageCleanup\");\n```\n\n \n \n
\n\n\nYou can also get each service that share the same name by requesting an `IEnumerable<>` or using the `ResolveAll()` method with the `name` parameter.\n\n
\n\n\n```cs\ncontainer.Register(\"StorageJobs\");\ncontainer.Register(\"StorageJobs\");\ncontainer.Register();\n// jobs will be [DbBackup, StorageCleanup].\nIEnumerable jobs = container.Resolve>(\"StorageJobs\");\n```\n\n
\n\n\nWith instance registration, you can provide an already created external instance to use when the given [service type](/docs/getting-started/glossary#service-type--implementation-type) is requested.\n\nStashbox automatically handles the [disposal](/docs/guides/scopes#disposal) of the registered instances, but you can turn this feature off with the `withoutDisposalTracking` parameter.\n\nWhen an `IJob` is requested, the container will always return the external instance.\n\n
\n\n\n\n\n```cs\nvar job = new DbBackup();\ncontainer.RegisterInstance(job);\n\n// resolvedJob and job are the same.\nIJob resolvedJob = container.Resolve();\n```\n\n \n\n\n```cs\nvar job = new DbBackup();\ncontainer.RegisterInstance(job, typeof(IJob));\n\n// resolvedJob and job are the same.\nobject resolvedJob = container.Resolve(typeof(IJob));\n```\n\n \n\n\n```cs\nvar job = new DbBackup();\ncontainer.RegisterInstance(job, \"DbBackup\");\n\n// resolvedJob and job are the same.\nIJob resolvedJob = container.Resolve(\"DbBackup\");\n```\n\n \n\n\n```cs\nvar job = new DbBackup();\ncontainer.RegisterInstance(job, withoutDisposalTracking: true);\n\n// resolvedJob and job are the same.\nIJob resolvedJob = container.Resolve();\n```\n\n \n \n
\n\n\nThe instance registration API allows the batched registration of different instances.\n\n
\n\n\n```cs\ncontainer.RegisterInstances(new DbBackup(), new StorageCleanup());\nIEnumerable jobs = container.ResolveAll();\n```\n\n
\n\n\nWith re-map, you can bind new implementations to a [service type](/docs/getting-started/glossary#service-type--implementation-type) and delete old registrations in one action. \n\n:::caution\nWhen there are multiple registrations mapped to a [service type](/docs/getting-started/glossary#service-type--implementation-type), `.ReMap()` will replace all of them with the given [implementation type](/docs/getting-started/glossary#service-type--implementation-type). If you want to replace only one specific service, use the `.ReplaceExisting()` [configuration option](/docs/configuration/registration-configuration#replace).\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.Register();\ncontainer.Register();\n// jobs contain all two jobs\nIEnumerable jobs = container.ResolveAll();\n\ncontainer.ReMap();\n// jobs contains only the SlackMessageSender\njobs = container.ResolveAll();\n```\n\n \n\n\n```cs\ncontainer.Register(typeof(IJob), typeof(DbBackup));\ncontainer.Register(typeof(IJob), typeof(StorageCleanup));\n// jobs contain all two jobs\nIEnumerable \n \n
\n\n\nWiring up is similar to [Instance registration](#instance-registration) except that the container will perform property/field injection (if configured so and applicable) on the registered instance during resolution.\n\n
\n\n\n\n\n\n```cs\ncontainer.WireUp(new DbBackup());\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\ncontainer.WireUp(new DbBackup(), typeof(IJob));\nobject job = container.Resolve(typeof(IJob));\n```\n\n \n \n
\n\nA service's lifetime indicates how long its instance will live and which re-using policy should be applied when it gets injected.\n\nThis example shows how you can use the registration API's shortcuts for lifetimes. These are just sugars, and there are more ways explained in the [lifetimes](/docs/guides/lifetimes) section.\n\n:::info\nThe `DefaultLifetime` is [configurable](/docs/guides/lifetimes#default-lifetime).\n:::\n\n
\n\n\n\n\n\nWhen no lifetime is specified, the service will use the container's `DefaultLifetime`, which is `Transient` by default.\n\n```cs\ncontainer.Register();\nIJob job = container.Resolve();\n```\n\n \n\n\nA service with `Singleton` lifetime will be instantiated once and reused during the container's lifetime.\n```cs\ncontainer.RegisterSingleton();\nIJob job = container.Resolve();\n```\n\n \n\n\nThe `Scoped` lifetime behaves like a `Singleton` within a [scope](/docs/guides/scopes). \nA scoped service is instantiated once and reused during the scope's whole lifetime.\n```cs\ncontainer.RegisterScoped();\nIJob job = container.Resolve();\n```\n\n \n \n
\n\n\nWhen you are not specifying a lifetime during registration, Stashbox will use the default lifetime. By default, it's set to [Transient](#transient-lifetime), but you can override it with the `.WithDefaultLifetime()` [container configuration option](/docs/configuration/container-configuration#default-lifetime). \n\nYou can choose either from the pre-defined lifetimes defined on the `Lifetimes` static class or use a [custom lifetime](#custom-lifetime).\n\n
\n\n\n\n\n\n```cs\nvar container = new StashboxContainer(options => options\n .WithDefaultLifetime(Lifetimes.Transient));\n```\n\n \n\n\n```cs\nvar container = new StashboxContainer(options => options\n .WithDefaultLifetime(Lifetimes.Singleton));\n```\n\n \n\n\n```cs\nvar container = new StashboxContainer(options => options\n .WithDefaultLifetime(Lifetimes.Scoped));\n```\n\n \n \n
\n\n\nA new instance is created for each resolution request. If a transient is referred by multiple consumers in the same [resolution tree](/docs/getting-started/glossary#resolution-tree), each will get a new instance.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithLifetime(Lifetimes.Transient));\n```\n\n
\n\n\nA single instance is created and reused for each resolution request and injected into each consumer.\n\n:::note\nSingleton services are disposed when the container ([root scope](/docs/getting-started/glossary#root-scope)) is being disposed.\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .WithLifetime(Lifetimes.Singleton));\n```\n\n \n\n\n```cs\ncontainer.RegisterSingleton();\n```\n\n \n \n
\n\n\nA new instance is created for each [scope](/docs/guides/scopes), which will be returned for every resolution request initiated on the given scope. It's like a singleton lifetime within a scope. \n\n:::note\nScoped services are disposed when their scope is being disposed.\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .WithLifetime(Lifetimes.Scoped));\n\nusing var scope = container.BeginScope();\nIJob job = scope.Resolve();\n```\n\n \n\n\n```cs\ncontainer.RegisterScoped();\n\nusing var scope = container.BeginScope();\nIJob job = scope.Resolve();\n```\n\n \n \n
\n\n\nIt is the same as scoped lifetime, except the given service will be selected only when a scope with the same name initiates the resolution request.\n\nYou can also let a service [define](/docs/guides/scopes#service-as-scope) its own named scope. During registration, this scope can be referred to by its name upon using a named scope lifetime.\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .InNamedScope(\"DbScope\"));\n\nusing var scope = container.BeginScope(\"DbScope\");\nIJob job = scope.Resolve();\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .DefinesScope());\n\nontainer.Register(options => options\n .InScopeDefinedBy());\n\n// the executor will begin a new scope within itself\n// when it gets resolved and DbBackup will be selected\n// and attached to that scope instead.\nusing var scope = container.BeginScope();\nDbJobExecutor executor = scope.Resolve();\n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .DefinesScope(\"DbScope\"));\n\nontainer.Register(options => options\n .InNamedScope(\"DbScope\"));\n\n// the executor will begin a new scope within itself\n// when it gets resolved and DbBackup will be selected\n// and attached to that scope instead.\nusing var scope = container.BeginScope();\nDbJobExecutor executor = scope.Resolve();\n```\n\n \n \n
\n\n\nThe requested service will be reused within the whole resolution request. A new instance is created for each individual request .\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithPerRequestLifetime());\n```\n\n
\n\n\nThe requested service's lifetime will align to the lifetime of its dependencies. When the requested service has a dependency with a higher lifespan, this lifetime will inherit that lifespan up to a given boundary.\n\n
\n\n\n```cs\ncontainer.Register(options => options\n .WithAutoLifetime(Lifetimes.Scoped /* boundary lifetime */));\n```\n\n
\n\n\nIf the requested service has auto lifetime with a scoped boundary and it has only transient dependencies, it'll inherit their transient lifetime.\n\n
\n\n\n```cs\ncontainer.Register();\n\ncontainer.Register(options => options\n .WithAutoLifetime(Lifetimes.Scoped /* boundary lifetime */));\n\n// job has transient lifetime.\nvar job = container.Resolve();\n```\n\n
\n\n\nWhen there's a dependency with higher lifespan than the given boundary, the requested service will get the boundary lifetime.\n\n
\n\n\n```cs\ncontainer.RegisterSingleton();\n\ncontainer.Register(options => options\n .WithAutoLifetime(Lifetimes.Scoped /* boundary lifetime */));\n\n// job has scoped lifetime.\nvar job = container.Resolve();\n```\n\n
\n\n\nYou can create a scope from the container by calling its `.BeginScope()` method.\n\nScopes can be **nested**, which means you can create sub-scopes from existing ones with their `.BeginScope()` method. \n\nScoped service instances are not shared across parent and sub-scope relations.\n\nNested scopes can be **attached to their parent's lifetime**, which means when a parent gets disposed all child scopes attached to it will be disposed.\n\nScopes are `IDisposable`; they track all `IDisposable` instances they resolved. Calling their `Dispose()` method or wrapping them in `using` statements is a crucial part of their service's lifetime management.\n\n
\n\n\n\n\n\n```cs\ncontainer.RegisterScoped();\n\n// create the scope with using so it'll be auto disposed.\nusing (var scope = container.BeginScope())\n{\n IJob job = scope.Resolve();\n IJob jobAgain = scope.Resolve();\n // job and jobAgain are created in the \n // same scope, so they are the same instance.\n}\n```\n\n \n\n\n```cs\ncontainer.RegisterScoped();\n\nusing (var parent = container.BeginScope())\n{\n IJob job = parent.Resolve();\n IJob jobAgain = parent.Resolve();\n // job and jobAgain are created in the \n // same scope, so they are the same instance.\n\n // create a sub-scope.\n using var sub = parent.BeginScope();\n\n IJob subJob = sub.Resolve();\n // subJob is a new instance created in the sub-scope, \n // differs from either job and jobAgain.\n}\n```\n\n \n\n\n```cs\ncontainer.RegisterScoped();\n\nvar parent = container.BeginScope();\nvar sub = parent.BeginScope(attachToParent: true);\n\n// sub will also be disposed with the scope.\nscope.Dispose(); \n```\n\n \n \n
\n\n\nThere might be cases where you don't want to use a service globally across every scope, only in specific ones. \n\nFor this reason, you can differentiate specific scope groups from other scopes with a **name**.\n\nYou can set a service's lifetime to [named scope lifetime](/docs/guides/lifetimes#named-scope-lifetime) initialized with the **scope's name** to mark it usable only for that named scope.\n\n```cs\ncontainer.Register(options => \n options.InNamedScope(\"DbScope\"));\n\ncontainer.Register(options => \n options.InNamedScope(\"DbScope\"));\n\ncontainer.Register(options => \n options.InNamedScope(\"DbSubScope\"));\n\ncontainer.Register(options => \n options.InNamedScope(\"StorageScope\"));\n```\n\n:::note\nServices with named scope lifetime are **shared across parent and sub-scope relations**.\n:::\n\nIf you request a name-scoped service from an un-named scope, you'll get an error or no result (depending on the configuration) because those services are selectable only by named scopes with a matching name.\n\n
\n\n\n```cs\nusing (var dbScope = container.BeginScope(\"DbScope\"))\n{ \n // DbBackup and DbCleanup will be returned.\n IEnumerable jobs = dbScope.ResolveAll();\n\n // create a sub-scope of dbScope.\n using var sub = dbScope.BeginScope();\n\n // DbBackup and DbCleanup will be returned from the named parent scope.\n IEnumerable jobs = sub.ResolveAll();\n\n // create a named sub-scope.\n using var namedSub = dbScope.BeginScope(\"DbSubScope\");\n // DbIndexRebuild will be returned from the named sub-scope.\n IEnumerable jobs = namedSub.ResolveAll();\n}\n\nusing (var storageScope = container.BeginScope(\"StorageScope\"))\n{\n // StorageCleanup will be returned.\n IJob job = storageScope.Resolve();\n}\n\n// create a common scope without a name.\nusing (var unNamed = container.BeginScope())\n{\n // empty result as there's no service registered without named scope.\n IEnumerable jobs = unNamed.ResolveAll();\n\n // throws an exception because there's no unnamed service registered.\n IJob job = unNamed.Resolve();\n}\n```\n\n
\n\n\nYou can configure a service to behave like a nested named scope. At the resolution of this kind of service, a new dedicated named scope is created implicitly for managing the service's dependencies. \n\nWith this feature, you can organize your dependencies around logical groups (named scopes) instead of individual services.\n\nUsing `InScopeDefinedBy()`, you can bind services to a defined scope without giving it a name. In this case, the defining service's [implementation type](/docs/getting-started/glossary#service-type--implementation-type) is used for naming the scope.\n\n:::note\nThe lifetime of the defined scope is attached to the current scope that was used to create the service.\n:::\n\n
\n\n\n\n\n\n```cs\ncontainer.Register(options => options\n .DefinesScope(\"DbBackupScope\"));\ncontainer.Register(options => options\n .InNamedScope(\"DbBackupScope\"));\ncontainer.Register();\n\nvar scope = container.BeginScope();\n\n// DbBackup will create a named scope with the name \"DbBackupScope\".\n// the named scope will select ConsoleLogger as it's \n// bound to the named scope's identifier.\nIJob job = scope.Resolve();\n\n// this will dispose the implicitly created named scope by DbBackup.\nscope.Dispose(); \n```\n\n \n\n\n```cs\ncontainer.Register(options => options\n .DefinesScope());\ncontainer.Register(options => options\n .InScopeDefinedBy());\ncontainer.Register();\n\nvar scope = container.BeginScope();\n\n// DbBackup will create a named scope with the name typeof(DbBackup).\n// the named scope will select ConsoleLogger as it's \n// bound to the named scope's identifier.\nIJob job = scope.Resolve();\n\n// this will dispose the implicitly created named scope by DbBackup.\nscope.Dispose(); \n```\n\n \n \n
\n\n\nYou can add an already instantiated service to a scope. The instance's lifetime will be tracked by the given scope.\n\n
\n\n\n```cs\nusing var scope = container.BeginScope();\nscope.PutInstanceInScope(new DbBackup());\n```\n\n
\n\n\nYou can disable the tracking by passing `true` for the `withoutDisposalTracking` parameter. In this case, only the strong reference to the instance is dropped when the scope is disposed.\n\n
\n\n\n```cs\nusing var scope = container.BeginScope();\nscope.PutInstanceInScope(new DbBackup(), withoutDisposalTracking: true);\n```\n\n
\n\n\nYou can also give your instance a name to use it like a [named registration](/docs/guides/basics#named-registration):\n\n
\n\n\n```cs\nusing var scope = container.BeginScope();\nscope.PutInstanceInScope(new DbBackup(), false, name: \"DbBackup\");\n```\n\n
\n\n\nThe currently resolving scope tracks services that implement either `IDisposable` or `IAsyncDisposable`. This means that when the scope is disposed, all the tracked disposable instances will be disposed with it.\n\n:::note\nDisposing the container will dispose all the singleton instances and their dependencies.\n:::\n\n
\n\n\n\n\n\n```cs\nusing (var scope = container.BeginScope())\n{\n var disposable = scope.Resolve();\n} // 'disposable' will be disposed when \n // the using statement ends.\n```\n\n \n\n\n```cs\nvar scope = container.BeginScope();\nvar disposable = scope.Resolve();\n\n// 'disposable' will be disposed with the scope.\nscope.Dispose();\n```\n\n \n \n
\n\n\nYou can disable the disposal tracking on a [service registration](/docs/getting-started/glossary#service-registration--registered-service) with the `.WithoutDisposalTracking()` option.\n\n
\n\n\n```cs\ncontainer.Register(options => \n options.WithoutDisposalTracking());\n```\n\n
\n\n\n### Async disposal\nAs the container and its scopes implement the `IAsyncDisposable` interface, you can dispose them asynchronously when they are used in an `async` context.\n\nCalling `DisposeAsync` disposes both `IDisposable` and `IAsyncDisposable` instances; however, calling `Dispose` only disposes `IDisposable` instances.\n\n
\n\n\n\n\n\n```cs\nawait using (var scope = container.BeginScope())\n{\n var disposable = scope.Resolve();\n} // 'disposable' will be disposed asynchronously \n // when the using statement ends.\n```\n\n \n\n\n```cs\nvar scope = container.BeginScope();\nvar disposable = scope.Resolve();\n\n// 'disposable' will be disposed asynchronously with the scope.\nawait scope.DisposeAsync();\n```\n\n \n \n
\n\n\n### Finalizer delegate\nDuring [service registration](/docs/getting-started/glossary#service-registration--registered-service), you can set a custom finalizer delegate that will be invoked at the service's disposal.\n\n
\n\n\n```cs\ncontainer.Register(options => \n options.WithFinalizer(backup => \n backup.CloseDbConnection()));\n```\n\n
\n\n\n**Constructor injection** is the *primary dependency injection pattern*. It encourages the organization of dependencies to a single place - the constructor.\n\nStashbox, by default, uses the constructor that has the most parameters it knows how to resolve. This behavior is configurable through [constructor selection](/docs/configuration/registration-configuration#constructor-selection).\n\n[Property/field injection](/docs/configuration/registration-configuration#property-field-injection) is also supported in cases where constructor injection is not applicable.\n\nMembers defined with C# 11's [`required`](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required) keyword are automatically injected by the container. \nThis behavior can be controlled with [registration](/docs/configuration/registration-configuration#required-member-injection) or [container](/docs/configuration/container-configuration#required-member-injection) configuration options \n\n:::info \n[Constructor selection](/docs/configuration/container-configuration#constructor-selection) and [property/field injection](/docs/configuration/container-configuration#auto-member-injection) is also configurable container-wide.\n:::\n\n
\n\n\n\n\n\n```cs\nclass DbBackup : IJob\n{\n private readonly ILogger logger;\n private readonly IEventBroadcaster eventBroadcaster;\n\n public DbBackup(ILogger logger, IEventBroadcaster eventBroadcaster)\n {\n this.logger = logger;\n this.eventBroadcaster = eventBroadcaster;\n }\n}\n\ncontainer.Register();\ncontainer.Register();\n\ncontainer.Register();\n\n// resolution using the available constructor.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public ILogger Logger { get; set; }\n public IEventBroadcaster EventBroadcaster { get; set; }\n\n public DbBackup() \n { }\n}\n\ncontainer.Register();\ncontainer.Register();\n\n// registration of service with auto member injection.\ncontainer.Register(options => \n options.WithAutoMemberInjection());\n\n// resolution will inject the properties.\nIJob job = container.Resolve();\n```\n\n \n \n
\n\n\nAttributes can give you control over how Stashbox selects dependencies for a service's resolution.\n\n**Dependency attribute**: \n- **On a constructor/method parameter**: used with the *name* property, it works as a marker for [named resolution](/docs/getting-started/glossary#named-resolution).\n\n- **On a property/field**: first, it enables *auto-injection* on the marked property/field (even if it wasn't configured at registration explicitly), and just as with the method parameter, it allows [named resolution](/docs/getting-started/glossary#named-resolution).\n\n**DependencyName attribute**: a parameter marked with this attribute will get the related service's dependency name.\n\n**InjectionMethod attribute**: marks a method to be called when the requested service is instantiated.\n\n
\n\n\n\n\n\n```cs\nclass DbBackup : IJob\n{\n private readonly ILogger logger;\n\n public DbBackup([Dependency(\"Console\")]ILogger logger)\n {\n this.logger = logger;\n }\n}\n\ncontainer.Register(\"Console\");\ncontainer.Register(\"File\");\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n [Dependency(\"Console\")]\n public ILogger Logger { get; set; }\n\n public DbBackup() \n { }\n}\n\ncontainer.Register(\"Console\");\ncontainer.Register(\"File\");\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public string Name { get; set; }\n\n public DbBackup([DependencyName] string name) \n { }\n}\n\ncontainer.Register(\"Backup\");\n\n\nIJob job = container.Resolve();\n// name is \"Backup\".\nvar name = job.Name;\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n [InjectionMethod]\n public void Initialize([Dependency(\"Console\")]ILogger logger)\n {\n this.logger.Log(\"Initializing.\");\n }\n}\n\ncontainer.Register(\"Console\");\ncontainer.Register(\"File\");\n\ncontainer.Register();\n\n// the container will call DbBackup's Initialize method.\nIJob job = container.Resolve();\n```\n\n \n \n
\n\nThere's an option to extend the container's dependency finding mechanism with your own attributes.\n\n- **Additional Dependency attributes**: you can use the [`.WithAdditionalDependencyAttribute()`](/docs/configuration/container-configuration#withadditionaldependencyattribute) container configuration option to let the container know that it should watch for additional attributes besides the built-in [`Dependency`](/docs/guides/service-resolution#attributes) attribute upon building up the [resolution tree](/docs/getting-started/glossary#resolution-tree).\n\n- **Additional DependencyName attributes**: you can use the [`.WithAdditionalDependencyNameAttribute()`](/docs/configuration/container-configuration#withadditionaldependencynameattribute) container configuration option to use additional dependency name indicator attributes besides the built-in [`DependencyName`](/docs/guides/service-resolution#attributes) attribute.\n\n
\n\n\n\n\n\n```cs\nclass DbBackup : IJob\n{\n [CustomDependency(\"Console\")]\n public ILogger Logger { get; set; }\n\n public DbBackup() \n { }\n}\n\nvar container = new StashboxContainer(options => options\n .WithAdditionalDependencyAttribute());\n\ncontainer.Register(\"Console\");\ncontainer.Register(\"File\");\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public string Name { get; set; }\n\n public DbBackup([CustomName] string name) \n { }\n}\n\nvar container = new StashboxContainer(options => options\n .WithAdditionalDependencyNameAttribute());\n\ncontainer.Register(\"Backup\");\n\nIJob job = container.Resolve();\n// name is \"Backup\".\nvar name = job.Name;\n```\n\n \n \n\n
\n\n\nThe same dependency configuration functionality as attributes, but without attributes.\n\n- **Binding to a parameter**: the same functionality as the [`Dependency`](/docs/guides/service-resolution#attributes) attribute on a constructor or method parameter, enabling [named resolution](/docs/getting-started/glossary#named-resolution).\n\n- **Binding to a property/field**: the same functionality as the [`Dependency`](/docs/guides/service-resolution#attributes) attribute, enabling the injection of the given property/field.\n\n:::info\nThere are further dependency binding options [available](/docs/configuration/registration-configuration#dependency-configuration) on the registration configuration API.\n:::\n\n
\n\n\n\n\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup(ILogger logger)\n { }\n}\n\ncontainer.Register(\"Console\");\ncontainer.Register(\"File\");\n\n// registration of service with the dependency binding.\ncontainer.Register(options => options\n .WithDependencyBinding(\"logger\", \"Console\"));\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public ILogger Logger { get; set; }\n}\n\ncontainer.Register(\"Console\");\ncontainer.Register(\"File\");\n\n// registration of service with the member injection.\ncontainer.Register(options => options\n .WithDependencyBinding(\"Logger\", \"Console\"));\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n \n
\n\n\nWhen you enable conventional resolution, the container treats member and method parameter names as their dependency identifier. \n\nIt's like an implicit dependency binding on every class member.\n\nFirst, you have to enable conventional resolution through the configuration of the container: \n```cs\nnew StashboxContainer(options => options\n .TreatParameterAndMemberNameAsDependencyName());\n```\n\n:::note\nThe container will attempt a [named resolution](/docs/getting-started/glossary#named-resolution) on each dependency based on their parameter or property/field name.\n:::\n\n
\n\n\n\n\n\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup(\n // the parameter name identifies the dependency.\n ILogger consoleLogger)\n { }\n}\n\ncontainer.Register(\"consoleLogger\");\ncontainer.Register(\"fileLogger\");\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n // the property name identifies the dependency.\n public ILogger ConsoleLogger { get; set; }\n}\n\ncontainer.Register(\"ConsoleLogger\");\ncontainer.Register(\"FileLogger\");\n\n// registration of service with auto member injection.\ncontainer.Register(options => options\n .WithAutoMemberInjection());\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n \n
\n\n\nStashbox can resolve a particular dependency based on its context. This context is typically the reflected type of dependency, its usage, and the type it gets injected into.\n\n- **Attribute**: you can filter on constructor, method, property, or field attributes to select the desired dependency for your service. In contrast to the `Dependency` attribute, this configuration doesn't tie your application to Stashbox because you use your own attributes.\n\n- **Parent type**: you can filter on what type the given service is injected into.\n\n- **Resolution path**: similar to the parent type and attribute condition but extended with inheritance. You can set that the given service is only usable in a type's resolution path. This means that each direct and sub-dependency of the selected type must use the provided service as a dependency.\n\n- **Custom**: with this, you can build your own selection logic based on the given contextual type information.\n\n
\n\n\n\n\n\n```cs\nclass ConsoleAttribute : Attribute { }\n\nclass DbBackup : IJob\n{\n public DbBackup([Console]ILogger logger)\n { }\n}\n\ncontainer.Register(options => options\n // resolve only when the injected parameter, \n // property or field has the 'Console' attribute\n .WhenHas());\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup(ILogger logger)\n { }\n}\n\ncontainer.Register(options => options\n // inject only when we are \n // currently resolving DbBackup OR StorageCleanup.\n .WhenDependantIs()\n .WhenDependantIs());\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup(IStorage storage)\n { }\n}\n\nclass FileStorage : IStorage\n{\n public FileStorage(ILogger logger) \n { }\n}\n\ncontainer.Register(options => options\n // inject only when we are in the\n // resolution path of DbBackup\n .WhenInResolutionPathOf());\n\ncontainer.Register();\ncontainer.Register();\n\n// the container will select ConsoleLogger for FileStorage\n// because they are injected into DbBackup.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup(ILogger logger)\n { }\n}\n\ncontainer.Register(options => options\n // inject only when we are \n // currently resolving DbBackup.\n .When(typeInfo => typeInfo.ParentType.Equals(typeof(DbBackup))));\n\ncontainer.Register();\n\n// the container will resolve DbBackup with ConsoleLogger.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\nclass DbJobsExecutor : IJobsExecutor\n{\n public DbBackup(IEnumerable jobs)\n { }\n}\n\ncontainer.Register(options => options\n .WhenDependantIs());\ncontainer.Register(options => options\n .WhenDependantIs());\nontainer.Register();\n\ncontainer.Register();\n\n// jobsExecutor will get DbBackup and DbCleanup within a collection.\nIJobsExecutor jobsExecutor = container.Resolve();\n```\n\n \n \n
\n\n\nIn cases where it's not guaranteed that a service is resolvable, either because it's not registered or any of its dependencies are missing, you can attempt an optional resolution using the `ResolveOrDefault()` method. \n\nWhen the resolution attempt fails, it will return `null` (or `default` in case of value types).\n
\n\n\n\n\n\n```cs\n// returns null when the resolution fails.\nIJob job = container.ResolveOrDefault();\n\n// throws ResolutionFailedException when the resolution fails.\nIJob job = container.Resolve();\n```\n\n \n\n\n```cs\n// returns null when the resolution fails.\nobject job = container.ResolveOrDefault(typeof(IJob));\n\n// throws ResolutionFailedException when the resolution fails.\nobject job = container.Resolve(typeof(IJob));\n```\n\n \n \n
\n\n\nAt resolution time, you can override a service's dependencies by passing an `object[]` to the `Resolve()` method.\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup(ILogger logger)\n { }\n}\n```\n\n
\n\n\n\n\n\n```cs\nDbBackup backup = container.Resolve( \n dependencyOverrides: new object[] \n { \n new ConsoleLogger() \n });\n```\n\n \n\n\n```cs\nobject backup = container.Resolve(typeof(DbBackup),\n dependencyOverrides: new object[] \n { \n new ConsoleLogger() \n });\n```\n\n \n \n
\n\n\nTo get more control over your overrides (like giving them name to allow [named resolution](/docs/getting-started/glossary#named-resolution)), you can use the `Override` built-in wrapper.\n\n```cs\nclass DbBackup : IJob\n{\n public DbBackup([Dependency(\"console\")]ILogger logger)\n { }\n}\n```\n\n
\n\n\n\n\n\n```cs\nDbBackup backup = container.Resolve( \n dependencyOverrides: new object[] \n { \n Override.Of(new ConsoleLogger(), \"console\"), \n });\n```\n\n \n\n\n```cs\nobject backup = container.Resolve(typeof(DbBackup),\n dependencyOverrides: new object[] \n { \n Override.Of(typeof(ILogger), new ConsoleLogger(), \"console\"), \n });\n```\n\n \n \n
\n\n\nYou can use the container's `.Activate()` method when you only want to build up an instance from a type on the fly without registration.\n\nIt allows dependency overriding with `object` arguments and performs property/field/method injection (when configured).\n\nIt works like `Activator.CreateInstance()` except that Stashbox supplies the dependencies.\n\n
\n\n\n\n\n\n```cs\n// use dependency injected by container.\nDbBackup backup = container.Activate();\n\n// override the injected dependency.\nDbBackup backup = container.Activate(new ConsoleLogger());\n```\n\n \n\n\n```cs\n// use dependency injected by container.\nobject backup = container.Activate(typeof(DbBackup));\n\n// override the injected dependency.\nobject backup = container.Activate(typeof(DbBackup), new ConsoleLogger());\n```\n\n \n \n
\n\n\n### Build-up\n\nWith the `.BuildUp()` method, you can do the same *on the fly* post-processing (property/field/method injection) on already constructed instances. \n\n:::caution\n`.BuildUp()` won't register the given instance into the container.\n:::\n
\n\n\n```cs\nclass DbBackup : IJob\n{\n public ILogger Logger { get; set; }\n}\n\nDbBackup backup = new DbBackup();\n// the container fills the Logger property.\ncontainer.BuildUp(backup); \n```\n\n
\n',\n },\n {\n type: 'html',\n className: 'navbar-title',\n value: 'ASP.NET',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-web-webapi',\n label: 'Web API',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-web-mvc',\n label: 'MVC',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-signalr',\n label: 'SignalR',\n },\n {\n type: 'html',\n value: '
',\n },\n {\n type: 'html',\n className: 'navbar-title',\n value: 'OWIN',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-owin',\n label: 'OWIN',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-webapi-owin',\n label: 'Web API',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-signalr-owin',\n label: 'SignalR',\n },\n {\n type: 'html',\n value: '
',\n },\n {\n type: 'html',\n className: 'navbar-title',\n value: 'Other',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-extensions/tree/main/src/stashbox-hangfire',\n label: 'Hangfire',\n },\n {\n href: 'https://github.com/z4kn4fein/stashbox-mocking',\n label: 'Mocking',\n },\n ]\n },\n {\n type: 'dropdown',\n position: 'left',\n label: 'Benchmarks',\n items: [\n {\n href: 'https://danielpalme.github.io/IocPerformance',\n label: 'Performance',\n },\n ]\n },\n {\n position: 'left',\n label: 'Changelog',\n href: 'https://github.com/z4kn4fein/stashbox/releases'\n },\n {\n type: 'custom-icon',\n icon: 'nuget',\n position: 'right',\n className: 'nav-icon',\n href: 'https://www.nuget.org/packages/Stashbox'\n },\n {\n type: 'custom-icon',\n icon: 'github',\n position: 'right',\n className: 'nav-icon',\n href: 'https://github.com/z4kn4fein/stashbox'\n },\n {\n type: 'custom-separator',\n position: 'right',\n },\n ],\n },\n footer: {\n style: 'dark',\n links: [\n {\n title: 'GUIDES',\n items: [\n { label: 'Basic usage', to: 'docs/guides/basics' },\n { label: 'Advanced registration', to: 'docs/guides/advanced-registration' },\n { label: 'Service resolution', to: 'docs/guides/service-resolution' },\n { label: 'Lifetimes', to: 'docs/guides/lifetimes' },\n { label: 'Scopes', to: 'docs/guides/scopes' },\n ],\n },\n {\n title: 'ADVANCED',\n items: [\n { label: 'Generics', to: 'docs/advanced/generics' },\n { label: 'Decorators', to: 'docs/advanced/decorators' },\n { label: 'Wrappers & resolvers', to: 'docs/advanced/wrappers-resolvers' },\n { label: 'Child containers', to: 'docs/advanced/child-containers' },\n { label: 'Special resolution cases', to: 'docs/advanced/special-resolution-cases' },\n ],\n }\n ],\n copyright: `Copyright © ${new Date().getFullYear()} Peter Csajtai. Built with Docusaurus.`,\n },\n docs: {\n sidebar: {\n hideable: true,\n },\n },\n prism: {\n theme: prismLightTheme,\n additionalLanguages: [\n 'csharp',\n 'powershell',\n 'bash',\n ],\n },\n colorMode: {\n defaultMode: 'light',\n disableSwitch: false,\n respectPrefersColorScheme: true,\n },\n algolia: {\n appId: 'CYYLE77D6F',\n apiKey: '70fdb3ec7ec00e65922f35e5a5e35562',\n indexName: 'stashbox'\n },\n }),\n};\n\nasync function createConfig() {\n const darkTheme = (await import('./src/utils/prismDark.mjs')).default;\n // @ts-expect-error: it exists\n config.themeConfig.prism.darkTheme = darkTheme;\n return config;\n}\n\nmodule.exports = createConfig;\n" }, { "path": "docs/package.json", "content": "{\n \"name\": \"website\",\n \"version\": \"0.0.0\",\n \"private\": true,\n \"scripts\": {\n \"docusaurus\": \"docusaurus\",\n \"start\": \"docusaurus start\",\n \"build\": \"docusaurus build\",\n \"swizzle\": \"docusaurus swizzle\",\n \"deploy\": \"docusaurus deploy\",\n \"clear\": \"docusaurus clear\",\n \"serve\": \"docusaurus serve\",\n \"write-translations\": \"docusaurus write-translations\",\n \"write-heading-ids\": \"docusaurus write-heading-ids\"\n },\n \"dependencies\": {\n \"@docusaurus/core\": \"3.9.2\",\n \"@docusaurus/preset-classic\": \"3.9.2\",\n \"@mdx-js/react\": \"^3.0.0\",\n \"clsx\": \"^2.0.0\",\n \"docusaurus-plugin-sass\": \"^0.2.6\",\n \"prism-react-renderer\": \"^2.1.0\",\n \"react\": \"^18.2.0\",\n \"react-dom\": \"^18.2.0\",\n \"sass\": \"^1.69.5\"\n },\n \"devDependencies\": {\n \"@docusaurus/module-type-aliases\": \"3.0.0\"\n },\n \"browserslist\": {\n \"production\": [\n \">0.5%\",\n \"not dead\",\n \"not op_mini all\"\n ],\n \"development\": [\n \"last 1 chrome version\",\n \"last 1 firefox version\",\n \"last 1 safari version\"\n ]\n },\n \"engines\": {\n \"node\": \">=20.0\"\n }\n}\n" }, { "path": "docs/sidebars.js", "content": "/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */\nconst sidebars = {\n docs: [\n {\n type: 'category',\n label: 'Get started',\n collapsed: false,\n items: [\n 'getting-started/overview',\n 'getting-started/introduction',\n 'getting-started/glossary',\n ],\n },\n {\n type: 'category',\n label: 'Guides',\n collapsed: false,\n items: [\n 'guides/basics',\n 'guides/advanced-registration',\n 'guides/service-resolution',\n 'guides/lifetimes',\n 'guides/scopes',\n ],\n },\n {\n type: 'category',\n label: 'Configuration',\n collapsed: false,\n items: [\n 'configuration/registration-configuration',\n 'configuration/container-configuration',\n ],\n },\n {\n type: 'category',\n label: 'Advanced',\n collapsed: false,\n items: [\n 'advanced/generics',\n 'advanced/decorators',\n 'advanced/wrappers-resolvers',\n 'advanced/child-containers',\n 'advanced/special-resolution-cases',\n ],\n },\n {\n type: 'category',\n label: 'Diagnostics',\n collapsed: false,\n items: [\n 'diagnostics/validation',\n 'diagnostics/utilities',\n ],\n },\n ]\n};\n\nmodule.exports = sidebars;\n" }, { "path": "docs/src/components/CodeDescPanel/index.tsx", "content": "import React from 'react';\nimport styles from './styles.module.scss';\n\nexport default function CodeDescPanel({children}) {\n let notNullChildren = React.Children.toArray(children).filter(c => c);\n return (\n
\n
\n );\n}"
},
{
"path": "docs/src/components/CodeDescPanel/styles.module.scss",
"content": ".codeDescContainer {\n width: 100%;\n display: inline-block;\n}\n\n.desc {\n float: left;\n max-width: 45%;\n width: 45%;\n padding-right: 10px;\n}\n\n.example {\n width: 55%;\n max-width: 55%;\n padding-left: 10px;\n display: inline-block;\n}\n\n@media screen and (max-width: 996px) {\n .desc {\n float: none;\n max-width: 100%;\n width: 100%;\n padding-right: 0px;\n }\n \n .example {\n width: 100%;\n max-width: 100%;\n padding-left: 0px;\n display: block;\n }\n}"
},
{
"path": "docs/src/components/NavbarItems/SeparatorNavbarItem/index.tsx",
"content": "import React from 'react';\nimport clsx from 'clsx';\nimport styles from './styles.module.scss';\n\nexport default function SeparatorNavbarItem({mobile, ...props}): JSX.Element {\n return ;\n}"
},
{
"path": "docs/src/components/NavbarItems/SeparatorNavbarItem/styles.module.scss",
"content": ".separator {\n height: 1.7rem;\n width: 1px;\n background-color: var(--ifm-navbar-link-color);\n opacity: .2;\n margin: 0 12px 0 8px;\n}\n\n@media screen and (max-width: 996px) {\n .separator {\n display: none;\n }\n}"
},
{
"path": "docs/src/components/NavbarItems/SvgNavbarItem/index.tsx",
"content": "import useBaseUrl from '@docusaurus/useBaseUrl';\nimport clsx from 'clsx';\nimport React from 'react';\nimport SvgIcon from '../../SvgIcon';\nimport styles from './styles.module.scss';\n\nexport default function SvgNavbarItem({icon, href, mobile, ...props}): JSX.Element {\n return (\n \n {notNullChildren[0]}\n
\n \n {notNullChildren[1]}\n
\n \n \n
\n );\n}"
},
{
"path": "docs/src/components/NavbarItems/SvgNavbarItem/styles.module.scss",
"content": ".icon_container {\n display: flex;\n align-items: center;\n}\n\n.icon {\n color: var(--ifm-navbar-link-color);\n width: 24px;\n height: 24px;\n transition: opacity .2s;\n display: flex;\n align-items: center;\n}\n\n.icon:hover {\n opacity: .7;\n}\n\n.link {\n padding: 0 10px;\n}"
},
{
"path": "docs/src/components/SvgIcon/index.tsx",
"content": "import React from 'react';\nimport GitHubSvg from '@site/static/img/github.svg';\nimport ApiSvg from '@site/static/img/api.svg';\nimport GitterSvg from '@site/static/img/gitter.svg';\nimport SlackSvg from '@site/static/img/slack.svg';\nimport NuGetSvg from '@site/static/img/nuget.svg';\n\nexport default function SvgIcon({icon, ...props}): JSX.Element {\n return (\n {\n 'github': \n })
\n\n
\n \n\n {siteConfig.title}
\n{siteConfig.tagline}
\n\n\n 🚀 Thread-safe and lock-free.
\n ⚡️️ Easy-to-use Fluent API.
\n ♻️ Small memory footprint.
\n
\n\n \n ⚡️️ Easy-to-use Fluent API.
\n ♻️ Small memory footprint.
\n
\n
\n \n \n
\n {'$'} dotnet add package Stashbox --version 5.20.0\n
\n \n Get Started\n \n \n GitHub\n \n \n NuGet\n \n
\n \n
\n \n
\n \n \n ![](\"https://github-readme-stats-pcsajtai.vercel.app/api/pin/?username=z4kn4fein&repo=stashbox&show_owner=true&title_color=43c8ff&text_color=e3e3e3&bg_color=2a313c&icon_color=f9f9f9\")
\n \n
\n\n {links.map((link, i) => (\n REPOSITORY
\n \n
\n ))}\n {link.title}
\n - \n {link.items.map((item, k) => (\n item.html ? (\n
- \n
\n \n )\n ))}\n
\n
\n LINKS
\n - \n {footerLinks.map((link, i) => (\n
- \n \n\n
\n \n {link.text} \n \n \n ))}\n
\n
\n {(copyright) && (\n
\n \n );\n}\nexport default React.memo(Footer);\n"
},
{
"path": "docs/src/theme/Footer/styles.module.scss",
"content": ".footer {\n background-color: var(--ifm-footer-background-color);\n padding: var(--ifm-footer-padding-vertical) 0;\n font-size: 14px;\n}\n\n.footer_title {\n color: #858a96;\n font-weight: 500;\n font-size: 14px;\n}\n\n.footer_icon {\n margin-right: 7px;\n width: 14px;\n height: 14px;\n color: var(--ifm-footer-color);\n}\n\n.footer_copyright {\n font-size: 13px;\n color: var(--ifm-color-gray-600);\n}\n\n.footer_link {\n display: flex;\n flex-direction: row;\n flex-wrap: nowrap;\n align-items: center;\n}\n\n.separator {\n opacity: .2;\n}\n\n.repo {\n min-width: 500px;\n}\n\n.remote_link_icon {\n opacity: .5;\n width: 10;\n height: 10px;\n}\n\n@media screen and (max-width: 996px) {\n .repo {\n min-width: 300px;\n }\n}"
},
{
"path": "docs/src/theme/NavbarItem/ComponentTypes.js",
"content": "import ComponentTypes from '@theme-original/NavbarItem/ComponentTypes';\nimport SvgNavbarItem from '@site/src/components/NavbarItems/SvgNavbarItem';\nimport SeparatorNavbarItem from '@site/src/components/NavbarItems/SeparatorNavbarItem';\n\nexport default {\n ...ComponentTypes,\n 'custom-icon': SvgNavbarItem,\n 'custom-separator': SeparatorNavbarItem,\n};"
},
{
"path": "docs/src/utils/prismDark.mjs",
"content": "/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\nimport {themes} from 'prism-react-renderer';\nconst darkTheme = themes.vsDark;\n\nexport default {\n plain: {\n color: '#D4D4D4',\n backgroundColor: '#272727',\n },\n styles: [\n ...darkTheme.styles,\n ],\n};"
},
{
"path": "docs/static/.nojekyll",
"content": ""
},
{
"path": "sandbox/stashbox.assemblyload/Program.cs",
"content": "using Stashbox;\nusing System.Reflection;\nusing System.Runtime.CompilerServices;\nusing System.Runtime.Loader;\n\nIStashboxContainer container = new StashboxContainer();\n\nLoadAndUnload(container, out var weakContext);\n\nfor (var i = 0; weakContext.TryGetTarget(out _) && i < 10; i++)\n{\n GC.Collect();\n GC.WaitForPendingFinalizers();\n}\n\nConsole.WriteLine(weakContext.TryGetTarget(out _));\n\n[MethodImpl(MethodImplOptions.NoInlining)]\nstatic void LoadAndUnload(IStashboxContainer container, out WeakReference\n
\n )}\n