Use SafeHandle to hold pointer to native delegates.

Author: kring

Reinterop~/CustomDelegateGenerator.cs

@@ -72,7 +72,7 @@ private void GenerateDelegate(CppGenerationContext context, GeneratedResult resu
                     """
                 ));
 
-            // A a C# delegate type that wraps a std::function, and arrange for
+            // A C# delegate type that wraps a std::function, and arrange for
             // the invoke and dispose to be implemented in C++.
             CSharpType csType = CSharpType.FromSymbol(context, item.Type);
 
@@ -88,7 +88,7 @@ private void GenerateDelegate(CppGenerationContext context, GeneratedResult resu
             string disposeCallbackName = $"{csType.GetFullyQualifiedNamespace().Replace(".", "_")}_{item.Type.Name}{genericTypeHash}_DisposeCallback";
 
             var invokeParameters = callbackParameters.Select(p => $"{p.CsType.GetFullyQualifiedName()} {p.Name}");
-            var invokeInteropParameters = new[] { "IntPtr callbackFunction" }.Concat(callbackParameters.Select(p => $"{p.CsType.AsInteropTypeParameter().GetFullyQualifiedName()} {p.Name}"));
+            var invokeInteropParameters = new[] { "ImplementationHandle callbackFunction" }.Concat(callbackParameters.Select(p => $"{p.CsType.AsInteropTypeParameter().GetFullyQualifiedName()} {p.Name}"));
             var callInvokeInteropParameters = new[] { "_callbackFunction" }.Concat(callbackParameters.Select(p => p.CsType.GetConversionToInteropType(p.Name)));
             var csReturnType = CSharpType.FromSymbol(context, invokeMethod.ReturnType);
 
@@ -109,31 +109,34 @@ private void GenerateDelegate(CppGenerationContext context, GeneratedResult resu
                     $$"""
                     private class {{csType.Name}}{{genericTypeHash}}NativeFunction : System.IDisposable
                     {
-                        private IntPtr _callbackFunction;
-
-                        public {{csType.Name}}{{genericTypeHash}}NativeFunction(IntPtr callbackFunction)
+                        internal class ImplementationHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
                         {
-                            _callbackFunction = callbackFunction;
-                        }
+                            public ImplementationHandle(IntPtr nativeImplementation) : base(true)
+                            {
+                                SetHandle(nativeImplementation);
+                            }
 
-                        ~{{csType.Name}}{{genericTypeHash}}NativeFunction()
-                        {
-                            Dispose(false);
+                            [System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)]
+                            protected override bool ReleaseHandle()
+                            {
+                                {{disposeCallbackName}}(this.handle);
+                                return true;
+                            }
                         }
-                    
-                        public void Dispose()
+
+                        [System.NonSerialized]
+                        private ImplementationHandle _callbackFunction;
+
+                        public {{csType.Name}}{{genericTypeHash}}NativeFunction(IntPtr callbackFunction)
                         {
-                            Dispose(true);
-                            GC.SuppressFinalize(this);
+                            _callbackFunction = new ImplementationHandle(callbackFunction);
                         }
 
-                        private void Dispose(bool disposing)
+                        public void Dispose()
                         {
-                            if (_callbackFunction != IntPtr.Zero)
-                            {
-                                {{disposeCallbackName}}(_callbackFunction);
-                                _callbackFunction = IntPtr.Zero;
-                            }
+                            if (this._callbackFunction != null && !this._callbackFunction.IsInvalid)
+                                this._callbackFunction.Dispose();
+                            this._callbackFunction = null;
                         }
 
                         public {{csReturnType.GetFullyQualifiedName()}} Invoke({{string.Join(", ", invokeParameters)}})