Memory usage improvements/optimizations to Messenger

Microsoft.Toolkit.Mvvm/ComponentModel/ObservableRecipient.cs

@@ -25,11 +25,11 @@ public abstract class ObservableRecipient : ObservableObject
         /// Initializes a new instance of the <see cref="ObservableRecipient"/> class.
         /// </summary>
         /// <remarks>
-        /// This constructor will produce an instance that will use the <see cref="Messaging.Messenger.Default"/> instance
+        /// This constructor will produce an instance that will use the <see cref="WeakReferenceMessenger.Default"/> instance
         /// to perform requested operations. It will also be available locally through the <see cref="Messenger"/> property.
         /// </remarks>
         protected ObservableRecipient()
-            : this(Messaging.Messenger.Default)
+            : this(WeakReferenceMessenger.Default)
         {
         }
 
@@ -78,7 +78,7 @@ public bool IsActive
         /// <remarks>
         /// The base implementation registers all messages for this recipients that have been declared
         /// explicitly through the <see cref="IRecipient{TMessage}"/> interface, using the default channel.
-        /// For more details on how this works, see the <see cref="MessengerExtensions.RegisterAll"/> method.
+        /// For more details on how this works, see the <see cref="IMessengerExtensions.RegisterAll"/> method.
         /// If you need more fine tuned control, want to register messages individually or just prefer
         /// the lambda-style syntax for message registration, override this method and register manually.
         /// </remarks>

Microsoft.Toolkit.Mvvm/Messaging/IMessenger.cs

@@ -7,8 +7,70 @@
 
 namespace Microsoft.Toolkit.Mvvm.Messaging
 {
+    /// <summary>
+    /// A <see langword="delegate"/> used to represent actions to invoke when a message is received.
+    /// The recipient is given as an input argument to allow message registrations to avoid creating
+    /// closures: if an instance method on a recipient needs to be invoked it is possible to just
+    /// cast the recipient to the right type and then access the local method from that instance.
+    /// </summary>
+    /// <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
+    /// <typeparam name="TMessage">The type of message to receive.</typeparam>
+    /// <param name="recipient">The recipient that is receiving the message.</param>
+    /// <param name="message">The message being received.</param>
+    public delegate void MessageHandler<in TRecipient, in TMessage>(TRecipient recipient, TMessage message)
+        where TRecipient : class
+        where TMessage : class;
+
     /// <summary>
     /// An interface for a type providing the ability to exchange messages between different objects.
+    /// This can be useful to decouple different modules of an application without having to keep strong
+    /// references to types being referenced. It is also possible to send messages to specific channels, uniquely
+    /// identified by a token, and to have different messengers in different sections of an applications.
+    /// In order to use the <see cref="IMessenger"/> functionalities, first define a message type, like so:
+    /// <code>
+    /// public sealed class LoginCompletedMessage { }
+    /// </code>
+    /// Then, register your a recipient for this message:
+    /// <code>
+    /// Messenger.Default.Register&lt;MyRecipientType, LoginCompletedMessage&gt;(this, (r, m) =>
+    /// {
+    ///     // Handle the message here...
+    /// });
+    /// </code>
+    /// The message handler here is a lambda expression taking two parameters: the recipient and the message.
+    /// This is done to avoid the allocations for the closures that would've been generated if the expression
+    /// had captured the current instance. The recipient type parameter is used so that the recipient can be
+    /// directly accessed within the handler without the need to manually perform type casts. This allows the
+    /// code to be less verbose and more reliable, as all the checks are done just at build time. If the handler
+    /// is defined within the same type as the recipient, it is also possible to directly access private members.
+    /// This allows the message handler to be a static method, which enables the C# compiler to perform a number
+    /// of additional memory optimizations (such as caching the delegate, avoiding unnecessary memory allocations).
+    /// Finally, send a message when needed, like so:
+    /// <code>
+    /// Messenger.Default.Send&lt;LoginCompletedMessage&gt;();
+    /// </code>
+    /// Additionally, the method group syntax can also be used to specify the message handler
+    /// to invoke when receiving a message, if a method with the right signature is available
+    /// in the current scope. This is helpful to keep the registration and handling logic separate.
+    /// Following up from the previous example, consider a class having this method:
+    /// <code>
+    /// private static void Receive(MyRecipientType recipient, LoginCompletedMessage message)
+    /// {
+    ///     // Handle the message there
+    /// }
+    /// </code>
+    /// The registration can then be performed in a single line like so:
+    /// <code>
+    /// Messenger.Default.Register(this, Receive);
+    /// </code>
+    /// The C# compiler will automatically convert that expression to a <see cref="MessageHandler{TRecipient,TMessage}"/> instance
+    /// compatible with <see cref="IMessengerExtensions.Register{TRecipient,TMessage}(IMessenger,TRecipient,MessageHandler{TRecipient,TMessage})"/>.
+    /// This will also work if multiple overloads of that method are available, each handling a different
+    /// message type: the C# compiler will automatically pick the right one for the current message type.
+    /// It is also possible to register message handlers explicitly using the <see cref="IRecipient{TMessage}"/> interface.
+    /// To do so, the recipient just needs to implement the interface and then call the
+    /// <see cref="IMessengerExtensions.RegisterAll(IMessenger,object)"/> extension, which will automatically register
+    /// all the handlers that are declared by the recipient type. Registration for individual handlers is supported as well.
     /// </summary>
     public interface IMessenger
     {
@@ -28,13 +90,15 @@ bool IsRegistered<TMessage, TToken>(object recipient, TToken token)
         /// <summary>
         /// Registers a recipient for a given type of message.
         /// </summary>
+        /// <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
         /// <typeparam name="TMessage">The type of message to receive.</typeparam>
         /// <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
         /// <param name="recipient">The recipient that will receive the messages.</param>
         /// <param name="token">A token used to determine the receiving channel to use.</param>
-        /// <param name="action">The <see cref="Action{T}"/> to invoke when a message is received.</param>
+        /// <param name="handler">The <see cref="MessageHandler{TRecipient,TMessage}"/> to invoke when a message is received.</param>
         /// <exception cref="InvalidOperationException">Thrown when trying to register the same message twice.</exception>
-        void Register<TMessage, TToken>(object recipient, TToken token, Action<TMessage> action)
+        void Register<TRecipient, TMessage, TToken>(TRecipient recipient, TToken token, MessageHandler<TRecipient, TMessage> handler)
+            where TRecipient : class
             where TMessage : class
             where TToken : IEquatable<TToken>;
 
@@ -83,6 +147,14 @@ TMessage Send<TMessage, TToken>(TMessage message, TToken token)
             where TMessage : class
             where TToken : IEquatable<TToken>;
 
+        /// <summary>
+        /// Performs a cleanup on the current messenger.
+        /// Invoking this method does not unregister any of the currently registered
+        /// recipient, and it can be used to perform cleanup operations such as
+        /// trimming the internal data structures of a messenger implementation.
+        /// </summary>
+        void Cleanup();
+
         /// <summary>
         /// Resets the <see cref="IMessenger"/> instance and unregisters all the existing recipients.
         /// </summary>

Microsoft.Toolkit.Mvvm/Messaging/MessengerExtensions.cs → Microsoft.Toolkit.Mvvm/Messaging/IMessengerExtensions.cs

@@ -8,19 +8,20 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using Microsoft.Toolkit.Mvvm.Messaging.Internals;
 
 namespace Microsoft.Toolkit.Mvvm.Messaging
 {
     /// <summary>
     /// Extensions for the <see cref="IMessenger"/> type.
     /// </summary>
-    public static partial class MessengerExtensions
+    public static class IMessengerExtensions
     {
         /// <summary>
         /// A class that acts as a container to load the <see cref="MethodInfo"/> instance linked to
         /// the <see cref="Register{TMessage,TToken}(IMessenger,IRecipient{TMessage},TToken)"/> method.
         /// This class is needed to avoid forcing the initialization code in the static constructor to run as soon as
-        /// the <see cref="MessengerExtensions"/> type is referenced, even if that is done just to use methods
+        /// the <see cref="IMessengerExtensions"/> type is referenced, even if that is done just to use methods
         /// that do not actually require this <see cref="MethodInfo"/> instance to be available.
         /// We're effectively using this type to leverage the lazy loading of static constructors done by the runtime.
         /// </summary>
@@ -32,7 +33,7 @@ private static class MethodInfos
             static MethodInfos()
             {
                 RegisterIRecipient = (
-                    from methodInfo in typeof(MessengerExtensions).GetMethods()
+                    from methodInfo in typeof(IMessengerExtensions).GetMethods()
                     where methodInfo.Name == nameof(Register) &&
                           methodInfo.IsGenericMethod &&
                           methodInfo.GetGenericArguments().Length == 2
@@ -174,7 +175,7 @@ static Action<IMessenger, object, TToken> GetRegistrationAction(Type type, Metho
         public static void Register<TMessage>(this IMessenger messenger, IRecipient<TMessage> recipient)
             where TMessage : class
         {
-            messenger.Register<TMessage, Unit>(recipient, default, recipient.Receive);
+            messenger.Register<IRecipient<TMessage>, TMessage, Unit>(recipient, default, (r, m) => r.Receive(m));
         }
 
         /// <summary>
@@ -191,7 +192,7 @@ public static void Register<TMessage, TToken>(this IMessenger messenger, IRecipi
             where TMessage : class
             where TToken : IEquatable<TToken>
         {
-            messenger.Register<TMessage, TToken>(recipient, token, recipient.Receive);
+            messenger.Register<IRecipient<TMessage>, TMessage, TToken>(recipient, token, (r, m) => r.Receive(m));
         }
 
         /// <summary>
@@ -200,13 +201,47 @@ public static void Register<TMessage, TToken>(this IMessenger messenger, IRecipi
         /// <typeparam name="TMessage">The type of message to receive.</typeparam>
         /// <param name="messenger">The <see cref="IMessenger"/> instance to use to register the recipient.</param>
         /// <param name="recipient">The recipient that will receive the messages.</param>
-        /// <param name="action">The <see cref="Action{T}"/> to invoke when a message is received.</param>
+        /// <param name="handler">The <see cref="MessageHandler{TRecipient,TMessage}"/> to invoke when a message is received.</param>
         /// <exception cref="InvalidOperationException">Thrown when trying to register the same message twice.</exception>
         /// <remarks>This method will use the default channel to perform the requested registration.</remarks>
-        public static void Register<TMessage>(this IMessenger messenger, object recipient, Action<TMessage> action)
+        public static void Register<TMessage>(this IMessenger messenger, object recipient, MessageHandler<object, TMessage> handler)
             where TMessage : class
         {
-            messenger.Register(recipient, default(Unit), action);
+            messenger.Register(recipient, default(Unit), handler);
+        }
+
+        /// <summary>
+        /// Registers a recipient for a given type of message.
+        /// </summary>
+        /// <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
+        /// <typeparam name="TMessage">The type of message to receive.</typeparam>
+        /// <param name="messenger">The <see cref="IMessenger"/> instance to use to register the recipient.</param>
+        /// <param name="recipient">The recipient that will receive the messages.</param>
+        /// <param name="handler">The <see cref="MessageHandler{TRecipient,TMessage}"/> to invoke when a message is received.</param>
+        /// <exception cref="InvalidOperationException">Thrown when trying to register the same message twice.</exception>
+        /// <remarks>This method will use the default channel to perform the requested registration.</remarks>
+        public static void Register<TRecipient, TMessage>(this IMessenger messenger, TRecipient recipient, MessageHandler<TRecipient, TMessage> handler)
+            where TRecipient : class
+            where TMessage : class
+        {
+            messenger.Register(recipient, default(Unit), handler);
+        }
+
+        /// <summary>
+        /// Registers a recipient for a given type of message.
+        /// </summary>
+        /// <typeparam name="TMessage">The type of message to receive.</typeparam>
+        /// <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
+        /// <param name="messenger">The <see cref="IMessenger"/> instance to use to register the recipient.</param>
+        /// <param name="recipient">The recipient that will receive the messages.</param>
+        /// <param name="token">A token used to determine the receiving channel to use.</param>
+        /// <param name="handler">The <see cref="MessageHandler{TRecipient,TMessage}"/> to invoke when a message is received.</param>
+        /// <exception cref="InvalidOperationException">Thrown when trying to register the same message twice.</exception>
+        public static void Register<TMessage, TToken>(this IMessenger messenger, object recipient, TToken token, MessageHandler<object, TMessage> handler)
+            where TMessage : class
+            where TToken : IEquatable<TToken>
+        {
+            messenger.Register(recipient, token, handler);
         }
 
         /// <summary>

Microsoft.Toolkit.Mvvm/Messaging/Microsoft.Collections.Extensions/DictionarySlim{TKey,TValue}.cs → Microsoft.Toolkit.Mvvm/Messaging/Internals/Microsoft.Collections.Extensions/DictionarySlim{TKey,TValue}.cs

@@ -130,7 +130,11 @@ public void Clear()
             this.entries = InitialEntries;
         }
 
-        /// <inheritdoc cref="Dictionary{TKey,TValue}.ContainsKey"/>
+        /// <summary>
+        /// Checks whether or not the dictionary contains a pair with a specified key.
+        /// </summary>
+        /// <param name="key">The key to look for.</param>
+        /// <returns>Whether or not the key was present in the dictionary.</returns>
         public bool ContainsKey(TKey key)
         {
             Entry[] entries = this.entries;
@@ -176,7 +180,18 @@ public bool TryGetValue(TKey key, out TValue? value)
         }
 
         /// <inheritdoc/>
-        public bool TryRemove(TKey key, out object? result)
+        public bool TryRemove(TKey key)
+        {
+            return TryRemove(key, out _);
+        }
+
+        /// <summary>
+        /// Tries to remove a value with a specified key, if present.
+        /// </summary>
+        /// <param name="key">The key of the value to remove.</param>
+        /// <param name="result">The removed value, if it was present.</param>
+        /// <returns>Whether or not the key was present.</returns>
+        public bool TryRemove(TKey key, out TValue? result)
         {
             Entry[] entries = this.entries;
             int bucketIndex = key.GetHashCode() & (this.buckets.Length - 1);
@@ -218,13 +233,6 @@ public bool TryRemove(TKey key, out object? result)
             return false;
         }
 
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Remove(TKey key)
-        {
-            return TryRemove(key, out _);
-        }
-
         /// <summary>
         /// Gets the value for the specified key, or, if the key is not present,
         /// adds an entry and returns the value by ref. This makes it possible to

Microsoft.Toolkit.Mvvm/Messaging/Microsoft.Collections.Extensions/IDictionarySlim{TKey}.cs → Microsoft.Toolkit.Mvvm/Messaging/Internals/Microsoft.Collections.Extensions/IDictionarySlim{TKey}.cs

@@ -14,18 +14,10 @@ internal interface IDictionarySlim<in TKey> : IDictionarySlim
         where TKey : IEquatable<TKey>
     {
         /// <summary>
-        /// Tries to remove a value with a specified key.
+        /// Tries to remove a value with a specified key, if present.
         /// </summary>
         /// <param name="key">The key of the value to remove.</param>
-        /// <param name="result">The removed value, if it was present.</param>
-        /// <returns>.Whether or not the key was present.</returns>
-        bool TryRemove(TKey key, out object? result);
-
-        /// <summary>
-        /// Removes an item from the dictionary with the specified key, if present.
-        /// </summary>
-        /// <param name="key">The key of the item to remove.</param>
-        /// <returns>Whether or not an item was removed.</returns>
-        bool Remove(TKey key);
+        /// <returns>Whether or not the key was present.</returns>
+        bool TryRemove(TKey key);
     }
 }