Add ref patcher method

BepInEx/Bootstrap/AssemblyPatcher.cs

@@ -7,7 +7,7 @@ using Mono.Cecil;
 
 namespace BepInEx.Bootstrap
 {
-    public delegate void AssemblyPatcherDelegate(AssemblyDefinition assembly);
+    public delegate void AssemblyPatcherDelegate(ref AssemblyDefinition assembly);
 
     public static class AssemblyPatcher
     {
@@ -57,46 +57,44 @@ namespace BepInEx.Bootstrap
             }
 
             //sort the assemblies so load the assemblies that are dependant upon first
-            IEnumerable<AssemblyDefinition> sortedAssemblies = Utility.TopologicalSort(assemblies, x => assemblyDependencyDict[x]);
+            AssemblyDefinition[] sortedAssemblies = Utility.TopologicalSort(assemblies, x => assemblyDependencyDict[x]).ToArray();
 
             //call the patchers on the assemblies
-            foreach (var assembly in sortedAssemblies)
+			for (int i = 0; i < sortedAssemblies.Length; i++)
-            {
+			{
-#if CECIL_10
+                string filename = Path.GetFileName(assemblyFilenames[sortedAssemblies[i]]);
-                using (assembly)
-#endif
-                {
-                    string filename = Path.GetFileName(assemblyFilenames[assembly]);
 
-                    //skip if we aren't patching it
+                //skip if we aren't patching it
-                    if (!patcherMethodDictionary.TryGetValue(filename, out IList<AssemblyPatcherDelegate> patcherMethods))
+                if (!patcherMethodDictionary.TryGetValue(filename, out IList<AssemblyPatcherDelegate> patcherMethods))
-                        continue;
+                    continue;
 
-                    Patch(assembly, patcherMethods);
+                Patch(ref sortedAssemblies[i], patcherMethods);
 
-                    if (DumpingEnabled)
+                if (DumpingEnabled)
+                {
+                    using (MemoryStream mem = new MemoryStream())
                     {
-                        using (MemoryStream mem = new MemoryStream())
+                        string dirPath = Path.Combine(Preloader.PluginPath, "DumpedAssemblies");
-                        {
-                            string dirPath = Path.Combine(Preloader.PluginPath, "DumpedAssemblies");
 
-                            if (!Directory.Exists(dirPath))
+                        if (!Directory.Exists(dirPath))
-                                Directory.CreateDirectory(dirPath);
+                            Directory.CreateDirectory(dirPath);
                             
-                            assembly.Write(mem);
+	                    sortedAssemblies[i].Write(mem);
-                            File.WriteAllBytes(Path.Combine(dirPath, filename), mem.ToArray());
+                        File.WriteAllBytes(Path.Combine(dirPath, filename), mem.ToArray());
-                        }
                     }
                 }
+#if CECIL_10
+				sortedAssemblies[i].Dispose();
+#endif
             }
         }
 
-        public static void Patch(AssemblyDefinition assembly, IEnumerable<AssemblyPatcherDelegate> patcherMethods)
+        public static void Patch(ref AssemblyDefinition assembly, IEnumerable<AssemblyPatcherDelegate> patcherMethods)
         {
             using (MemoryStream assemblyStream = new MemoryStream())
             {
                 foreach (AssemblyPatcherDelegate method in patcherMethods)
-                    method.Invoke(assembly);
+                    method.Invoke(ref assembly);
 
                 assembly.Write(assemblyStream);
                 Assembly.Load(assemblyStream.ToArray());

BepInEx/Bootstrap/Preloader.cs

@@ -165,31 +165,51 @@ namespace BepInEx.Bootstrap
 
             foreach (var type in assembly.GetExportedTypes())
             {
-                try
+	            try
-                {
+	            {
-                    if (type.IsInterface)
+		            if (type.IsInterface)
+			            continue;
+
+		            PropertyInfo targetsProperty = type.GetProperty(
+			            "TargetDLLs",
+			            BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase,
+			            null,
+			            typeof(IEnumerable<string>),
+			            Type.EmptyTypes,
+			            null);
+
+					//first try get the ref patcher method
+		            MethodInfo patcher = type.GetMethod(
+			            "Patch",
+			            BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase,
+			            null,
+			            CallingConventions.Any,
+			            new[] {typeof(AssemblyDefinition).MakeByRefType()},
+			            null);
+
+		            if (patcher == null) //otherwise try getting the non-ref patcher method
+		            {
+			            patcher = type.GetMethod(
+				            "Patch",
+				            BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase,
+				            null,
+				            CallingConventions.Any,
+				            new[] {typeof(AssemblyDefinition)},
+				            null);
+		            }
+
+		            if (targetsProperty == null || !targetsProperty.CanRead || patcher == null)
                         continue;
 
-                    PropertyInfo targetsProperty = type.GetProperty(
+                    AssemblyPatcherDelegate patchDelegate = (ref AssemblyDefinition ass) =>
-                        "TargetDLLs", 
+                    {
-                        BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase,
+						//we do the array fuckery here to get the ref result out
-                        null,
+	                    object[] args = { ass };
-                        typeof(IEnumerable<string>),
+
-                        Type.EmptyTypes,
+	                    patcher.Invoke(null, args);
-                        null);
-
-                    MethodInfo patcher = type.GetMethod(
-                        "Patch", 
-                        BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase,
-                        null,
-                        CallingConventions.Any,
-                        new[] { typeof(AssemblyDefinition) },
-                        null);
-
-                    if (targetsProperty == null || !targetsProperty.CanRead || patcher == null)
-                        continue;
 
-                    AssemblyPatcherDelegate patchDelegate = (ass) => { patcher.Invoke(null, new object[] {ass}); };
+	                    ass = (AssemblyDefinition)args[0];
+                    };
 
                     IEnumerable<string> targets = (IEnumerable<string>)targetsProperty.GetValue(null, null);
 
@@ -217,7 +237,7 @@ namespace BepInEx.Bootstrap
             return patcherMethods;
         }
 
-        internal static void PatchEntrypoint(AssemblyDefinition assembly)
+        internal static void PatchEntrypoint(ref AssemblyDefinition assembly)
         {
             if (assembly.Name.Name == "UnityEngine")
             {