Added debug information for Scopes

Fixes #993

Author: dotnetjunkie

src/SimpleInjector/Container.Common.cs

@@ -38,16 +38,15 @@ namespace SimpleInjector
     [DebuggerTypeProxy(typeof(ContainerDebugView))]
     public partial class Container : ApiObject, IDisposable
     {
-        internal readonly Dictionary<object, Dictionary<Type, WeakReference>> LifestyleRegistrationCache = new();
+        private static long Counter;
 
-        private static long counter;
+        internal readonly Dictionary<object, Dictionary<Type, WeakReference>> LifestyleRegistrationCache = new();
+        internal readonly long ContainerId;
 
         private readonly object locker = new();
         private readonly List<IInstanceInitializer> instanceInitializers = new();
         private readonly List<ContextualResolveInterceptor> resolveInterceptors = new();
 
-        private readonly long containerId;
-
         // Collection of (both conditional and unconditional) instance producers that are explicitly
         // registered by the user and implicitly registered through unregistered type resolution.
         private readonly Dictionary<Type, IRegistrationEntry> explicitRegistrations = new(64);
@@ -73,7 +72,7 @@ public partial class Container : ApiObject, IDisposable
         /// <summary>Initializes a new instance of the <see cref="Container"/> class.</summary>
         public Container()
         {
-            this.containerId = Interlocked.Increment(ref counter);
+            this.ContainerId = Interlocked.Increment(ref Counter);
 
             this.ContainerScope = new ContainerScope(this);
 

src/SimpleInjector/Scope.cs

@@ -6,7 +6,9 @@ namespace SimpleInjector
     using System;
     using System.Collections;
     using System.Collections.Generic;
+    using System.Diagnostics;
     using System.Runtime.CompilerServices;
+    using System.Threading;
     using System.Threading.Tasks;
     using SimpleInjector.Advanced;
     using SimpleInjector.Internals;
@@ -52,12 +54,16 @@ public partial class Scope
     /// thread-safe methods. This means that once the Scope is ready for disposal, only a single thread should
     /// access it. Also note that although the scope is thread safe, cached instances might not be.
     /// </remarks>
+    [DebuggerDisplay("{DebugString,nq}")]
     public partial class Scope : ApiObject, IDisposable, IServiceProvider
     {
         private const int MaximumDisposeRecursion = 100;
 
+        private static long counter = 0;
+
         private readonly object syncRoot = new();
         private readonly ScopeManager? manager;
+        private readonly long scopeId = Interlocked.Increment(ref counter);
 
         private IDictionary? items;
         private Dictionary<Registration, object>? cachedInstances;
@@ -109,6 +115,11 @@ private enum DisposeState
 
         internal bool IsContainerScope { get; set; }
 
+        private string DebugString =>
+            "Scope #" + this.scopeId
+            + (this.ParentScope is not null ? (" for Parent #" + this.ParentScope.scopeId) : "")
+            + (this.Container is not null ? (" for Container #" + this.Container!.ContainerId) : "");
+
         /// <summary>Gets an instance of the given <typeparamref name="TService"/> for the current scope.</summary>
         /// <typeparam name="TService">The type of the service to resolve.</typeparam>
         /// <remarks><b>Thread safety:</b> Calls to this method are thread safe.</remarks>