Specifying T[] as the injection type allows instances from all bindings that implement the T type to be injected.
interface IDependency;
class AbcDependency : IDependency;
class XyzDependency : IDependency;
interface IService
{
IDependency[] Dependencies { get; }
}
class Service(IDependency[] dependencies) : IService
{
public IDependency[] Dependencies { get; } = dependencies;
}
DI.Setup(nameof(Composition))
.Bind<IDependency>().To<AbcDependency>()
.Bind<IDependency>(2).To<XyzDependency>()
.Bind<IService>().To<Service>()
// Composition root
.Root<IService>("Root");
var composition = new Composition();
var service = composition.Root;
service.Dependencies.Length.ShouldBe(2);
service.Dependencies[0].ShouldBeOfType<AbcDependency>();
service.Dependencies[1].ShouldBeOfType<XyzDependency>();In addition to arrays, other collection types are also supported, such as:
- System.Memory
- System.ReadOnlyMemory
- System.Span
- System.ReadOnlySpan
- System.Collections.Generic.ICollection
- System.Collections.Generic.IList
- System.Collections.Generic.List
- System.Collections.Generic.IReadOnlyCollection
- System.Collections.Generic.IReadOnlyList
- System.Collections.Generic.ISet
- System.Collections.Generic.HashSet
- System.Collections.Generic.SortedSet
- System.Collections.Generic.Queue
- System.Collections.Generic.Stack
- System.Collections.Immutable.ImmutableArray
- System.Collections.Immutable.IImmutableList
- System.Collections.Immutable.ImmutableList
- System.Collections.Immutable.IImmutableSet
- System.Collections.Immutable.ImmutableHashSet
- System.Collections.Immutable.ImmutableSortedSet
- System.Collections.Immutable.IImmutableQueue
- System.Collections.Immutable.ImmutableQueue
- System.Collections.Immutable.IImmutableStack And of course this list can easily be supplemented on its own.
The following partial class will be generated:
partial class Composition
{
private readonly Composition _root;
public Composition()
{
_root = this;
}
internal Composition(Composition parentScope)
{
_root = (parentScope ?? throw new ArgumentNullException(nameof(parentScope)))._root;
}
public IService Root
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
return new Service(new IDependency[2] { new AbcDependency(), new XyzDependency() });
}
}
[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)
{
var index = (int)(_bucketSize * ((uint)RuntimeHelpers.GetHashCode(type) % 1));
ref var pair = ref _buckets[index];
return 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 (pair.Key == type)
{
return pair.Value.Resolve(this);
}
}
throw new InvalidOperationException($"{CannotResolveMessage} {OfTypeMessage} {type}.");
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public object Resolve(Type type, object? tag)
{
var index = (int)(_bucketSize * ((uint)RuntimeHelpers.GetHashCode(type) % 1));
ref var pair = ref _buckets[index];
return 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 (pair.Key == type)
{
return pair.Value.ResolveByTag(this, tag);
}
}
throw new InvalidOperationException($"{CannotResolveMessage} \"{tag}\" {OfTypeMessage} {type}.");
}
private readonly static int _bucketSize;
private readonly static Pair<Type, IResolver<Composition, object>>[] _buckets;
static Composition()
{
var valResolver_0000 = new Resolver_0000();
Resolver<IService>.Value = valResolver_0000;
_buckets = Buckets<Type, IResolver<Composition, object>>.Create(
1,
out _bucketSize,
new Pair<Type, IResolver<Composition, object>>[1]
{
new Pair<Type, IResolver<Composition, object>>(typeof(IService), valResolver_0000)
});
}
private const string CannotResolveMessage = "Cannot resolve composition root ";
private const string OfTypeMessage = "of type ";
private class Resolver<T>: IResolver<Composition, T>
{
public static IResolver<Composition, T> Value = new Resolver<T>();
public virtual T Resolve(Composition composite)
{
throw new InvalidOperationException($"{CannotResolveMessage}{OfTypeMessage}{typeof(T)}.");
}
public virtual T ResolveByTag(Composition composite, object tag)
{
throw new InvalidOperationException($"{CannotResolveMessage}\"{tag}\" {OfTypeMessage}{typeof(T)}.");
}
}
private sealed class Resolver_0000: Resolver<IService>
{
public override IService Resolve(Composition composition)
{
return composition.Root;
}
public override IService ResolveByTag(Composition composition, object tag)
{
switch (tag)
{
case null:
return composition.Root;
default:
return base.ResolveByTag(composition, tag);
}
}
}
}Class diagram:
classDiagram
class Composition {
<<partial>>
+IService Root
+ T ResolveᐸTᐳ()
+ T ResolveᐸTᐳ(object? tag)
+ object Resolve(Type type)
+ object Resolve(Type type, object? tag)
}
AbcDependency --|> IDependency
class AbcDependency {
+AbcDependency()
}
XyzDependency --|> IDependency : 2
class XyzDependency {
+XyzDependency()
}
Service --|> IService
class Service {
+Service(ArrayᐸIDependencyᐳ dependencies)
}
class ArrayᐸIDependencyᐳ
class IDependency {
<<interface>>
}
class IService {
<<interface>>
}
Composition ..> Service : IService Root
Service *-- ArrayᐸIDependencyᐳ : ArrayᐸIDependencyᐳ
ArrayᐸIDependencyᐳ *-- AbcDependency : IDependency
ArrayᐸIDependencyᐳ *-- XyzDependency : 2 IDependency