Class FactoryLifetime

Namespace

Unity

Assembly

Unity.Abstractions.dll

public static class FactoryLifetime

Inheritance

object

FactoryLifetime

Inherited Members

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Properties

External

This lifetime keeps a weak reference to object it holds.

public static IFactoryLifetimeManager External { get; }

Property Value

IFactoryLifetimeManager

A new instance of a ExternallyControlledLifetimeManager lifetime manager.

Remarks

When no object is associated with the manager container creates and returns a new object. It gets and holds a weak reference to the created object. As long as the object still exists and has not been garbage collected the container will return the object when requested.

If the object went out of scope and has been garbage collected the container will create and return a new instance.

This lifetime manager does not dispose an object when container is disposed

Hierarchical

Unity returns a unique value for each child container.

public static IFactoryLifetimeManager Hierarchical { get; }

Property Value

IFactoryLifetimeManager

A new instance of a HierarchicalLifetimeManager lifetime manager.

Remarks

The Unity container allows creating hierarchies of child containers. This lifetime creates local singleton for each level of the hierarchy. So, when you resolve a type and this container does not have an instance of that type, the container will create new instance. Next type the type is resolved the same instance will be returned.

If a child container is created and requested to resolve the type, the child container will create a new instance and store it for subsequent resolutions. Next time the child container requested to resolve the type, it will return stored instance.

If you have multiple children, each will resolve its own instance.

PerContainer

Unity returns the same instance each time the Resolve(...) method is called or when the dependency mechanism injects the instance into other classes.

public static IFactoryLifetimeManager PerContainer { get; }

Property Value

IFactoryLifetimeManager

A new instance of a ContainerControlledLifetimeManager lifetime manager.

Remarks

Per Container lifetime allows a registration of an existing or resolved object as a scoped singleton in the container it was created or registered. In other words this instance is unique within the container it war registered with. Child or parent containers could have their own instances registered for the same contract.

PerContainerTransient

This lifetime is similar to TransientLifetimeManager with exception how the container holds references to created objects.

public static IFactoryLifetimeManager PerContainerTransient { get; }

Property Value

IFactoryLifetimeManager

A new instance of a ContainerControlledTransientManager lifetime manager.

Remarks

On each call to the Resolve{T}() method a container will create a new objects. If the objects implements IDisposable, the container will hold a reference to the interface and will dispose the object when the container goes out of scope.

This lifetime is particularly useful in session based designs with child containers associated with the session

PerResolve

This lifetime keeps a reference to an instance only for the duration of one resolution call

public static IFactoryLifetimeManager PerResolve { get; }

Property Value

IFactoryLifetimeManager

A new instance of a PerResolveLifetimeManager lifetime manager.

Examples

Consider this scenario:

class a {}

class b 
{
    b(a arg1)
    {...}
}

class c
{
    c(a arg1, b arg2)
    {...}
}

When you resolve type c, it depends on type b and type a. Type b, in turn, also depends on type a, and both types, c and b, require a to be the same instance.

If type `a` is a singleton, the logic is easy. But if you require each instance of `c` to have a unique `a`, you could use per resolve lifetime. The instance of `a` will act as a singleton only during that one resolution. Next call to resolve the dependent type will create a new object.

In the case of recursion, the singleton behavior is still applies and prevents circular dependency

Remarks

This type of lifetime is useful when you need to pass the same instance of the dependency to a different nodes of the resolution graph.

PerThread

Per thread lifetime means a new instance of the registered Type will be created once per each thread. In other words, if a Resolve{T}() method is called on a thread the first time, it will return a new object. Each subsequent call to Resolve{T}(), or when the dependency mechanism injects instances of the type into other classes on the same thread, the container will return the same object.

public static IFactoryLifetimeManager PerThread { get; }

Property Value

IFactoryLifetimeManager

A new instance of a PerThreadLifetimeManager lifetime manager.

Scoped

Unity returns a unique value for each scope.

public static IFactoryLifetimeManager Scoped { get; }

Property Value

IFactoryLifetimeManager

A new instance of a HierarchicalLifetimeManager lifetime manager.

Remarks

The Unity container allows creating hierarchies of child containers. This lifetime creates local singleton for each level of the hierarchy. So, when you resolve a type and this container does not have an instance of that type, the container will create new instance. Next type the type is resolved the same instance will be returned.

If a child container is created and requested to resolve the type, the child container will create a new instance and store it for subsequent resolutions. Next time the child container requested to resolve the type, it will return stored instance.

If you have multiple children, each will resolve its own instance.

Singleton

Singleton lifetime creates globally unique singleton. Any Unity container tree (parent and all the children) is guaranteed to have only one global singleton for the registered type.

public static IFactoryLifetimeManager Singleton { get; }

Property Value

IFactoryLifetimeManager

A new instance of a SingletonLifetimeManager lifetime manager.

Remarks

Registering a type with singleton lifetime always places the registration at the root of the container tree and makes it globally available for all the children of that container. It does not matter if registration takes places at the root of child container the destination is always the root node.

Repeating the registration on any of the child nodes with singleton lifetime will always override the root registration.

Transient

This lifetime creates and returns a new instance of the requested type for each call to the Resolve(...) method.

public static IFactoryLifetimeManager Transient { get; }

Property Value

IFactoryLifetimeManager

An instance of a TransientLifetimeManager lifetime manager.

Remarks

Transient lifetime is a default lifetime of the Unity container. As the name implies it lasts very short period of time, actually, no time at all. In the Unity container terms, having transient lifetime is the same as having no lifetime manager at all.