-
Notifications
You must be signed in to change notification settings - Fork 10
Home
Peter Csajtai edited this page Sep 25, 2018
·
33 revisions
Stashbox is a lightweight, portable dependency injection framework for .NET based solutions.
- Fluent interface - for faster and easier configuration, attribute based configuration is supported also.
- Interface/type mapping - single service, instance registration, remapping of existing registrations.
- Resolution via delegates - dynamic dependency overrides with delegate parameters.
- Keyed registrations - multiple implementations identified with a key for the same service type.
- Assembly registration - service lookup in assemblies with auto determined service types.
- Factory registration - factory delegates with several parameters can be registered.
- Initializer / finalizer - custom initializer and finalizer actions can be set.
- Multiple service resolution - all implementation registered for an interface can be obtained.
- Unknown type resolution - unregistered services can be resolved or injected.
- Default and optional value injection - primitive types or dependencies with default or optional value can be resolved.
- Open generic type resolution - concrete generic types can be resolved from open generic definitions with constraint and nested generic definition checking.
- Constructor, property and field injection - attribute driven resolution or automatic injection, when there is no chance to decorate members with attributes.
-
Injection method - methods decorated with
InjectionMethod
attribute are called at resolution time. - Wiring into container - member injection can be executed on existing instances.
- Building up existing instance - member injection can be executed on existing instances without wiring them into the container.
- Child container - parent/child container support.
- Lifetime scopes - hierarchical/named scoping support.
-
Lifetime management - including
Singleton
,Transient
,Scoped
,NamedScope
andPerResolutionRequest
lifetime, custom user-defined lifetimes also can be used. - Conditional resolution - attribute, parent-type and custom user defined conditions can be specified.
-
IDisposable object tracking -
IDisposable
objects are being disposed by the container. - Cleanup delegates - custom finalizer delegate can be configured to be called when the container or scope which created the service is being disposed.
- Circular dependency tracking - the container checks the resolution graph for circular dependencies, it throws a specific excpetion if it finds any.
-
Special types - generic wrappers:
- Collections: everything assignable to
IEnumerable<T>
e.g.T[]
,ICollection<T>
,IReadOnlyCollection<T>
,IList<T>
etc. -
Lazy<>
,Func<>
,Tuple<>
- Parameter injection over delegate arguments e.g.
Func<TParam, TService>
,Func<TParam1, TParam2, TService>
, etc. applied to subdependencies as well. - Nested wrappers e.g.
Tuple<TService, IEnumerable<Func<TParam, Lazy<TService1>>>>
.
- Collections: everything assignable to
- Custom resolvers - the existing activation rutines can be extended with custom resolvers.
- Container extensions - the containers functionality can be extended with custom extensions, e.g. Auto configuration parser extension
- Custom configuration - the behavior of the container can be controlled with custom configurations.
-
Container validation - the resolution graph can be validated by calling the
Validate()
function. - Decorator support / Interception - decorator services can be registered and used for interception with Castle DynamicProxy
- Service registration
- Factory registration
- Assembly registration
- Composition
- Fluent registration api
- Service resolution
- Resolution by attributes
- Conventional resolution
- Delegate resolution
- Conditional resolution
- Multi resolution
- Lifetimes
- Generics
- Generic wrappers
- Decorators
- Resolvers
- Scopes
- Container configuration
- Container diagnostics
- Exceptions