Improved nullability annotations in messenger types

Author: Sergio0694

Microsoft.Toolkit.Mvvm/Attributes/NotNullWhenAttribute.cs

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if NETSTANDARD2_0
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.
+    /// </summary>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NotNullWhenAttribute"/> class.
+        /// </summary>
+        /// <param name="returnValue">The return value condition. If the method returns this value, the associated parameter will not be null.</param>
+        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        /// <summary>
+        /// Gets a value indicating whether the annotated variable is not <see langword="null"/>.
+        /// </summary>
+        public bool ReturnValue { get; }
+    }
+}
+
+#endif

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

@@ -11,6 +11,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
 
@@ -158,7 +159,7 @@ public bool ContainsKey(TKey key)
         /// <param name="key">The key to look for.</param>
         /// <param name="value">The value found, otherwise <see langword="default"/>.</param>
         /// <returns>Whether or not the key was present.</returns>
-        public bool TryGetValue(TKey key, out TValue? value)
+        public bool TryGetValue(TKey key, [NotNullWhen(true)] out TValue? value)
         {
             Entry[] entries = this.entries;
 
@@ -181,17 +182,6 @@ public bool TryGetValue(TKey key, out TValue? value)
 
         /// <inheritdoc/>
         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);
@@ -219,17 +209,13 @@ public bool TryRemove(TKey key, out TValue? result)
                     this.freeList = entryIndex;
                     this.count--;
 
-                    result = candidate.Value;
-
                     return true;
                 }
 
                 lastIndex = entryIndex;
                 entryIndex = candidate.Next;
             }
 
-            result = null;
-
             return false;
         }
 

Microsoft.Toolkit.Mvvm/Messaging/StrongReferenceMessenger.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Buffers;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using Microsoft.Collections.Extensions;
@@ -102,7 +103,7 @@ public bool IsRegistered<TMessage, TToken>(object recipient, TToken token)
 
                 Recipient key = new(recipient);
 
-                return mapping!.ContainsKey(key);
+                return mapping.ContainsKey(key);
             }
         }
 
@@ -155,7 +156,7 @@ public void UnregisterAll(object recipient)
                 }
 
                 // Removes all the lists of registered handlers for the recipient
-                foreach (IMapping mapping in set!)
+                foreach (IMapping mapping in set)
                 {
                     if (mapping.TryRemove(key) &&
                         mapping.Count == 0)
@@ -168,12 +169,12 @@ public void UnregisterAll(object recipient)
                         // dictionary (a hashed collection) only costs O(1) in the best case, while
                         // if we had tried to iterate the whole dictionary every time we would have
                         // paid an O(n) minimum cost for each single remove operation.
-                        this.typesMap.TryRemove(mapping.TypeArguments, out _);
+                        this.typesMap.TryRemove(mapping.TypeArguments);
                     }
                 }
 
                 // Remove the associated set in the recipients map
-                this.recipientsMap.TryRemove(key, out _);
+                this.recipientsMap.TryRemove(key);
             }
         }
 
@@ -212,7 +213,7 @@ public void UnregisterAll<TToken>(object recipient, TToken token)
                 // the opportunities to reuse existing buffers for both. When we need to reference an item
                 // stored in the buffer with the type we know it will have, we use Unsafe.As<T> to avoid the
                 // expensive type check in the cast, since we already know the assignment will be valid.
-                maps = ArrayPool<object>.Shared.Rent(set!.Count);
+                maps = ArrayPool<object>.Shared.Rent(set.Count);
 
                 foreach (IMapping item in set)
                 {
@@ -256,7 +257,7 @@ public void UnregisterAll<TToken>(object recipient, TToken token)
                             set.Remove(Unsafe.As<IMapping>(map)) &&
                             set.Count == 0)
                         {
-                            this.recipientsMap.TryRemove(key, out _);
+                            this.recipientsMap.TryRemove(key);
                         }
                     }
                 }
@@ -297,28 +298,28 @@ public void Unregister<TMessage, TToken>(object recipient, TToken token)
 
                 Recipient key = new(recipient);
 
-                if (!mapping!.TryGetValue(key, out DictionarySlim<TToken, object>? dictionary))
+                if (!mapping.TryGetValue(key, out DictionarySlim<TToken, object>? dictionary))
                 {
                     return;
                 }
 
                 // Remove the target handler
-                if (dictionary!.TryRemove(token, out _) &&
+                if (dictionary.TryRemove(token) &&
                     dictionary.Count == 0)
                 {
                     // If the map is empty, it means that the current recipient has no remaining
                     // registered handlers for the current <TMessage, TToken> combination, regardless,
                     // of the specific token value (ie. the channel used to receive messages of that type).
                     // We can remove the map entirely from this container, and remove the link to the map itself
                     // to the current mapping between existing registered recipients (or entire recipients too).
-                    mapping.TryRemove(key, out _);
+                    mapping.TryRemove(key);
 
                     HashSet<IMapping> set = this.recipientsMap[key];
 
                     if (set.Remove(mapping) &&
                         set.Count == 0)
                     {
-                        this.recipientsMap.TryRemove(key, out _);
+                        this.recipientsMap.TryRemove(key);
                     }
                 }
             }
@@ -379,7 +380,7 @@ public TMessage Send<TMessage, TToken>(TMessage message, TToken token)
                         // which will always be greater or equal than the ones matching the previous test.
                         // We're still using a checked span accesses here though to make sure an out of
                         // bounds write can never happen even if an error was present in the logic above.
-                        pairs[2 * i] = handler!;
+                        pairs[2 * i] = handler;
                         pairs[(2 * i) + 1] = mappingEnumerator.Key.Target;
                         i++;
                     }
@@ -439,7 +440,7 @@ public void Reset()
         /// <param name="mapping">The resulting <see cref="Mapping{TMessage,TToken}"/> instance, if found.</param>
         /// <returns>Whether or not the required <see cref="Mapping{TMessage,TToken}"/> instance was found.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool TryGetMapping<TMessage, TToken>(out Mapping<TMessage, TToken>? mapping)
+        private bool TryGetMapping<TMessage, TToken>([NotNullWhen(true)] out Mapping<TMessage, TToken>? mapping)
             where TMessage : class
             where TToken : IEquatable<TToken>
         {

Microsoft.Toolkit.Mvvm/Messaging/WeakReferenceMessenger.cs

@@ -64,7 +64,7 @@ public bool IsRegistered<TMessage, TToken>(object recipient, TToken token)
                 // of token and message types. If it exists, check if there is a matching token.
                 return
                     this.recipientsMap.TryGetValue(type2, out RecipientsTable? table) &&
-                    table!.TryGetValue(recipient, out IDictionarySlim? mapping) &&
+                    table.TryGetValue(recipient, out IDictionarySlim? mapping) &&
                     Unsafe.As<DictionarySlim<TToken, object>>(mapping)!.ContainsKey(token);
             }
         }
@@ -133,7 +133,7 @@ public void UnregisterAll<TToken>(object recipient, TToken token)
                     if (enumerator.Key.TToken == typeof(TToken) &&
                         enumerator.Value.TryGetValue(recipient, out IDictionarySlim? mapping))
                     {
-                        Unsafe.As<DictionarySlim<TToken, object>>(mapping)!.TryRemove(token, out _);
+                        Unsafe.As<DictionarySlim<TToken, object>>(mapping)!.TryRemove(token);
                     }
                 }
             }
@@ -151,9 +151,9 @@ public void Unregister<TMessage, TToken>(object recipient, TToken token)
                 // Get the target mapping table for the combination of message and token types,
                 // and remove the handler with a matching token (the entire map), if present.
                 if (this.recipientsMap.TryGetValue(type2, out RecipientsTable? value) &&
-                    value!.TryGetValue(recipient, out IDictionarySlim? mapping))
+                    value.TryGetValue(recipient, out IDictionarySlim? mapping))
                 {
-                    Unsafe.As<DictionarySlim<TToken, object>>(mapping)!.TryRemove(token, out _);
+                    Unsafe.As<DictionarySlim<TToken, object>>(mapping)!.TryRemove(token);
                 }
             }
         }
@@ -184,13 +184,13 @@ public TMessage Send<TMessage, TToken>(TMessage message, TToken token)
                 // to enumerate all the existing recipients for the token and message types pair
                 // corresponding to the generic arguments for this invocation, and then track the
                 // handlers with a matching token, and their corresponding recipients.
-                foreach (KeyValuePair<object, IDictionarySlim> pair in table!)
+                foreach (KeyValuePair<object, IDictionarySlim> pair in table)
                 {
                     var map = Unsafe.As<DictionarySlim<TToken, object>>(pair.Value);
 
                     if (map.TryGetValue(token, out object? handler))
                     {
-                        bufferWriter.Add(handler!);
+                        bufferWriter.Add(handler);
                         bufferWriter.Add(pair.Key);
                         i++;
                     }
@@ -268,7 +268,7 @@ public void Cleanup()
                 // Remove all the mappings with no handlers left
                 foreach (Type2 key in type2s.Span)
                 {
-                    this.recipientsMap.TryRemove(key, out _);
+                    this.recipientsMap.TryRemove(key);
                 }
             }
         }