Proposed delegate change

Realm/Realm/DatabaseTypes/Accessors/ManagedAccessor.cs

@@ -210,8 +210,9 @@ public void UnsubscribeFromNotifications()
 
         /// <inheritdoc/>
         void INotifiable<NotifiableObjectHandleBase.CollectionChangeSet>.NotifyCallbacks(NotifiableObjectHandleBase.CollectionChangeSet? changes,
-            KeyPathsCollectionType type, IntPtr callback)
+            KeyPathsCollectionType type, Delegate? callback)
         {
+            Debug.Assert(callback == null, "Object notifications don't support keypaths, so callback should always be null");
             if (changes.HasValue)
             {
                 foreach (var propertyIndex in changes.Value.Properties)

Realm/Realm/DatabaseTypes/INotifiable.cs

@@ -34,8 +34,8 @@ internal interface INotifiable<TChangeset>
         /// </summary>
         /// <param name="changes">The changes that occurred.</param>
         /// <param name="type">The type of the key paths collection related to the notification.</param>
-        /// <param name="callbackNative">The eventual callback to call for the notification (if type == Explicit)</param>
-        void NotifyCallbacks(TChangeset? changes, KeyPathsCollectionType type, IntPtr callbackNative = default);
+        /// <param name="callback">The eventual callback to call for the notification (if type == Explicit).</param>
+        void NotifyCallbacks(TChangeset? changes, KeyPathsCollectionType type, Delegate? callback);
     }
 
     internal class NotificationToken<TCallback> : IDisposable

Realm/Realm/DatabaseTypes/RealmCollectionBase.cs

@@ -214,7 +214,7 @@ internal IDisposable SubscribeForNotificationsImpl(NotificationCallbackDelegate<
                 var token = Handle.Value.AddNotificationCallback(GCHandle.ToIntPtr(managedResultsHandle), keyPathsCollection,
                     GCHandle.ToIntPtr(callbackHandle));
 
-                return NotificationToken.Create(callback, c => token.Dispose());
+                return NotificationToken.Create(callback, _ => token.Dispose());
             }
 
             // For notifications with type Default or Shallow we cache the callbacks on the managed level, to avoid creating multiple notifications in core
@@ -434,7 +434,7 @@ private void UpdateCollectionChangedSubscriptionIfNecessary(bool isSubscribed)
 
         #endregion INotifyCollectionChanged
 
-        void INotifiable<CollectionChangeSet>.NotifyCallbacks(CollectionChangeSet? changes, KeyPathsCollectionType type, IntPtr callbackNative)
+        void INotifiable<CollectionChangeSet>.NotifyCallbacks(CollectionChangeSet? changes, KeyPathsCollectionType type, Delegate? callback)
         {
             ChangeSet? changeset = null;
             if (changes != null)
@@ -449,10 +449,9 @@ void INotifiable<CollectionChangeSet>.NotifyCallbacks(CollectionChangeSet? chang
                     cleared: actualChanges.Cleared);
             }
 
-            if (type == KeyPathsCollectionType.Explicit
-                && GCHandle.FromIntPtr(callbackNative).Target is NotificationCallbackDelegate<T> callback)
+            if (callback is NotificationCallbackDelegate<T> notificationCallback)
             {
-                callback(this, changeset);
+                notificationCallback(this, changeset);
                 return;
             }
 

Realm/Realm/DatabaseTypes/RealmDictionary.cs

@@ -255,11 +255,13 @@ protected override bool ContainsRealmObjects()
         protected override KeyValuePair<string, TValue> GetValueAtIndex(int index) => _dictionaryHandle.GetValueAtIndex<TValue>(index, Realm);
 
         void INotifiable<DictionaryHandle.DictionaryChangeSet>.NotifyCallbacks(DictionaryHandle.DictionaryChangeSet? changes,
-            KeyPathsCollectionType type, IntPtr callback)
+            KeyPathsCollectionType type, Delegate? callback)
         {
             Debug.Assert(type == KeyPathsCollectionType.Full,
                 "Notifications should always be default here as we don't expose a way to configure it.");
 
+            Debug.Assert(callback == null, "Dictionary notifications don't expose keypaths, so the callback should always be null");
+
             DictionaryChangeSet? changeset = null;
             if (changes != null)
             {

Realm/Realm/Handles/DictionaryHandle.cs

@@ -350,7 +350,7 @@ public static unsafe void NotifyDictionaryChanged(IntPtr managedHandle, Dictiona
         {
             if (GCHandle.FromIntPtr(managedHandle).Target is INotifiable<DictionaryChangeSet> notifiable)
             {
-                notifiable.NotifyCallbacks(changes == null ? null : *changes, KeyPathsCollectionType.Full);
+                notifiable.NotifyCallbacks(changes == null ? null : *changes, KeyPathsCollectionType.Full, callback: null);
             }
         }
     }

Realm/Realm/Handles/NotifiableObjectHandleBase.cs

@@ -60,7 +60,8 @@ public static unsafe void NotifyObjectChanged(IntPtr managedHandle, CollectionCh
         {
             if (GCHandle.FromIntPtr(managedHandle).Target is INotifiable<CollectionChangeSet> notifiable)
             {
-                notifiable.NotifyCallbacks(changes == null ? null : *changes, type, callback);
+                var managedCallback = type == KeyPathsCollectionType.Explicit && GCHandle.FromIntPtr(callback).Target is Delegate c ? c : null;
+                notifiable.NotifyCallbacks(changes == null ? null : *changes, type, managedCallback);
             }
         }
     }

Tests/Realm.Tests/Database/NotificationTests.cs

@@ -1740,7 +1740,7 @@ void OnNotification(IRealmCollection<TestNotificationObject> s, ChangeSet? chang
         }
 
         [Test]
-        public void SubscribeWithKeypaths_ShallowKeypath_RaisesOnlyCollectioNotifications()
+        public void SubscribeWithKeypaths_ShallowKeypath_RaisesOnlyCollectionNotifications()
         {
             var query = _realm.All<TestNotificationObject>();
             var changesets = new List<ChangeSet>();