Thread-safe overrides

using Shouldly;
using Pure.DI;
using System.Collections.Immutable;
using System.Drawing;

DI.Setup(nameof(Composition))
    .Bind(Tag.Red).To(_ => Color.Red)
    .Bind().As(Lifetime.Singleton).To<Clock>()
    .Bind().To<Func<int, int, IDependency>>(ctx =>
        (dependencyId, subId) =>
        {
            ctx.Inject(Tag.Red, out Color red);

            // Get composition sync root object
            ctx.Inject(Tag.SyncRoot, out Lock lockObject);
            lock (lockObject)
            {
                // Overrides with a lambda argument
                ctx.Override(dependencyId);

                // Overrides with tag using lambda argument
                ctx.Override(subId, "sub");

                // Overrides with some value
                ctx.Override($"Dep {dependencyId} {subId}");

                // Overrides with injected value
                ctx.Override(red);

                ctx.Inject<Dependency>(out var dependency);
                return dependency;
            }
        })
    .Bind().To<Service>()

    // Composition root
    .Root<IService>("Root");

var composition = new Composition();
var service = composition.Root;
service.Dependencies.Length.ShouldBe(100);
for (var i = 0; i < 100; i++)
{
    service.Dependencies.Count(dep => dep.Id == i).ShouldBe(1);
}

interface IClock
{
    DateTimeOffset Now { get; }
}

class Clock : IClock
{
    public DateTimeOffset Now => DateTimeOffset.Now;
}

interface IDependency
{
    string Name { get; }

    int Id { get; }

    int SubId { get; }
}

class Dependency(
    string name,
    IClock clock,
    int id,
    [Tag("sub")] int subId,
    Color red)
    : IDependency
{
    public string Name => name;

    public int Id => id;

    public int SubId => subId;
}

interface IService
{
    ImmutableArray<IDependency> Dependencies { get; }
}

class Service(Func<int, int, IDependency> dependencyFactory): IService
{
    public ImmutableArray<IDependency> Dependencies { get; } =
        [
            ..Enumerable.Range(0, 100).AsParallel().Select(i => dependencyFactory(i, 99))
        ];
}

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
- Pure.DI
- Shouldly

dotnet 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 run

The following partial class will be generated:

partial class Composition
{
  private readonly Composition _root;
#if NET9_0_OR_GREATER
  private readonly Lock _lock;
#else
  private readonly Object _lock;
#endif

  private Clock? _singleClock53;

  [OrdinalAttribute(256)]
  public Composition()
  {
    _root = this;
#if NET9_0_OR_GREATER
    _lock = new Lock();
#else
    _lock = new Object();
#endif
  }

  internal Composition(Composition parentScope)
  {
    _root = (parentScope ?? throw new ArgumentNullException(nameof(parentScope)))._root;
    _lock = parentScope._lock;
  }

  public IService Root
  {
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    get
    {
      Func<int, int, IDependency> transFunc1;
      lock (_lock)
      {
        transFunc1 =
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        (localDependencyId, localSubId1) =>
        {
          Drawing.Color transColor2 = Color.Red;
          Drawing.Color localRed2 = transColor2;
          // Get composition sync root object
          Lock transLock3 = _lock;
          Lock localLockObject52 = transLock3;
          lock (localLockObject52)
          {
            // Overrides with a lambda argument
            // Overrides with tag using lambda argument
            // Overrides with some value
            // Overrides with injected value
            int overrInt32 = localDependencyId;
            int overrInt321 = localSubId1;
            string overrString2 = $"Dep {localDependencyId} {localSubId1}";
            Drawing.Color overrColor3 = localRed2;
            if (_root._singleClock53 is null)
            {
              _root._singleClock53 = new Clock();
            }

            Dependency localDependency53 = new Dependency(overrString2, _root._singleClock53, overrInt32, overrInt321, overrColor3);
            return localDependency53;
          }
        };
      }

      return new Service(transFunc1);
    }
  }
}

Class diagram:

---
 config:
  maxTextSize: 2147483647
  maxEdges: 2147483647
  class:
   hideEmptyMembersBox: true
---
classDiagram
	Service --|> IService
	Composition ..> Service : IService Root
	FuncᐸInt32ˏInt32ˏIDependencyᐳ *--  Lock : "SyncRoot"  Lock
	FuncᐸInt32ˏInt32ˏIDependencyᐳ *--  Color : "Red"  Color
	FuncᐸInt32ˏInt32ˏIDependencyᐳ *--  Dependency : Dependency
	Service *--  FuncᐸInt32ˏInt32ˏIDependencyᐳ : FuncᐸInt32ˏInt32ˏIDependencyᐳ
	Dependency o-- "Singleton" Clock : IClock
	Dependency *--  Int32 : Int32
	Dependency *--  Int32 : "sub"  Int32
	Dependency *--  String : String
	Dependency *--  Color : Color
	namespace Pure.DI.UsageTests.Advanced.ThreadsafeOverridesScenario {
		class Clock {
			<<class>>
		}
		class Composition {
		<<partial>>
		+IService Root
		}
		class Dependency {
				<<class>>
			+Dependency(String name, IClock clock, Int32 id, Int32 subId, Color red)
		}
		class IService {
			<<interface>>
		}
		class Service {
				<<class>>
			+Service(FuncᐸInt32ˏInt32ˏIDependencyᐳ dependencyFactory)
		}
	}
	namespace System {
		class FuncᐸInt32ˏInt32ˏIDependencyᐳ {
				<<delegate>>
		}
		class Int32 {
			<<struct>>
		}
		class String {
			<<class>>
		}
	}
	namespace System.Drawing {
		class Color {
			<<struct>>
		}
	}
	namespace System.Threading {
		class Lock {
			<<class>>
		}
	}

Loading

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!