When this occurs: you need to control how far override values propagate in a factory. What it solves: keeps overrides local to a single injection level without affecting nested dependencies. How it is solved in the example: uses Let to keep overrides local and verifies the scope.
using Shouldly;
using Pure.DI;
DI.Setup(nameof(DeepComposition))
.Bind().To(_ => 7)
.Bind().To<Dependency>()
.Bind().To<Service>(ctx =>
{
ctx.Override(42);
ctx.Inject(out Service service);
return service;
})
.Root<Service>("Service");
DI.Setup(nameof(ShallowComposition))
.Bind().To(_ => 7)
.Bind().To<Dependency>()
.Bind().To<Service>(ctx =>
{
ctx.Let(42);
ctx.Inject(out Service service);
return service;
})
.Root<Service>("Service");
var deep = new DeepComposition().Service;
var shallow = new ShallowComposition().Service;
deep.Id.ShouldBe(42);
deep.Dependency.Id.ShouldBe(42);
shallow.Id.ShouldBe(42);
shallow.Dependency.Id.ShouldBe(7);
class Dependency(int id)
{
public int Id { get; } = id;
}
class Service(int id, Dependency dependency)
{
public int Id { get; } = id;
public Dependency Dependency { get; } = dependency;
}Running this code sample locally
- Make sure you have the .NET SDK 10.0 or later installed
dotnet --list-sdk- Create a net10.0 (or later) console application
dotnet new console -n Sampledotnet add package Pure.DI
dotnet add package Shouldly- Copy the example code into the Program.cs file
You are ready to run the example 🚀
dotnet runWhat it shows:
- Demonstrates deep vs one-level override behavior.
Important points:
- Deep overrides propagate into nested dependency graphs.
- One-level overrides affect only the immediate injection.
Useful when:
- You want to override a constructor parameter without affecting deeper object graphs.
The following partial class will be generated
partial class DeepComposition
{
#if NET9_0_OR_GREATER
private readonly Lock _lock = new Lock();
#else
private readonly Object _lock = new Object();
#endif
public Service Service
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
Service transientService;
lock (_lock)
{
int overriddenInt32 = 42;
Service localService = new Service(overriddenInt32, new Dependency(overriddenInt32));
transientService = localService;
}
return transientService;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T Resolve<T>()
{
return Resolver<T>.Value.Resolve(this);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T Resolve<T>(object? tag)
{
return Resolver<T>.Value.ResolveByTag(this, tag);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public object Resolve(Type type)
{
#if NETCOREAPP3_0_OR_GREATER
var index = (int)(_bucketSize * (((uint)type.TypeHandle.GetHashCode()) % 1));
#else
var index = (int)(_bucketSize * (((uint)RuntimeHelpers.GetHashCode(type)) % 1));
#endif
ref var pair = ref _buckets[index];
return Object.ReferenceEquals(pair.Key, type) ? pair.Value.Resolve(this) : Resolve(type, index);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private object Resolve(Type type, int index)
{
var finish = index + _bucketSize;
while (++index < finish)
{
ref var pair = ref _buckets[index];
if (Object.ReferenceEquals(pair.Key, type))
{
return pair.Value.Resolve(this);
}
}
throw new CannotResolveException($"{CannotResolveMessage} {OfTypeMessage} {type}.", type, null);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public object Resolve(Type type, object? tag)
{
#if NETCOREAPP3_0_OR_GREATER
var index = (int)(_bucketSize * (((uint)type.TypeHandle.GetHashCode()) % 1));
#else
var index = (int)(_bucketSize * (((uint)RuntimeHelpers.GetHashCode(type)) % 1));
#endif
ref var pair = ref _buckets[index];
return Object.ReferenceEquals(pair.Key, type) ? pair.Value.ResolveByTag(this, tag) : Resolve(type, tag, index);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private object Resolve(Type type, object? tag, int index)
{
var finish = index + _bucketSize;
while (++index < finish)
{
ref var pair = ref _buckets[index];
if (Object.ReferenceEquals(pair.Key, type))
{
return pair.Value.ResolveByTag(this, tag);
}
}
throw new CannotResolveException($"{CannotResolveMessage} \"{tag}\" {OfTypeMessage} {type}.", type, tag);
}
private readonly static uint _bucketSize;
private readonly static Pair<IResolver<DeepComposition, object>>[] _buckets;
static DeepComposition()
{
var valResolver_0000 = new Resolver_0000();
Resolver<Service>.Value = valResolver_0000;
_buckets = Buckets<IResolver<DeepComposition, object>>.Create(
1,
out _bucketSize,
new Pair<IResolver<DeepComposition, object>>[1]
{
new Pair<IResolver<DeepComposition, object>>(typeof(Service), valResolver_0000)
});
}
private const string CannotResolveMessage = "Cannot resolve composition root ";
private const string OfTypeMessage = "of type ";
private class Resolver<T>: IResolver<DeepComposition, T>
{
public static IResolver<DeepComposition, T> Value = new Resolver<T>();
public virtual T Resolve(DeepComposition composite)
{
throw new CannotResolveException($"{CannotResolveMessage}{OfTypeMessage}{typeof(T)}.", typeof(T), null);
}
public virtual T ResolveByTag(DeepComposition composite, object tag)
{
throw new CannotResolveException($"{CannotResolveMessage}\"{tag}\" {OfTypeMessage}{typeof(T)}.", typeof(T), tag);
}
}
private sealed class Resolver_0000: Resolver<Service>
{
public override Service Resolve(DeepComposition composition)
{
return composition.Service;
}
public override Service ResolveByTag(DeepComposition composition, object tag)
{
switch (tag)
{
case null:
return composition.Service;
default:
return base.ResolveByTag(composition, tag);
}
}
}
}The following partial class will be generated
partial class ShallowComposition
{
#if NET9_0_OR_GREATER
private readonly Lock _lock = new Lock();
#else
private readonly Object _lock = new Object();
#endif
public Service Service
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
Service transientService;
lock (_lock)
{
int overriddenInt32 = 42;
int transientInt32 = 7;
Service localService = new Service(overriddenInt32, new Dependency(transientInt32));
transientService = localService;
}
return transientService;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T Resolve<T>()
{
return Resolver<T>.Value.Resolve(this);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T Resolve<T>(object? tag)
{
return Resolver<T>.Value.ResolveByTag(this, tag);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public object Resolve(Type type)
{
#if NETCOREAPP3_0_OR_GREATER
var index = (int)(_bucketSize * (((uint)type.TypeHandle.GetHashCode()) % 1));
#else
var index = (int)(_bucketSize * (((uint)RuntimeHelpers.GetHashCode(type)) % 1));
#endif
ref var pair = ref _buckets[index];
return Object.ReferenceEquals(pair.Key, type) ? pair.Value.Resolve(this) : Resolve(type, index);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private object Resolve(Type type, int index)
{
var finish = index + _bucketSize;
while (++index < finish)
{
ref var pair = ref _buckets[index];
if (Object.ReferenceEquals(pair.Key, type))
{
return pair.Value.Resolve(this);
}
}
throw new CannotResolveException($"{CannotResolveMessage} {OfTypeMessage} {type}.", type, null);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public object Resolve(Type type, object? tag)
{
#if NETCOREAPP3_0_OR_GREATER
var index = (int)(_bucketSize * (((uint)type.TypeHandle.GetHashCode()) % 1));
#else
var index = (int)(_bucketSize * (((uint)RuntimeHelpers.GetHashCode(type)) % 1));
#endif
ref var pair = ref _buckets[index];
return Object.ReferenceEquals(pair.Key, type) ? pair.Value.ResolveByTag(this, tag) : Resolve(type, tag, index);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private object Resolve(Type type, object? tag, int index)
{
var finish = index + _bucketSize;
while (++index < finish)
{
ref var pair = ref _buckets[index];
if (Object.ReferenceEquals(pair.Key, type))
{
return pair.Value.ResolveByTag(this, tag);
}
}
throw new CannotResolveException($"{CannotResolveMessage} \"{tag}\" {OfTypeMessage} {type}.", type, tag);
}
private readonly static uint _bucketSize;
private readonly static Pair<IResolver<ShallowComposition, object>>[] _buckets;
static ShallowComposition()
{
var valResolver_0000 = new Resolver_0000();
Resolver<Service>.Value = valResolver_0000;
_buckets = Buckets<IResolver<ShallowComposition, object>>.Create(
1,
out _bucketSize,
new Pair<IResolver<ShallowComposition, object>>[1]
{
new Pair<IResolver<ShallowComposition, object>>(typeof(Service), valResolver_0000)
});
}
private const string CannotResolveMessage = "Cannot resolve composition root ";
private const string OfTypeMessage = "of type ";
private class Resolver<T>: IResolver<ShallowComposition, T>
{
public static IResolver<ShallowComposition, T> Value = new Resolver<T>();
public virtual T Resolve(ShallowComposition composite)
{
throw new CannotResolveException($"{CannotResolveMessage}{OfTypeMessage}{typeof(T)}.", typeof(T), null);
}
public virtual T ResolveByTag(ShallowComposition composite, object tag)
{
throw new CannotResolveException($"{CannotResolveMessage}\"{tag}\" {OfTypeMessage}{typeof(T)}.", typeof(T), tag);
}
}
private sealed class Resolver_0000: Resolver<Service>
{
public override Service Resolve(ShallowComposition composition)
{
return composition.Service;
}
public override Service ResolveByTag(ShallowComposition composition, object tag)
{
switch (tag)
{
case null:
return composition.Service;
default:
return base.ResolveByTag(composition, tag);
}
}
}
}Class diagram:
---
config:
class:
hideEmptyMembersBox: true
---
classDiagram
ShallowComposition ..> Service : Service Service
Dependency *-- Int32 : Int32
Service *-- Dependency : Dependency
Service *-- Int32 : Int32
namespace Pure.DI.UsageTests.Advanced.OverrideDepthScenario {
class Dependency {
<<class>>
+Dependency(Int32 id)
}
class Service {
<<class>>
}
class ShallowComposition {
<<partial>>
+Service Service
+ T ResolveᐸTᐳ()
+ T ResolveᐸTᐳ(object? tag)
+ object Resolve(Type type)
+ object Resolve(Type type, object? tag)
}
}
namespace System {
class Int32 {
<<struct>>
}
}
See also: