Allocate on the heap and register that pointer

Author: ammeep

LibGit2Sharp/Core/NativeMethods.cs

@@ -507,7 +507,7 @@ internal static extern int git_diff_find_similar(
         [DllImport(libgit2)]
         internal static extern int git_filter_register(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string name,
-            ref GitFilter gitFilter, int priority);
+            IntPtr gitFilter, int priority);
 
         [DllImport(libgit2)]
         internal static extern int git_filter_unregister(

LibGit2Sharp/Core/Proxy.cs

@@ -741,18 +741,18 @@ public static GitDiffDelta git_diff_get_delta(DiffSafeHandle diff, int idx)
 
         #region git_filter_
 
-        public static GitFilter git_filter_register(string name, ref GitFilter filter, int priority)
+        public static void git_filter_register(string name, IntPtr filter, int priority)
         {
             using (ThreadAffinity())
             {
-                int res = NativeMethods.git_filter_register(name, ref filter, priority);
+                int res = NativeMethods.git_filter_register(name, filter, priority);
                 if (res == (int)GitErrorCode.Exists)
                 {
                     var message = string.Format("A filter with the name '{0}' is already registered.", name);
                     throw new InvalidOperationException(message);
                 }
                 Ensure.ZeroResult(res);
-                return filter;
+               // return filter;
             }
         }
 

LibGit2Sharp/Filter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.InteropServices;
 using System.Text;
 using LibGit2Sharp.Core;
 
@@ -9,45 +10,54 @@ namespace LibGit2Sharp
     /// </summary>
     public sealed class Filter
     {
-        private GitFilter filter;
-        private readonly string name;
+        private GitFilter managedFilter;
+        private IntPtr nativeFilter;
+
+        private readonly string filterName;
         private readonly string attributes;
         private readonly int version;
 
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Filter"/> class.
+        /// And allocates the filter natively. 
         /// </summary>
         public Filter(string name, string attributes, int version)
         {
             Ensure.ArgumentNotNullOrEmptyString(name, "name");
             Ensure.ArgumentNotNullOrEmptyString(attributes, "attributes");
             Ensure.ArgumentNotNull(version, "version");
 
-            this.name = name;
+            this.filterName = name;
             this.attributes = attributes;
             this.version = version;
-            filter = new GitFilter
+
+            managedFilter = new GitFilter
             {
                 attributes = EncodingMarshaler.FromManaged(Encoding.UTF8, attributes),
-                version =  (uint)version
+                version =  (uint)version,
+                shutdown = FilterCallbacks.ShutdownCallback,
             };
+
+            nativeFilter = Marshal.AllocHGlobal(Marshal.SizeOf(managedFilter));
+            Marshal.StructureToPtr(managedFilter, nativeFilter, false);
         }
 
         internal Filter(string name, IntPtr filterPtr)
         {
-            var handle = filterPtr.MarshalAs<GitFilter>();
-            this.name = name;
-            this.version = (int)handle.version;
-            this.attributes = LaxUtf8Marshaler.FromNative(handle.attributes);
+            nativeFilter = filterPtr;
+            managedFilter = nativeFilter.MarshalAs<GitFilter>();
+            filterName = name;
+            attributes = EncodingMarshaler.FromNative(Encoding.UTF8, this.managedFilter.attributes);
+            version = (int) managedFilter.version;
         }
 
-
         /// <summary>
         /// The name that this filter was registered with
         /// </summary>
         public string Name
         {
-            get { return name; }
+            get { return filterName; }
         }
 
         /// <summary>
@@ -71,15 +81,30 @@ public int Version
         /// </summary>
         public void Register()
         {
-            filter = Proxy.git_filter_register(name, ref filter, 1);
+           Proxy.git_filter_register(filterName, nativeFilter, 1);
         }
 
         /// <summary>
-        /// Remove the filter from the registry.
+        /// Remove the filter from the registry, and frees the native heap allocation.
         /// </summary>
         public void Deregister()
         {
             Proxy.git_filter_unregister(Name);
+            Marshal.FreeHGlobal(nativeFilter);
+        }
+
+        private static class FilterCallbacks
+        {
+            // Because our GitFilter structure exists on the managed heap only for a short time (to be marshaled
+            // to native memory with StructureToPtr), we need to bind to static delegates. If at construction time
+            // we were to bind to the methods directly, that's the same as newing up a fresh delegate every time.
+            // Those delegates won't be rooted in the object graph and can be collected as soon as StructureToPtr finishes.
+            public static readonly GitFilter.git_filter_shutdown_fn ShutdownCallback = Shutdown;
+
+            private static void Shutdown(IntPtr gitFilter)
+            {
+                Console.WriteLine("Shut down mother fucker");
+            }
         }
     }