DI: avoid duplicate disposal for shared singleton instances

[Copilot]

When multiple service registrations resolve to the same singleton instance via factory indirection (sp => sp.GetRequiredService<TImpl>()), MEDI could capture that object multiple times for scope disposal. This can lead to repeated disposal and incorrect teardown ordering for dependents.

• Scope capture/disposal behavior

  • Kept ServiceProviderEngineScope.CaptureDisposable allocation-light on hot paths by appending disposables without capture-time deduplication.
  • Added lazy reference-based deduplication in BeginDispose: scan 0 -> count, null duplicate entries, then dispose count -> 0 while skipping nulls.
  • Preserves disposal ordering semantics for dependents while ensuring shared singleton instances are disposed once per scope.

• Behavioral coverage

  • Added targeted tests in ServiceProviderEngineScopeTests for:
    • same singleton resolved as multiple services is disposed once;
    • shared singleton is disposed after dependents that reference it during their own disposal.

• Representative scenario

  services.AddSingleton<TImpl>();
  services.AddSingleton<IService1>(sp => sp.GetRequiredService<TImpl>());
  services.AddSingleton<IService2>(sp => sp.GetRequiredService<TImpl>());

  After this change, duplicate captures are lazily collapsed at dispose time so TImpl is disposed once, and dependent teardown order remains correct.

[rosebyte]

@copilot , the brute force deduplication isn't an option here since services might be resolved in hot-path, gating the list with a set to deduplicate would mean higher memory consumption (8 bytes vs 28 bytes per item) so the best compromise seems to be lazy deduplication when we dispose the scope, going 0->count with a set and nullify all already seen objects and then do count->0 disposing and skipping nulls.

[Copilot]

@copilot , the brute force deduplication isn't an option here since services might be resolved in hot-path, gating the list with a set to deduplicate would mean higher memory consumption (8 bytes vs 2...

Updated in 2fe33aa. I removed capture-time duplicate checks and switched to lazy deduplication in BeginDispose: we now scan forward with a reference-based HashSet, null out repeated entries, then keep the existing reverse disposal pass while skipping nulls in sync/async disposal paths.

[Copilot]

Pull request overview

This PR changes DI scope disposal to avoid disposing the same instance multiple times when it’s captured repeatedly via factory indirection (e.g., multiple singleton registrations returning the same underlying singleton). It does this by collapsing duplicate entries in the captured-disposables list at dispose time, while keeping reverse-disposal ordering for dependents.

Changes:

• Add reference-based deduplication of _disposables entries during BeginDispose, nulling duplicate list slots and skipping nulls during disposal.
• Update sync and async disposal loops to tolerate null entries introduced by deduplication.
• Add regression tests ensuring a shared singleton instance is disposed once and disposed after dependents.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 3 comments.

File	Description
src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceProviderEngineScope.cs	Adds dispose-time deduplication for captured disposables and updates dispose loops to skip null entries.
src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderEngineScopeTests.cs	Adds tests for singleton aliasing scenarios to validate single-dispose behavior and dependent teardown ordering.