From 9b9330c8ccd48737fb22ab66022f3fc1033976cf Mon Sep 17 00:00:00 2001
From: Dan Clark <dan.clark@videosoftglobal.com>
Date: Tue, 3 Dec 2024 09:55:26 +0000
Subject: [PATCH] Ensure messengers can be used in scopes

---
 Toolkit.Foundation/AsyncHandlerInitialization.cs | 14 ++++++++------
 .../AsyncHandlerKeyedInitialization.cs           | 15 +++++++++------
 Toolkit.Foundation/DefaultHostBuilder.cs         |  2 +-
 Toolkit.Foundation/HandlerInitialization.cs      | 14 ++++++++------
 Toolkit.Foundation/HandlerKeyedInitialization.cs | 16 ++++++++++------
 Toolkit.Windows/WndProc.cs                       |  1 +
 6 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/Toolkit.Foundation/AsyncHandlerInitialization.cs b/Toolkit.Foundation/AsyncHandlerInitialization.cs
index 5585331..e170665 100644
--- a/Toolkit.Foundation/AsyncHandlerInitialization.cs
+++ b/Toolkit.Foundation/AsyncHandlerInitialization.cs
@@ -3,15 +3,16 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace Toolkit.Foundation;
 
-public class AsyncHandlerInitialization<TMessage, TResponse, THandler>(IServiceProvider provider) :
+public class AsyncHandlerInitialization<TMessage, TResponse, THandler>(IMessenger messenger,
+    IServiceProvider provider) :
     IInitialization where THandler : class, IAsyncHandler<TMessage, TResponse>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<AsyncResponseEventArgs<TMessage, TResponse>>(provider))
+        if (!messenger.IsRegistered<AsyncResponseEventArgs<TMessage, TResponse>>(provider))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, TResponse>>(provider,
+            messenger.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, TResponse>>(provider,
                 (provider, args) =>
                 {
                     IEnumerable<IAsyncHandler<TMessage, TResponse>> handlers = provider.GetServices<IAsyncHandler<TMessage, TResponse>>();
@@ -30,15 +31,16 @@ public class AsyncHandlerInitialization<TMessage, TResponse, THandler>(IServiceP
     }
 }
 
-public class AsyncHandlerInitialization<TMessage, THandler>(IServiceProvider provider) :
+public class AsyncHandlerInitialization<TMessage, THandler>(IMessenger messenger, 
+    IServiceProvider provider) :
     IInitialization where THandler : class, IAsyncHandler<TMessage>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<AsyncResponseEventArgs<TMessage, Unit>>(provider))
+        if (!messenger.IsRegistered<AsyncResponseEventArgs<TMessage, Unit>>(provider))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, Unit>>(provider,
+            messenger.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, Unit>>(provider,
                 (provider, args) =>
                 {
                     IEnumerable<IAsyncHandler<TMessage>> handlers = provider.GetServices<IAsyncHandler<TMessage>>();
diff --git a/Toolkit.Foundation/AsyncHandlerKeyedInitialization.cs b/Toolkit.Foundation/AsyncHandlerKeyedInitialization.cs
index c13b218..f86ac94 100644
--- a/Toolkit.Foundation/AsyncHandlerKeyedInitialization.cs
+++ b/Toolkit.Foundation/AsyncHandlerKeyedInitialization.cs
@@ -3,15 +3,17 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace Toolkit.Foundation;
 
-public class AsyncHandlerKeyedInitialization<TMessage, THandler>(string key, IServiceProvider provider) :
+public class AsyncHandlerKeyedInitialization<TMessage, THandler>(string key, 
+    IMessenger messenger, 
+    IServiceProvider provider) :
     IInitialization where THandler : class, IAsyncHandler<TMessage>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<AsyncResponseEventArgs<TMessage, Unit>, string>(provider, key))
+        if (!messenger.IsRegistered<AsyncResponseEventArgs<TMessage, Unit>, string>(provider, key))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, Unit>, string>(provider, key,
+            messenger.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, Unit>, string>(provider, key,
                 (provider, args) =>
                 {
                     IEnumerable<IAsyncHandler<TMessage>> handlers = provider.GetKeyedServices<IAsyncHandler<TMessage>>(key);
@@ -30,15 +32,16 @@ public class AsyncHandlerKeyedInitialization<TMessage, THandler>(string key, ISe
     }
 }
 
-public class AsyncHandlerKeyedInitialization<TMessage, TResponse, THandler>(string key, IServiceProvider provider) :
+public class AsyncHandlerKeyedInitialization<TMessage, TResponse, THandler>(string key, IMessenger messenger, 
+    IServiceProvider provider) :
     IInitialization where THandler : class, IAsyncHandler<TMessage, TResponse>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<AsyncResponseEventArgs<TMessage, TResponse>, string>(provider, key))
+        if (!messenger.IsRegistered<AsyncResponseEventArgs<TMessage, TResponse>, string>(provider, key))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, TResponse>, string>(provider, key,
+            messenger.Register<IServiceProvider, AsyncResponseEventArgs<TMessage, TResponse>, string>(provider, key,
                 (provider, args) =>
                 {
                     IEnumerable<IAsyncHandler<TMessage, TResponse>> handlers = provider.GetKeyedServices<IAsyncHandler<TMessage, TResponse>>(key);
diff --git a/Toolkit.Foundation/DefaultHostBuilder.cs b/Toolkit.Foundation/DefaultHostBuilder.cs
index 58894be..effb767 100644
--- a/Toolkit.Foundation/DefaultHostBuilder.cs
+++ b/Toolkit.Foundation/DefaultHostBuilder.cs
@@ -22,7 +22,7 @@ public class DefaultHostBuilder :
                 ComponentHostCollection>();
 
             services.AddSingleton<IDisposer, Disposer>();
-            services.AddSingleton<IMessenger, StrongReferenceMessenger>(_ => StrongReferenceMessenger.Default);
+            services.AddScoped<IMessenger, StrongReferenceMessenger>();
 
             services.AddTransient<IValidation, Validation>();
             services.AddTransient<IValidatorCollection, ValidatorCollection>();
diff --git a/Toolkit.Foundation/HandlerInitialization.cs b/Toolkit.Foundation/HandlerInitialization.cs
index bb344ec..5bd5954 100644
--- a/Toolkit.Foundation/HandlerInitialization.cs
+++ b/Toolkit.Foundation/HandlerInitialization.cs
@@ -3,15 +3,16 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace Toolkit.Foundation;
 
-public class HandlerInitialization<TMessage, TResponse, THandler>(IServiceProvider provider) :
+public class HandlerInitialization<TMessage, TResponse, THandler>(IMessenger messenger,
+    IServiceProvider provider) :
     IInitialization where THandler : class, IHandler<TMessage, TResponse>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<ResponseEventArgs<TMessage, TResponse>>(provider))
+        if (!messenger.IsRegistered<ResponseEventArgs<TMessage, TResponse>>(provider))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, ResponseEventArgs<TMessage, TResponse>>(provider,
+            messenger.Register<IServiceProvider, ResponseEventArgs<TMessage, TResponse>>(provider,
                 (provider, args) =>
                 {
                     IEnumerable<IHandler<TMessage, TResponse>> handlers = provider.GetServices<IHandler<TMessage, TResponse>>();
@@ -31,15 +32,16 @@ public class HandlerInitialization<TMessage, TResponse, THandler>(IServiceProvid
 }
 
 
-public class HandlerInitialization<TMessage, THandler>(IServiceProvider provider) :
+public class HandlerInitialization<TMessage, THandler>(IMessenger messenger, 
+    IServiceProvider provider) :
     IInitialization where THandler : class, IHandler<TMessage>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<TMessage>(provider))
+        if (!messenger.IsRegistered<TMessage>(provider))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, TMessage>(provider,
+            messenger.Register<IServiceProvider, TMessage>(provider,
                 (provider, args) =>
                 {
                     IEnumerable<IHandler<TMessage>> handlers = provider.GetServices<IHandler<TMessage>>();
diff --git a/Toolkit.Foundation/HandlerKeyedInitialization.cs b/Toolkit.Foundation/HandlerKeyedInitialization.cs
index ff7219a..62f1741 100644
--- a/Toolkit.Foundation/HandlerKeyedInitialization.cs
+++ b/Toolkit.Foundation/HandlerKeyedInitialization.cs
@@ -3,15 +3,17 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace Toolkit.Foundation;
 
-public class HandlerKeyedInitialization<TMessage, THandler>(string key, IServiceProvider provider) :
+public class HandlerKeyedInitialization<TMessage, THandler>(string key,
+    IMessenger messenger,
+    IServiceProvider provider) :
     IInitialization where THandler : class, IHandler<TMessage>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<TMessage, string>(provider, key))
+        if (!messenger.IsRegistered<TMessage, string>(provider, key))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, TMessage, string>(provider, key,
+            messenger.Register<IServiceProvider, TMessage, string>(provider, key,
                 (provider, args) =>
                 {
                     IEnumerable<IHandler<TMessage>> handlers = provider.GetKeyedServices<IHandler<TMessage>>(key);
@@ -41,15 +43,17 @@ public class HandlerKeyedInitialization<TMessage, THandler>(string key, IService
     }
 }
 
-public class HandlerKeyedInitialization<TMessage, TResponse, THandler>(string key, IServiceProvider provider) :
+public class HandlerKeyedInitialization<TMessage, TResponse, THandler>(string key, 
+    IMessenger messenger,
+    IServiceProvider provider) :
     IInitialization where THandler : class, IHandler<TMessage, TResponse>
     where TMessage : class
 {
     public void Initialize()
     {
-        if (!StrongReferenceMessenger.Default.IsRegistered<ResponseEventArgs<TMessage, TResponse>, string>(provider, key))
+        if (!messenger.IsRegistered<ResponseEventArgs<TMessage, TResponse>, string>(provider, key))
         {
-            StrongReferenceMessenger.Default.Register<IServiceProvider, ResponseEventArgs<TMessage, TResponse>, string>(provider, key,
+            messenger.Register<IServiceProvider, ResponseEventArgs<TMessage, TResponse>, string>(provider, key,
                 (provider, args) =>
                 {
                     IEnumerable<IHandler<TMessage, TResponse>> handlers = provider.GetKeyedServices<IHandler<TMessage, TResponse>>(key);
diff --git a/Toolkit.Windows/WndProc.cs b/Toolkit.Windows/WndProc.cs
index ae0076f..9ba21ef 100644
--- a/Toolkit.Windows/WndProc.cs
+++ b/Toolkit.Windows/WndProc.cs
@@ -38,6 +38,7 @@ public class WndProc(IMessenger messenger) :
 
         PInvoke.DestroyWindow((HWND)Handle);
     }
+
     private LRESULT HandleWndProc(HWND hWnd, uint msg,
         WPARAM wParam, LPARAM lParam)
     {