Enabled inlining for calls to IDispatcherQueueHandler.Release()

Author: Sergio0694

CommunityToolkit.WinUI/Extensions/DispatcherQueueExtensions{T}.cs

@@ -111,7 +111,8 @@ public static unsafe bool TryEnqueue<T1, T2>(this DispatcherQueue dispatcherQueu
         /// <param name="dispatcherQueueHandler">The input callback to enqueue.</param>
         /// <returns>Whether or not the task was added to the queue.</returns>
         /// <exception cref="Exception">Thrown when the enqueue operation fails.</exception>
-        private static unsafe bool TryEnqueue(DispatcherQueue dispatcherQueue, DispatcherQueuePriority? priority, IDispatcherQueueHandler* dispatcherQueueHandler)
+        private static unsafe bool TryEnqueue<THandler>(DispatcherQueue dispatcherQueue, DispatcherQueuePriority? priority, THandler* dispatcherQueueHandler)
+            where THandler : unmanaged, IDispatcherQueueHandler
         {
             bool success;
             int hResult;

CommunityToolkit.WinUI/Extensions/Interop/DispatcherQueueProxyHandler1.cs

@@ -19,7 +19,7 @@ namespace CommunityToolkit.WinUI.Interop
     /// A custom <c>IDispatcherQueueHandler</c> object, that internally stores a captured <see cref="DispatcherQueueHandler{TState}"/> instance
     /// and the input captured state. This allows consumers to enqueue a state and a cached stateless delegate without any managed allocations.
     /// </summary>
-    internal unsafe struct DispatcherQueueProxyHandler1
+    internal unsafe struct DispatcherQueueProxyHandler1 : IDispatcherQueueHandler
     {
         /// <summary>
         /// The shared vtable pointer for <see cref="DispatcherQueueProxyHandler1"/> instances.
@@ -68,12 +68,12 @@ internal unsafe struct DispatcherQueueProxyHandler1
         private volatile uint referenceCount;
 
         /// <summary>
-        /// Creates a new <see cref="IDispatcherQueueHandler"/> instance for the input callback and state.
+        /// Creates a new <see cref="DispatcherQueueProxyHandler1"/> instance for the input callback and state.
         /// </summary>
         /// <param name="handler">The input <see cref="DispatcherQueueHandler{TState}"/> callback to enqueue.</param>
         /// <param name="state">The input state to capture and pass to the callback.</param>
-        /// <returns>A pointer to the newly initialized <see cref="IDispatcherQueueHandler"/> instance.</returns>
-        public static IDispatcherQueueHandler* Create(object handler, object state)
+        /// <returns>A pointer to the newly initialized <see cref="DispatcherQueueProxyHandler1"/> instance.</returns>
+        public static DispatcherQueueProxyHandler1* Create(object handler, object state)
         {
             DispatcherQueueProxyHandler1* @this = (DispatcherQueueProxyHandler1*)Marshal.AllocHGlobal(sizeof(DispatcherQueueProxyHandler1));
 
@@ -82,7 +82,7 @@ internal unsafe struct DispatcherQueueProxyHandler1
             @this->stateHandle = GCHandle.Alloc(state);
             @this->referenceCount = 1;
 
-            return (IDispatcherQueueHandler*)@this;
+            return @this;
         }
 
         /// <summary>

CommunityToolkit.WinUI/Extensions/Interop/DispatcherQueueProxyHandler2.cs

@@ -19,7 +19,7 @@ namespace CommunityToolkit.WinUI.Interop
     /// A custom <c>IDispatcherQueueHandler</c> object, that internally stores a captured <see cref="DispatcherQueueHandler{T1,T2}"/> instance
     /// and the input captured state. This allows consumers to enqueue a state and a cached stateless delegate without any managed allocations.
     /// </summary>
-    internal unsafe struct DispatcherQueueProxyHandler2
+    internal unsafe struct DispatcherQueueProxyHandler2 : IDispatcherQueueHandler
     {
         /// <summary>
         /// The shared vtable pointer for <see cref="DispatcherQueueProxyHandler2"/> instances.
@@ -73,13 +73,13 @@ internal unsafe struct DispatcherQueueProxyHandler2
         private volatile uint referenceCount;
 
         /// <summary>
-        /// Creates a new <see cref="IDispatcherQueueHandler"/> instance for the input callback and state.
+        /// Creates a new <see cref="DispatcherQueueProxyHandler2"/> instance for the input callback and state.
         /// </summary>
         /// <param name="handler">The input <see cref="DispatcherQueueHandler{T1,T2}"/> callback to enqueue.</param>
         /// <param name="state1">The first input state to capture and pass to the callback.</param>
         /// <param name="state2">The second input state to capture and pass to the callback.</param>
-        /// <returns>A pointer to the newly initialized <see cref="IDispatcherQueueHandler"/> instance.</returns>
-        public static IDispatcherQueueHandler* Create(object handler, object state1, object state2)
+        /// <returns>A pointer to the newly initialized <see cref="DispatcherQueueProxyHandler2"/> instance.</returns>
+        public static DispatcherQueueProxyHandler2* Create(object handler, object state1, object state2)
         {
             DispatcherQueueProxyHandler2* @this = (DispatcherQueueProxyHandler2*)Marshal.AllocHGlobal(sizeof(DispatcherQueueProxyHandler2));
 
@@ -89,7 +89,7 @@ internal unsafe struct DispatcherQueueProxyHandler2
             @this->state2Handle = GCHandle.Alloc(state2);
             @this->referenceCount = 1;
 
-            return (IDispatcherQueueHandler*)@this;
+            return @this;
         }
 
         /// <summary>

CommunityToolkit.WinUI/Extensions/Interop/IDispatcherQueue.cs

@@ -25,10 +25,16 @@ internal unsafe struct IDispatcherQueue
         /// <param name="callback">A pointer to an <see cref="IDispatcherQueueHandler"/> object.</param>
         /// <param name="result">The result of the operation (the <see cref="bool"/> WinRT retval).</param>
         /// <returns>The HRESULT for the operation.</returns>
+        /// <remarks>
+        /// The <paramref name="callback"/> parameter is assumed to be a pointer to an <see cref="IDispatcherQueueHandler"/> object, but it
+        /// is just typed as a <see cref="void"/> to avoid unnecessary generic instantiations for this method (as it just needs to pass a
+        /// pointer to the native side anyway). The <see cref="IDispatcherQueueHandler"/> is an actual C# interface and not a C++ one as it
+        /// is only used internally to constrain type parameters and allow calls to <see cref="IDispatcherQueueHandler.Release"/> to be inlined.
+        /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int TryEnqueue(IDispatcherQueueHandler* callback, byte* result)
+        public int TryEnqueue(void* callback, byte* result)
         {
-            return ((delegate* unmanaged<IDispatcherQueue*, IDispatcherQueueHandler*, byte*, int>)lpVtbl[7])((IDispatcherQueue*)Unsafe.AsPointer(ref this), callback, result);
+            return ((delegate* unmanaged<IDispatcherQueue*, void*, byte*, int>)lpVtbl[7])((IDispatcherQueue*)Unsafe.AsPointer(ref this), callback, result);
         }
 
         /// <summary>
@@ -39,9 +45,9 @@ public int TryEnqueue(IDispatcherQueueHandler* callback, byte* result)
         /// <param name="result">The result of the operation (the <see cref="bool"/> WinRT retval).</param>
         /// <returns>The HRESULT for the operation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int TryEnqueueWithPriority(DispatcherQueuePriority priority, IDispatcherQueueHandler* callback, byte* result)
+        public int TryEnqueueWithPriority(DispatcherQueuePriority priority, void* callback, byte* result)
         {
-            return ((delegate* unmanaged<IDispatcherQueue*, DispatcherQueuePriority, IDispatcherQueueHandler*, byte*, int>)lpVtbl[8])((IDispatcherQueue*)Unsafe.AsPointer(ref this), priority, callback, result);
+            return ((delegate* unmanaged<IDispatcherQueue*, DispatcherQueuePriority, void*, byte*, int>)lpVtbl[8])((IDispatcherQueue*)Unsafe.AsPointer(ref this), priority, callback, result);
         }
     }
 }

CommunityToolkit.WinUI/Extensions/Interop/IDispatcherQueueHandler.cs

@@ -2,30 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Runtime.CompilerServices;
-
-#pragma warning disable CS0649, SA1023
-
 namespace CommunityToolkit.WinUI.Interop
 {
     /// <summary>
-    /// A struct mapping the native WinRT <c>IDispatcherQueueHandler</c> interface.
+    /// An interface mapping the native WinRT <c>IDispatcherQueueHandler</c> interface.
     /// </summary>
-    internal unsafe struct IDispatcherQueueHandler
+    internal interface IDispatcherQueueHandler
     {
         /// <summary>
-        /// The vtable pointer for the current instance.
-        /// </summary>
-        private readonly void** lpVtbl;
-
-        /// <summary>
-        /// Native API for <c>IUnknown.Release()</c>.
+        /// Implements <c>IUnknown.Release()</c>.
         /// </summary>
         /// <returns>The updated reference count for the current instance.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public uint Release()
-        {
-            return ((delegate* unmanaged<IDispatcherQueueHandler*, uint>)lpVtbl[2])((IDispatcherQueueHandler*)Unsafe.AsPointer(ref this));
-        }
+        uint Release();
     }
 }