UnityContainer.Extensions.Owned 1.1.0

UnityContainer.Extensions.Owned

Autofac-style Owned<T> for Unity Container (v5.11.x).

Owned<T> gives you deterministic disposal of resolved services and their entire dependency graph. Each Owned<T> creates an isolated scope — when you dispose it, all transient and hierarchical dependencies created within that scope are disposed with it.

Install

dotnet add package UnityContainer.Extensions.Owned

Usage

Register the extension

using Unity;
using UnityContainer.Extensions.Owned;

var container = new UnityContainer();
container.AddExtension(new OwnedExtension());

Resolve Owned<T>

container.RegisterType<IRepository, Repository>();

// Each resolve creates an isolated scope
var owned = container.Resolve<Owned<IRepository>>();
IRepository repo = owned.Value;

// Use the service...
repo.Save("some data");

// Dispose the owned scope — disposes repo and all its transient dependencies
owned.Dispose();

Inject Owned<T> as a dependency

public class MyService : IDisposable
{
    private readonly Owned<IRepository> ownedRepo;

    public MyService(Owned<IRepository> ownedRepo)
    {
        this.ownedRepo = ownedRepo;
    }

    public void DoWork()
    {
        ownedRepo.Value.Save("data");
    }

    public void Dispose()
    {
        ownedRepo.Dispose(); // Disposes the repository and its scope
    }
}

Behavior

Lifetime handling

Scope isolation

• Each Owned<T> gets its own child container as its scope
• Disposing Owned<T> disposes all transient/hierarchical services resolved within that scope
• Singletons are resolved from the parent and are never disposed by Owned<T>
• Nested Owned<Owned<T>> scopes are independent — disposing outer does not cascade to inner
• If resolution fails, the child container is disposed immediately (no leak)

Child container support

Owned<T> works correctly when resolved from child containers. It preserves the registration hierarchy — services registered on child containers are visible to the owned scope.

How it works

The extension registers two BuilderStrategy implementations into Unity's build pipeline:

1. OwnedBuildStrategy (PreCreation stage) — intercepts resolution of Owned<T>, creates a child container, resolves T from it, and wraps both in Owned<T>
2. DisposalTrackingStrategy (PostInitialization stage) — tracks IDisposable instances created within an owned scope so they are disposed when the scope is disposed

An OwnedScopeMarker registered on the child container is used to detect whether the current resolution is happening inside an owned scope, using Unity's BuilderContext policy lookup.

Tests

The test suite validates behavior against Autofac's Owned<T> side-by-side to ensure identical semantics. Run with:

dotnet test

License

MIT