use scope store

Author: KuraiAndras

.editorconfig

@@ -213,3 +213,5 @@ dotnet_diagnostic.CA1040.severity = none
 
 # CA1031: Do not catch general exception types
 dotnet_diagnostic.CA1031.severity = none
+
+dotnet_diagnostic.S3011.severity = none

MainProject/Injecter.Wpf/XamlInjecter.cs

@@ -32,7 +32,9 @@ private static void DoInjectionScoped(DependencyObject d, DependencyPropertyChan
 
             if (CompositionRoot.ServiceProvider is null) return;
 
-            var scope = CompositionRoot.ServiceProvider.GetRequiredService<IInjecter>().InjectIntoType(d.GetType(), d);
+            CompositionRoot.ServiceProvider
+                .GetRequiredService<IInjecter>()
+                .InjectIntoType(d.GetType(), d);
 
             var behavior = (DisposeBehaviour?)e.NewValue;
 
@@ -49,13 +51,14 @@ void OnLoaded(object sender, EventArgs eventArgs)
 
                             var window = Window.GetWindow(d);
 
-                            void OnWindowClosed(object _, EventArgs __)
+                            void OnWindowClosed(object? _, EventArgs __)
                             {
                                 window.Closed -= OnWindowClosed;
                                 window = null;
 
-                                scope!.Dispose();
-                                scope = null;
+                                CompositionRoot.ServiceProvider
+                                    .GetRequiredService<IScopeStore>()
+                                    .DisposeScope(d);
 
                                 if (d is IDisposable disposable) disposable.Dispose();
                                 d = null!;
@@ -70,12 +73,13 @@ void OnWindowClosed(object _, EventArgs __)
                     }
                 case DisposeBehaviour.OnDispatcherShutdown:
                     {
-                        void OnControlShutdown(object sender, EventArgs eventArgs)
+                        void OnControlShutdown(object? sender, EventArgs __)
                         {
                             Application.Current.Dispatcher.ShutdownFinished -= OnControlShutdown;
 
-                            scope!.Dispose();
-                            scope = null;
+                            CompositionRoot.ServiceProvider
+                                .GetRequiredService<IScopeStore>()
+                                .DisposeScope(d);
 
                             if (d is IDisposable disposable) disposable.Dispose();
                             d = null!;
@@ -89,13 +93,14 @@ void OnControlShutdown(object sender, EventArgs eventArgs)
                     {
                         if (d is not FrameworkElement f) throw new InvalidOperationException($"{d} is not of type {nameof(FrameworkElement)}");
 
-                        void OnControlUnloaded(object sender, RoutedEventArgs routedEventArgs)
+                        void OnControlUnloaded(object? _, RoutedEventArgs __)
                         {
                             f.Unloaded -= OnControlUnloaded;
                             f = null!;
 
-                            scope!.Dispose();
-                            scope = null;
+                            CompositionRoot.ServiceProvider
+                                .GetRequiredService<IScopeStore>()
+                                .DisposeScope(d);
 
                             if (d is IDisposable disposable) disposable.Dispose();
                             d = null!;

MainProject/Injecter/IScopeStore.cs

@@ -0,0 +1,11 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Injecter
+{
+    public interface IScopeStore
+    {
+        IServiceScope CreateScope(object owner);
+        void DisposeScope(object owner);
+        IServiceScope GetScope(object owner);
+    }
+}

MainProject/Injecter/Injecter.cs

@@ -12,12 +12,14 @@ public sealed class Injecter : IInjecter
         private readonly ConcurrentDictionary<Type, (FieldInfo[] fieldInfos, PropertyInfo[] propertyInfos, MethodInfo[] methodInfos)> _resolveDictionary = new();
 
         private readonly InjecterOptions _options;
+        private readonly IScopeStore _scopeStore;
         private readonly IServiceProvider _serviceProvider;
 
-        public Injecter(IServiceProvider serviceProvider, InjecterOptions options)
+        public Injecter(IServiceProvider serviceProvider, InjecterOptions options, IScopeStore scopeStore)
         {
             _serviceProvider = serviceProvider;
             _options = options;
+            _scopeStore = scopeStore;
         }
 
         public IServiceScope? InjectIntoType(Type type, object instance, bool createScope = true)
@@ -27,7 +29,7 @@ public Injecter(IServiceProvider serviceProvider, InjecterOptions options)
 
             var (fieldInfos, propertyInfos, methodInfos) = GetMembers(type);
 
-            IServiceScope? serviceScope = createScope ? _serviceProvider.CreateScope() : null;
+            IServiceScope? serviceScope = createScope ? _scopeStore.CreateScope(instance) : null;
             var serviceProvider = createScope switch
             {
                 true => serviceScope!.ServiceProvider,

MainProject/Injecter/InjecterExtensions.cs

@@ -15,6 +15,7 @@ public static IServiceCollection AddInjecter(this IServiceCollection services, A
 
             services.AddSingleton(options);
             services.AddSingleton<IInjecter, Injecter>();
+            services.AddSingleton<IScopeStore, ScopeStore>();
 
             return services;
         }

MainProject/Injecter/ScopeStore.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+
+namespace Injecter
+{
+    public sealed class ScopeStore : IScopeStore
+    {
+        private readonly IServiceProvider _serviceProvider;
+        private readonly Dictionary<object, IServiceScope> _scopes = new();
+
+        public ScopeStore(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;
+
+        public IServiceScope CreateScope(object owner)
+        {
+            var scope = _serviceProvider.CreateScope();
+            _scopes.Add(owner, scope);
+
+            return scope;
+        }
+
+        public IServiceScope GetScope(object owner) => _scopes[owner];
+
+        public void DisposeScope(object owner)
+        {
+            var scope = _scopes[owner];
+
+            scope.Dispose();
+
+            _scopes.Remove(owner);
+        }
+    }
+}