[corlib] Remove ResourceCloseHandler usage

diff --git a/mcs/class/corlib/System.Reflection/Assembly.cs b/mcs/class/corlib/System.Reflection/Assembly.cs
index f1ba85efdd76de8d9cf04bf3c0715fb3d7515dcb..4e10838b10386e13bcb6475ed092b4aececc5700 100644 (file)
--- a/mcs/class/corlib/System.Reflection/Assembly.cs
+++ b/mcs/class/corlib/System.Reflection/Assembly.cs
@@ -58,6 +58,31 @@ namespace System.Reflection {
                        public event ModuleResolveEventHandler ModuleResolve;
                }
 
+               internal class UnmanagedMemoryStreamForModule : UnmanagedMemoryStream
+               {
+                       Module module;
+
+                       public unsafe UnmanagedMemoryStreamForModule (byte* pointer, long length, Module module)
+                               : base (pointer, length)
+                       {
+                               this.module = module;
+                       }
+
+                       protected override void Dispose (bool disposing)
+                       {
+                               if (_isOpen) {
+                                       /* 
+                                        * The returned pointer points inside metadata, so
+                                        * we have to increase the refcount of the module, and decrease
+                                        * it when the stream is finalized.
+                                        */
+                                       module = null;
+                               }
+
+                               base.Dispose (disposing);
+                       }
+               }
+
                // Note: changes to fields must be reflected in _MonoReflectionAssembly struct (object-internals.h)
 #pragma warning disable 649
                private IntPtr _mono_assembly;
@@ -304,14 +329,8 @@ namespace System.Reflection {
                        else {
                                UnmanagedMemoryStream stream;
                                unsafe {
-                                       stream = new UnmanagedMemoryStream ((byte*) data, size);
+                                       stream = new UnmanagedMemoryStreamForModule ((byte*) data, size, module);
                                }
-                               /* 
-                                * The returned pointer points inside metadata, so
-                                * we have to increase the refcount of the module, and decrease
-                                * it when the stream is finalized.
-                                */
-                               stream.Closed += new EventHandler (new ResourceCloseHandler (module).OnClose);
                                return stream;
                        }
                }
@@ -705,21 +724,6 @@ namespace System.Reflection {
                                return null;
                }
 
-               private class ResourceCloseHandler {
-#pragma warning disable 169, 414
-                       Module module;
-#pragma warning restore 169, 414                       
-
-                       public ResourceCloseHandler (Module module) {
-                               this.module = module;
-                       }
-
-                       public void OnClose (object sender, EventArgs e) {
-                               // The module dtor will take care of things
-                               module = null;
-                       }
-               }
-
                [MonoTODO ("Currently it always returns zero")]
                [ComVisible (false)]
                public

diff --git a/mcs/class/corlib/System.Resources/ResourceReader.cs b/mcs/class/corlib/System.Resources/ResourceReader.cs
index f73a8f8683d1cb581d5bb82119fffa9cc0706926..3bc3b47e51086571142d644c9860d830c59c4682 100644 (file)
--- a/mcs/class/corlib/System.Resources/ResourceReader.cs
+++ b/mcs/class/corlib/System.Resources/ResourceReader.cs
@@ -96,6 +96,26 @@ namespace System.Resources
                                ResourceValue = value;
                        }
                }
+
+               unsafe class HGlobalUnmanagedMemoryStream : UnmanagedMemoryStream
+               {
+                       IntPtr ptr;
+
+                       public HGlobalUnmanagedMemoryStream (byte* pointer, long length, IntPtr ptr)
+                               : base (pointer, length, length, FileAccess.ReadWrite)
+                       {
+                               this.ptr = ptr;
+                       }
+
+                       protected override void Dispose (bool disposing)
+                       {
+                               if (_isOpen) {
+                                       Marshal.FreeHGlobal (ptr);
+                               }
+
+                               base.Dispose (disposing);
+                       }
+               }
                
                BinaryReader reader;
                object readerLock = new object ();
@@ -448,12 +468,7 @@ namespace System.Resources
                                        } else {
                                                IntPtr ptr = Marshal.AllocHGlobal ((int) slen);
                                                byte* addr = (byte*) ptr.ToPointer ();
-                                               UnmanagedMemoryStream ms = new UnmanagedMemoryStream (addr, slen, slen, FileAccess.ReadWrite);
-                                               // The memory resource must be freed
-                                               // when the stream is disposed.
-                                               ms.Closed += delegate (object o, EventArgs e) {
-                                                       Marshal.FreeHGlobal (ptr);
-                                               };
+                                               UnmanagedMemoryStream ms = new HGlobalUnmanagedMemoryStream (addr, slen, ptr);
 
                                                byte [] bytes = new byte [slen < 1024 ? slen : 1024];
                                                while (slen > 0 ) {