From afe34cdbfef684b1b2134932990c62df7707e67e Mon Sep 17 00:00:00 2001
From: Enderlook <enderlook@gmail.com>
Date: Wed, 22 Feb 2023 13:14:12 -0300
Subject: [PATCH] Improve nullability annotations

---
 CHANGELOG.md                                  |   5 +-
 .../Enderlook.EventManager.csproj             |   2 +-
 .../src/EventManager.Weak.cs                  | 172 +++++++++---------
 3 files changed, 91 insertions(+), 88 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3d97c61..b03bd42 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,10 @@
 # Changelog
 
 ##
-- Stop using implementation details of runtimes in order to make the code more safe and compatible with other runtimes.
+
+## v0.4.8
+- Stop using implementation details of runtimes in order to make the code safer and more compatible with other runtimes.
+- Fix nullability annotations.
 
 ## v0.4.7
 
diff --git a/Enderlook.EventManager/Enderlook.EventManager.csproj b/Enderlook.EventManager/Enderlook.EventManager.csproj
index a43c8da..0fba8e3 100644
--- a/Enderlook.EventManager/Enderlook.EventManager.csproj
+++ b/Enderlook.EventManager/Enderlook.EventManager.csproj
@@ -10,7 +10,7 @@
     <Product>Enderlook.EventManager</Product>
     <RepositoryUrl>https://github.com/Enderlook/Net-Event-Manager</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>0.4.7</Version>
+    <Version>0.4.8</Version>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <LangVersion>11</LangVersion>
diff --git a/Enderlook.EventManager/src/EventManager.Weak.cs b/Enderlook.EventManager/src/EventManager.Weak.cs
index fc55c30..4243acb 100644
--- a/Enderlook.EventManager/src/EventManager.Weak.cs
+++ b/Enderlook.EventManager/src/EventManager.Weak.cs
@@ -88,7 +88,7 @@ public void WeakSubscribe<THandle, TEvent>(THandle handle, Action callback, Weak
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<TClosure?, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<TClosure, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -101,19 +101,19 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
         {
             if (trackResurrection)
             {
-                InvariantObjectAndTAndGCHandle<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandle<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
             }
             else
             {
-                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
             }
         }
         else
@@ -122,17 +122,17 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
             {
                 InvariantObjectAndTAndGCHandle<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
             }
             else
             {
                 InvariantObjectAndTAndGCHandleTrackResurrection<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
             }
         }
     }
@@ -148,7 +148,7 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<TClosure?> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<TClosure> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -161,19 +161,19 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
         {
             if (trackResurrection)
             {
-                InvariantObjectAndTAndGCHandle<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandle<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
             }
             else
             {
-                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
             }
         }
         else
@@ -182,17 +182,17 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
             {
                 InvariantObjectAndTAndGCHandle<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
             }
             else
             {
                 InvariantObjectAndTAndGCHandleTrackResurrection<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
             }
         }
     }
@@ -208,7 +208,7 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<THandle, TClosure?, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<THandle, TClosure, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -221,19 +221,19 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
         {
             if (trackResurrection)
             {
-                InvariantObjectAndTAndGCHandle<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandle<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
             }
             else
             {
-                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
             }
         }
         else
@@ -242,17 +242,17 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
             {
                 InvariantObjectAndTAndGCHandle<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<object?>>(callback_, listenToAssignableEvents);
             }
             else
             {
                 InvariantObjectAndTAndGCHandleTrackResurrection<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
             }
         }
     }
@@ -268,7 +268,7 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<THandle, TClosure?> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<THandle, TClosure> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -281,19 +281,19 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
         {
             if (trackResurrection)
             {
-                InvariantObjectAndTAndGCHandle<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandle<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandle<TClosure>>(callback_, listenToAssignableEvents);
             }
             else
             {
-                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?> callback_ = new(callback, handle, closure);
+                InvariantObjectAndTAndGCHandleTrackResurrection<TClosure> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(callback_, listenToAssignableEvents);
             }
         }
         else
@@ -310,9 +310,9 @@ public void WeakSubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? c
             {
                 InvariantObjectAndTAndGCHandleTrackResurrection<object?> callback_ = new(callback, handle, closure);
                 if (multipleRaises)
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
                 else
-                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
+                    Subscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(callback_, listenToAssignableEvents);
             }
         }
     }
@@ -468,7 +468,7 @@ public void WeakUnsubscribe<THandle, TEvent>(THandle handle, Action callback, We
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<TClosure?, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<TClosure, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -479,38 +479,38 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
         bool trackResurrection = (subscribeAttributes & WeakSubscribeFlags.TrackResurrection) == 0;
         if (typeof(TClosure).IsValueType)
         {
-            InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgument<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgument<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
             }
         }
         else
         {
-            InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgument<object?, TClosure, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
             }
         }
     }
@@ -525,7 +525,7 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<TClosure?> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<TClosure> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -536,38 +536,38 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
         bool trackResurrection = (subscribeAttributes & WeakSubscribeFlags.TrackResurrection) == 0;
         if (typeof(TClosure).IsValueType)
         {
-            InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoid<TClosure?, TClosure?, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoid<TClosure, TClosure, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
             }
         }
         else
         {
-            InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure?, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoid<object?, TClosure, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
             }
         }
     }
@@ -582,7 +582,7 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<THandle, TClosure?, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<THandle, TClosure, TEvent> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -593,38 +593,38 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
         bool trackResurrection = (subscribeAttributes & WeakSubscribeFlags.TrackResurrection) == 0;
         if (typeof(TClosure).IsValueType)
         {
-            InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTArgumentWithHandle<TClosure?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTArgumentWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
             }
         }
         else
         {
-            InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?, TEvent>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTArgumentWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure, TEvent>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
             }
         }
     }
@@ -639,7 +639,7 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="callback"/> or <paramref name="handle"/> is <see langword="null"/>.</exception>
     /// <exception cref="ObjectDisposedException">Thrown when this instance has already been disposed.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure? closure, Action<THandle, TClosure?> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
+    public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure closure, Action<THandle, TClosure> callback, WeakSubscribeFlags subscribeAttributes = WeakSubscribeFlags.Default)
         where THandle : class
     {
         if (callback is null) ThrowNullCallbackException();
@@ -650,38 +650,38 @@ public void WeakUnsubscribe<THandle, TClosure, TEvent>(THandle handle, TClosure?
         bool trackResurrection = (subscribeAttributes & WeakSubscribeFlags.TrackResurrection) == 0;
         if (typeof(TClosure).IsValueType)
         {
-            InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<TClosure>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, No, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>, WeakInvariantObjectAndTVoidWithHandle<TClosure?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>, WeakInvariantObjectAndTVoidWithHandle<TClosure, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndValueTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<TClosure>>(predicator, listenToAssignableEvents);
             }
         }
         else
         {
-            InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle> predicator = new(callback, closure, handle);
+            InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle> predicator = new(callback, closure, handle);
             if (trackResurrection)
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandle<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandle<object?>>(predicator, listenToAssignableEvents);
             }
             else
             {
                 if (multipleRaises)
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure?, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure, THandle, TEvent>>, No, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
                 else
-                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure?, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure?>, TClosure?, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
+                    Unsubscribe<TEvent, WeakCallbackExecuter<TEvent, InvariantObjectAndTAndGCHandleTrackResurrection<object?>, WeakInvariantObjectAndTVoidWithHandle<object?, TClosure, THandle, TEvent>>, Yes, InvariantObjectAndReferenceTAndGCHandleComparer<Action<THandle, TClosure>, TClosure, THandle>, InvariantObjectAndTAndGCHandleTrackResurrection<object?>>(predicator, listenToAssignableEvents);
             }
         }
     }