using Shouldly;
using Microsoft.Extensions.DependencyInjection;
using Pure.DI;
using var composition = new Composition();
using var scope1 = composition.CreateScope();
var service1 = scope1.ServiceProvider.GetRequiredService<IService>();
var dependency1 = composition.GetRequiredService<IDependency>();
service1.Dependency.ShouldBe(dependency1);
service1.ShouldBe(scope1.ServiceProvider.GetRequiredService<IService>());
using var scope2 = composition.CreateScope();
var service2 = scope2.ServiceProvider.GetRequiredService<IService>();
var dependency2 = composition.GetRequiredService<IDependency>();
service2.Dependency.ShouldBe(dependency2);
service2.ShouldBe(scope2.ServiceProvider.GetRequiredService<IService>());
service1.ShouldNotBe(service2);
dependency1.ShouldBe(dependency2);
interface IDependency;
class Dependency : IDependency;
interface IService : IDisposable
{
IDependency Dependency { get; }
}
class Service(IDependency dependency) : IService
{
public IDependency Dependency { get; } = dependency;
public void Dispose()
{
}
}
partial class Composition
: IKeyedServiceProvider, IServiceScopeFactory, IServiceScope
{
static void Setup() =>
// The following hint overrides the name of the
// "object Resolve(Type type)" method in "GetService",
// which implements the "IServiceProvider" interface:
DI.Setup()
// The following hint overrides the name of the
// "object Resolve(Type type)" method in "GetService",
// which implements the "IServiceProvider" interface
.Hint(Hint.ObjectResolveMethodName, "GetService")
// The following hint overrides the name of the
// "object Resolve(Type type, object tag)" method in "GetRequiredKeyedService",
// which implements the "IKeyedServiceProvider" interface
.Hint(Hint.ObjectResolveByTagMethodName, "GetRequiredKeyedService")
.Bind<IDependency>().As(Lifetime.Singleton).To<Dependency>()
.Bind<IService>().As(Lifetime.Scoped).To<Service>()
// Composition roots
.Root<IDependency>()
.Root<IService>();
public IServiceProvider ServiceProvider => this;
public IServiceScope CreateScope() => new Composition(this);
public object GetKeyedService(Type serviceType, object? serviceKey) =>
GetRequiredKeyedService(serviceType, serviceKey);
}Running this code sample locally
- Make sure you have the .NET SDK 9.0 or later is installed
dotnet --list-sdk- Create a net9.0 (or later) console application
dotnet new console -n Sample- Add references to NuGet packages
dotnet add package Pure.DI
dotnet add package Shouldly
dotnet add package Microsoft.Extensions.DependencyInjection- Copy the example code into the Program.cs file
You are ready to run the example 🚀
dotnet runThe following partial class will be generated:
partial class Composition: IDisposable
{
private readonly Composition _root;
private readonly Lock _lock;
private object[] _disposables;
private int _disposeIndex;
private Service? _scopedService44;
private Dependency? _singletonDependency43;
[OrdinalAttribute(256)]
public Composition()
{
_root = this;
_lock = new Lock();
_disposables = new object[1];
}
internal Composition(Composition parentScope)
{
_root = (parentScope ?? throw new ArgumentNullException(nameof(parentScope)))._root;
_lock = _root._lock;
_disposables = new object[1];
}
private IDependency Root2
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
if (_root._singletonDependency43 is null)
{
using (_lock.EnterScope())
{
if (_root._singletonDependency43 is null)
{
_root._singletonDependency43 = new Dependency();
}
}
}
return _root._singletonDependency43;
}
}
private IService Root1
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
if (_scopedService44 is null)
{
using (_lock.EnterScope())
{
if (_scopedService44 is null)
{
if (_root._singletonDependency43 is null)
{
_root._singletonDependency43 = new Dependency();
}
_scopedService44 = new Service(_root._singletonDependency43);
_disposables[_disposeIndex++] = _scopedService44;
}
}
}
return _scopedService44;
}
}
[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 GetService(Type type)
{
var index = (int)(_bucketSize * ((uint)RuntimeHelpers.GetHashCode(type) % 4));
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 GetRequiredKeyedService(Type type, object? tag)
{
var index = (int)(_bucketSize * ((uint)RuntimeHelpers.GetHashCode(type) % 4));
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}.");
}
public void Dispose()
{
int disposeIndex;
object[] disposables;
using (_lock.EnterScope())
{
disposeIndex = _disposeIndex;
_disposeIndex = 0;
disposables = _disposables;
_disposables = new object[1];
_scopedService44 = null;
_singletonDependency43 = null;
}
while (disposeIndex-- > 0)
{
switch (disposables[disposeIndex])
{
case IDisposable disposableInstance:
try
{
disposableInstance.Dispose();
}
catch (Exception exception)
{
OnDisposeException(disposableInstance, exception);
}
break;
}
}
}
partial void OnDisposeException<T>(T disposableInstance, Exception exception) where T : IDisposable;
private readonly static int _bucketSize;
private readonly static Pair<Type, IResolver<Composition, object>>[] _buckets;
static Composition()
{
var valResolver_0000 = new Resolver_0000();
Resolver<IDependency>.Value = valResolver_0000;
var valResolver_0001 = new Resolver_0001();
Resolver<IService>.Value = valResolver_0001;
_buckets = Buckets<Type, IResolver<Composition, object>>.Create(
4,
out _bucketSize,
new Pair<Type, IResolver<Composition, object>>[2]
{
new Pair<Type, IResolver<Composition, object>>(typeof(IDependency), valResolver_0000)
,new Pair<Type, IResolver<Composition, object>>(typeof(IService), valResolver_0001)
});
}
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<IDependency>
{
public override IDependency Resolve(Composition composition)
{
return composition.Root2;
}
public override IDependency ResolveByTag(Composition composition, object tag)
{
switch (tag)
{
case null:
return composition.Root2;
default:
return base.ResolveByTag(composition, tag);
}
}
}
private sealed class Resolver_0001: Resolver<IService>
{
public override IService Resolve(Composition composition)
{
return composition.Root1;
}
public override IService ResolveByTag(Composition composition, object tag)
{
switch (tag)
{
case null:
return composition.Root1;
default:
return base.ResolveByTag(composition, tag);
}
}
}
}Class diagram:
---
config:
class:
hideEmptyMembersBox: true
---
classDiagram
Composition --|> IDisposable
Service --|> IService
Dependency --|> IDependency
Composition ..> Service : IService _
Composition ..> Dependency : IDependency _
Service o-- "Singleton" Dependency : IDependency
namespace Pure.DI.UsageTests.BCL.ServiceProviderWithScopeScenario {
class Composition {
<<partial>>
-IDependency _
-IService _
+ T ResolveᐸTᐳ()
+ T ResolveᐸTᐳ(object? tag)
+ object GetService(Type type)
+ object GetRequiredKeyedService(Type type, object? tag)
}
class Dependency {
+Dependency()
}
class IDependency {
<<interface>>
}
class IService {
<<interface>>
}
class Service {
+Service(IDependency dependency)
}
}
namespace System {
class IDisposable {
<<abstract>>
}
}