Update various files

scorteanucosmin · MrBlue · commit b8bdc89b72ef · 2026-02-20T01:43:39.000+01:00
diff --git a/src/Libraries/Permission.cs b/src/Libraries/Permission.cs
@@ -155,9 +155,8 @@ private void VerifyAndLoadUsersData()
 
                 user.Groups = new HashSet<string>(groups, StringComparer.OrdinalIgnoreCase);
 
-                if (result.ContainsKey(entry.Key))
+                if (result.TryGetValue(entry.Key, out UserData? existing))
                 {
-                    UserData existing = result[entry.Key];
                     existing.Perms.UnionWith(user.Perms);
                     existing.Groups.UnionWith(user.Groups);
 
@@ -199,9 +198,8 @@ private void VerifyAndLoadGroupsData()
 
                 group.Perms = new HashSet<string>(permissions, StringComparer.OrdinalIgnoreCase);
 
-                if (result.ContainsKey(entry.Key))
+                if (result.TryGetValue(entry.Key, out GroupData? existing))
                 {
-                    GroupData existing = result[entry.Key];
                     existing.Perms.UnionWith(group.Perms);
                     changed = true;
 
@@ -236,11 +234,10 @@ private Dictionary<string, GroupData> VerifyGroupData(Dictionary<string, GroupDa
 
                 group.Perms = new HashSet<string>(permissions, StringComparer.OrdinalIgnoreCase);
 
-                if (result.ContainsKey(entry.Key))
+                if (result.TryGetValue(entry.Key, out GroupData? existing))
                 {
-                    GroupData existing = result[entry.Key];
                     // Get a matching entry.key from result.keys
-                    var existingKey = result.Keys.FirstOrDefault(x => x.Equals(entry.Key, StringComparison.OrdinalIgnoreCase));
+                    string? existingKey = result.Keys.FirstOrDefault(x => x.Equals(entry.Key, StringComparison.OrdinalIgnoreCase));
 
                     existing.Perms.UnionWith(group.Perms);
 
diff --git a/src/Plugins/CSPlugin.cs b/src/Plugins/CSPlugin.cs
@@ -129,9 +129,9 @@ public override void HandleAddedToManager(PluginManager manager)
             base.HandleAddedToManager(manager);
 
             // Subscribe us
-            foreach (string hookname in Hooks.Keys)
+            foreach (string hookName in Hooks.Keys)
             {
-                Subscribe(hookname);
+                Subscribe(hookName);
             }
 
             try
@@ -149,8 +149,13 @@ public override void HandleAddedToManager(PluginManager manager)
             }
 
             // Find all classes with the AutoPatch attribute and apply the patches
-            foreach (Type nestedType in GetType().GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
+            Type[] nestedTypes = GetType().GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Public |
+                                                          BindingFlags.NonPublic | BindingFlags.Static);
+
+            int nestedTypeCount = nestedTypes.Length;
+            for (int i = 0; i < nestedTypeCount; i++)
             {
+                Type nestedType = nestedTypes[i];
                 object[] attr = nestedType.GetCustomAttributes(typeof(AutoPatchAttribute), false);
                 if (attr.Length < 1)
                 {
@@ -159,22 +164,26 @@ public override void HandleAddedToManager(PluginManager manager)
 
                 try
                 {
-                    List<MethodInfo> harmonyMethods = HarmonyInstance.CreateClassProcessor(nestedType)?.Patch();
-
+                    List<MethodInfo>? harmonyMethods = HarmonyInstance.CreateClassProcessor(nestedType)?.Patch();
                     if (harmonyMethods == null || harmonyMethods.Count == 0)
                     {
-                        Interface.Oxide.LogWarning($"[{Title}] AutoPatch attribute found on '{nestedType.Name}' but no HarmonyPatch methods found. Skipping.");
+                        Interface.Oxide.LogWarning(
+                            $"[{Title}] AutoPatch attribute found on '{nestedType.Name}' but no HarmonyPatch methods found. Skipping.");
                         continue;
                     }
 
-                    foreach (MethodInfo method in harmonyMethods)
+                    int harmonyMethodCount = harmonyMethods.Count;
+                    for (int j = 0; j < harmonyMethodCount; j++)
                     {
-                        Interface.Oxide.LogInfo($"[{Title}] Automatically Harmony patched '{method?.Name ?? "unknown"}' method. ({nestedType.Name})");
+                        MethodInfo harmonyMethod = harmonyMethods[j];
+                        Interface.Oxide.LogInfo(
+                            $"[{Title}] Automatically Harmony patched '{harmonyMethod?.Name ?? "unknown"}' method. ({nestedType.Name})");
                     }
                 }
                 catch (Exception ex)
                 {
-                    Interface.Oxide.LogException($"[{Title}] Failed to automatically Harmony patch '{nestedType.Name}'", ex);
+                    Interface.Oxide.LogException($"[{Title}] Failed to automatically Harmony patch '{nestedType.Name}'",
+                        ex);
                 }
             }
         }
@@ -211,19 +220,22 @@ protected void AddHookMethod(string name, MethodInfo method)
         /// <returns></returns>
         protected sealed override object OnCallHook(string name, object[] args)
         {
-            object returnvalue = null;
+            object returnValue = null;
             bool pooledArray = false;
 
             // Call all hooks that match the signature
-            foreach (HookMethod h in FindHooks(name, args))
+            List<HookMethod> hookMethods = FindHooks(name, args);
+            int hookMethodCount = hookMethods.Count;
+            for (int i = 0; i < hookMethodCount; i++)
             {
+                HookMethod hookMethod = hookMethods[i];
                 int received = args?.Length ?? 0;
                 object[] hookArgs;
 
-                if (received != h.Parameters.Length)
+                if (received != hookMethod.Parameters.Length)
                 {
                     // The call argument count is different to the declared callback methods argument count
-                    hookArgs = ObjectArrayPool.Take(h.Parameters.Length);
+                    hookArgs = ObjectArrayPool.Take(hookMethod.Parameters.Length);
                     pooledArray = true;
 
                     if (received > 0 && hookArgs.Length > 0)
@@ -237,7 +249,7 @@ protected sealed override object OnCallHook(string name, object[] args)
                         // Create additional parameters for arguments excluded in this hook call
                         for (int n = received; n < hookArgs.Length; n++)
                         {
-                            ParameterInfo parameter = h.Parameters[n];
+                            ParameterInfo parameter = hookMethod.Parameters[n];
                             if (parameter.DefaultValue != null && parameter.DefaultValue != DBNull.Value)
                             {
                                 // Use the default value that was provided by the method definition
@@ -258,7 +270,7 @@ protected sealed override object OnCallHook(string name, object[] args)
 
                 try
                 {
-                    returnvalue = InvokeMethod(h, hookArgs);
+                    returnValue = InvokeMethod(hookMethod, hookArgs);
                 }
                 catch (TargetInvocationException exception)
                 {
@@ -276,13 +288,13 @@ protected sealed override object OnCallHook(string name, object[] args)
                     throw;
                 }
 
-                if (received != h.Parameters.Length)
+                if (received != hookMethod.Parameters.Length)
                 {
                     // A copy of the call arguments was used for this method call
-                    for (int n = 0; n < h.Parameters.Length; n++)
+                    for (int n = 0; n < hookMethod.Parameters.Length; n++)
                     {
                         // Copy output values for out and by reference arguments back to the calling args
-                        if (h.Parameters[n].IsOut || h.Parameters[n].ParameterType.IsByRef)
+                        if (hookMethod.Parameters[n].IsOut || hookMethod.Parameters[n].ParameterType.IsByRef)
                         {
                             args[n] = hookArgs[n];
                         }
@@ -295,22 +307,23 @@ protected sealed override object OnCallHook(string name, object[] args)
                 }
             }
 
-            return returnvalue;
+            return returnValue;
         }
 
         protected List<HookMethod> FindHooks(string name, object[] args)
         {
             // Get the full name of the hook `name(argument type 1, argument type 2, ..., argument type x)`
 
             // Check the cache if we already found a match for this hook
-            List<HookMethod> methods = HooksCache.GetHookMethod(name, args, out HookCache cache);
-            if (methods != null)
+            List<HookMethod> hookMethods = HooksCache.GetHookMethod(name, args, out HookCache cache);
+            if (hookMethods != null)
             {
-                return methods;
+                return hookMethods;
             }
+
             List<HookMethod> matches = new List<HookMethod>();
             // Get all hook methods that could match, return an empty list if none match
-            if (!Hooks.TryGetValue(name, out methods))
+            if (!Hooks.TryGetValue(name, out hookMethods))
             {
                 return matches;
             }
@@ -319,13 +332,15 @@ protected List<HookMethod> FindHooks(string name, object[] args)
             HookMethod exactMatch = null;
             HookMethod overloadedMatch = null;
 
-            foreach (HookMethod h in methods)
+            int hookMethodCount = hookMethods.Count;
+            for (int i = 0; i < hookMethodCount; i++)
             {
+                HookMethod hookMethod = hookMethods[i];
                 // A base hook should always have a matching signature either directly or through inheritance
                 // and should always be called as core functionality depends on it.
-                if (h.IsBaseHook)
+                if (hookMethod.IsBaseHook)
                 {
-                    matches.Add(h);
+                    matches.Add(hookMethod);
                     continue;
                 }
 
@@ -335,10 +350,10 @@ protected List<HookMethod> FindHooks(string name, object[] args)
 
                 bool pooledArray = false;
 
-                if (received != h.Parameters.Length)
+                if (received != hookMethod.Parameters.Length)
                 {
                     // The call argument count is different to the declared callback methods argument count
-                    hookArgs = ObjectArrayPool.Take(h.Parameters.Length);
+                    hookArgs = ObjectArrayPool.Take(hookMethod.Parameters.Length);
                     pooledArray = true;
 
                     if (received > 0 && hookArgs.Length > 0)
@@ -352,7 +367,7 @@ protected List<HookMethod> FindHooks(string name, object[] args)
                         // Create additional parameters for arguments excluded in this hook call
                         for (int n = received; n < hookArgs.Length; n++)
                         {
-                            ParameterInfo parameter = h.Parameters[n];
+                            ParameterInfo parameter = hookMethod.Parameters[n];
                             if (parameter.DefaultValue != null && parameter.DefaultValue != DBNull.Value)
                             {
                                 // Use the default value that was provided by the method definition
@@ -371,16 +386,16 @@ protected List<HookMethod> FindHooks(string name, object[] args)
                     hookArgs = args;
                 }
 
-                if (h.HasMatchingSignature(hookArgs, out bool isExactMatch))
+                if (hookMethod.HasMatchingSignature(hookArgs, out bool isExactMatch))
                 {
                     if (isExactMatch)
                     {
-                        exactMatch = h;
+                        exactMatch = hookMethod;
                         break;
                     }
 
                     // Should we determine the level and call the closest overloaded match? Performance impact?
-                    overloadedMatch = h;
+                    overloadedMatch = hookMethod;
                 }
 
                 if (pooledArray)
diff --git a/src/Plugins/HookCache.cs b/src/Plugins/HookCache.cs
@@ -30,7 +30,8 @@ public List<HookMethod> GetHookMethod(object[] args, int index, out HookCache ca
             }
 
             HookCache nextCache;
-            if (args[index] == null)
+            object arg = args[index];
+            if (arg == null)
             {
                 if (!_cache.TryGetValue(NullKey, out nextCache))
                 {
@@ -40,12 +41,14 @@ public List<HookMethod> GetHookMethod(object[] args, int index, out HookCache ca
             }
             else
             {
-                if (!_cache.TryGetValue(args[index].GetType().FullName, out nextCache))
+                string fullName = arg.GetType().FullName;
+                if (!_cache.TryGetValue(fullName, out nextCache))
                 {
                     nextCache = new HookCache();
-                    _cache.Add(args[index].GetType().FullName, nextCache);
+                    _cache.Add(fullName, nextCache);
                 }
             }
+
             //Interface.Oxide.ServerConsole.AddMessage($"GetHookMethod {key} {index}");
             return nextCache.GetHookMethod(args, index + 1, out cache);
         }
diff --git a/src/Plugins/PluginManager.cs b/src/Plugins/PluginManager.cs
@@ -117,13 +117,11 @@ public bool AddPlugin(Plugin plugin)
         /// <returns></returns>
         public bool RemovePlugin(Plugin plugin)
         {
-            if (!loadedPlugins.ContainsKey(plugin.Name))
+            if (!loadedPlugins.Remove(plugin.Name))
             {
                 return false;
             }
 
-            loadedPlugins.Remove(plugin.Name);
-
             lock (hookSubscriptions)
             {
                 foreach (HookSubscriptions sub in hookSubscriptions.Values)
@@ -295,27 +293,29 @@ public object CallHook(string hook, params object[] args)
                             continue;
                         }
 
-                        if (value.GetType().IsValueType)
+                        Type valueType = value.GetType();
+                        if (valueType.IsValueType)
                         {
-                            if (!values[i].Equals(finalValue))
+                            if (!value.Equals(finalValue))
                             {
-                                hookConflicts.Add($"{plugin.Name} - {value} ({value.GetType().Name})");
+                                hookConflicts.Add($"{plugin.Name} - {value} ({valueType.Name})");
                             }
                         }
                         else
                         {
-                            if (values[i] != finalValue)
+                            if (value != finalValue)
                             {
-                                hookConflicts.Add($"{plugin.Name} - {value} ({value.GetType().Name})");
+                                hookConflicts.Add($"{plugin.Name} - {value} ({valueType.Name})");
                             }
                         }
                     }
                     if (hookConflicts.Count > 0)
                     {
                         hookConflicts.Add($"{finalPlugin.Name} ({finalValue} ({finalValue.GetType().Name}))");
-                        Logger.Write(LogType.Warning, "Calling hook {0} resulted in a conflict between the following plugins: {1}", hook, string.Join(", ", hookConflicts.ToArray()));
+                        Logger.Write(LogType.Warning, "Calling hook {0} resulted in a conflict between the following plugins: {1}", hook, hookConflicts.JoinValues(", "));
                     }
                 }
+
                 ObjectPool.Return(values);
             }
             finally
@@ -381,7 +381,7 @@ public object CallDeprecatedHook(string oldHook, string newHook, DateTime expire
             {
                 // TODO: Add better handling
                 lastDeprecatedWarningAt[oldHook] = now;
-                Interface.Oxide.LogWarning($"'{subscriptions.Plugins[0].Name} v{subscriptions.Plugins[0].Version}' is using deprecated hook '{oldHook}', which will stop working on {expireDate.ToString("D")}. Please ask the author to update to '{newHook}'");
+                Interface.Oxide.LogWarning($"'{subscriptions.Plugins[0].Name} v{subscriptions.Plugins[0].Version}' is using deprecated hook '{oldHook}', which will stop working on {expireDate:D}. Please ask the author to update to '{newHook}'");
             }
 
             return CallHook(oldHook, args);

Original file line number	Diff line number	Diff line change
`@@ -129,9 +129,9 @@ public override void HandleAddedToManager(PluginManager manager)`
`129`	`129`	`base.HandleAddedToManager(manager);`
`130`	`130`
`131`	`131`	`// Subscribe us`
`132`		`- foreach (string hookname in Hooks.Keys)`
	`132`	`+ foreach (string hookName in Hooks.Keys)`
`133`	`133`	`{`
`134`		`- Subscribe(hookname);`
	`134`	`+ Subscribe(hookName);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`try`
`@@ -149,8 +149,13 @@ public override void HandleAddedToManager(PluginManager manager)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`// Find all classes with the AutoPatch attribute and apply the patches`
`152`		`- foreach (Type nestedType in GetType().GetNestedTypes(BindingFlags.DeclaredOnly \| BindingFlags.Public \| BindingFlags.NonPublic \| BindingFlags.Static))`
	`152`	`+ Type[] nestedTypes = GetType().GetNestedTypes(BindingFlags.DeclaredOnly \| BindingFlags.Public \|`
	`153`	`+ BindingFlags.NonPublic \| BindingFlags.Static);`
	`154`	`+`
	`155`	`+ int nestedTypeCount = nestedTypes.Length;`
	`156`	`+ for (int i = 0; i < nestedTypeCount; i++)`
`153`	`157`	`{`
	`158`	`+ Type nestedType = nestedTypes[i];`
`154`	`159`	`object[] attr = nestedType.GetCustomAttributes(typeof(AutoPatchAttribute), false);`
`155`	`160`	`if (attr.Length < 1)`
`156`	`161`	`{`
`@@ -159,22 +164,26 @@ public override void HandleAddedToManager(PluginManager manager)`
`159`	`164`
`160`	`165`	`try`
`161`	`166`	`{`
`162`		`- List<MethodInfo> harmonyMethods = HarmonyInstance.CreateClassProcessor(nestedType)?.Patch();`
`163`		`-`
	`167`	`+ List<MethodInfo>? harmonyMethods = HarmonyInstance.CreateClassProcessor(nestedType)?.Patch();`
`164`	`168`	`if (harmonyMethods == null \|\| harmonyMethods.Count == 0)`
`165`	`169`	`{`
`166`		`- Interface.Oxide.LogWarning($"[{Title}] AutoPatch attribute found on '{nestedType.Name}' but no HarmonyPatch methods found. Skipping.");`
	`170`	`+ Interface.Oxide.LogWarning(`
	`171`	`+ $"[{Title}] AutoPatch attribute found on '{nestedType.Name}' but no HarmonyPatch methods found. Skipping.");`
`167`	`172`	`continue;`
`168`	`173`	`}`
`169`	`174`
`170`		`- foreach (MethodInfo method in harmonyMethods)`
	`175`	`+ int harmonyMethodCount = harmonyMethods.Count;`
	`176`	`+ for (int j = 0; j < harmonyMethodCount; j++)`
`171`	`177`	`{`
`172`		`- Interface.Oxide.LogInfo($"[{Title}] Automatically Harmony patched '{method?.Name ?? "unknown"}' method. ({nestedType.Name})");`
	`178`	`+ MethodInfo harmonyMethod = harmonyMethods[j];`
	`179`	`+ Interface.Oxide.LogInfo(`
	`180`	`+ $"[{Title}] Automatically Harmony patched '{harmonyMethod?.Name ?? "unknown"}' method. ({nestedType.Name})");`
`173`	`181`	`}`
`174`	`182`	`}`
`175`	`183`	`catch (Exception ex)`
`176`	`184`	`{`
`177`		`- Interface.Oxide.LogException($"[{Title}] Failed to automatically Harmony patch '{nestedType.Name}'", ex);`
	`185`	`+ Interface.Oxide.LogException($"[{Title}] Failed to automatically Harmony patch '{nestedType.Name}'",`
	`186`	`+ ex);`
`178`	`187`	`}`
`179`	`188`	`}`
`180`	`189`	`}`
`@@ -211,19 +220,22 @@ protected void AddHookMethod(string name, MethodInfo method)`
`211`	`220`	`/// <returns></returns>`
`212`	`221`	`protected sealed override object OnCallHook(string name, object[] args)`
`213`	`222`	`{`
`214`		`- object returnvalue = null;`
	`223`	`+ object returnValue = null;`
`215`	`224`	`bool pooledArray = false;`
`216`	`225`
`217`	`226`	`// Call all hooks that match the signature`
`218`		`- foreach (HookMethod h in FindHooks(name, args))`
	`227`	`+ List<HookMethod> hookMethods = FindHooks(name, args);`
	`228`	`+ int hookMethodCount = hookMethods.Count;`
	`229`	`+ for (int i = 0; i < hookMethodCount; i++)`
`219`	`230`	`{`
	`231`	`+ HookMethod hookMethod = hookMethods[i];`
`220`	`232`	`int received = args?.Length ?? 0;`
`221`	`233`	`object[] hookArgs;`
`222`	`234`
`223`		`- if (received != h.Parameters.Length)`
	`235`	`+ if (received != hookMethod.Parameters.Length)`
`224`	`236`	`{`
`225`	`237`	`// The call argument count is different to the declared callback methods argument count`
`226`		`- hookArgs = ObjectArrayPool.Take(h.Parameters.Length);`
	`238`	`+ hookArgs = ObjectArrayPool.Take(hookMethod.Parameters.Length);`
`227`	`239`	`pooledArray = true;`
`228`	`240`
`229`	`241`	`if (received > 0 && hookArgs.Length > 0)`
`@@ -237,7 +249,7 @@ protected sealed override object OnCallHook(string name, object[] args)`
`237`	`249`	`// Create additional parameters for arguments excluded in this hook call`
`238`	`250`	`for (int n = received; n < hookArgs.Length; n++)`
`239`	`251`	`{`
`240`		`- ParameterInfo parameter = h.Parameters[n];`
	`252`	`+ ParameterInfo parameter = hookMethod.Parameters[n];`
`241`	`253`	`if (parameter.DefaultValue != null && parameter.DefaultValue != DBNull.Value)`
`242`	`254`	`{`
`243`	`255`	`// Use the default value that was provided by the method definition`
`@@ -258,7 +270,7 @@ protected sealed override object OnCallHook(string name, object[] args)`
`258`	`270`
`259`	`271`	`try`
`260`	`272`	`{`
`261`		`- returnvalue = InvokeMethod(h, hookArgs);`
	`273`	`+ returnValue = InvokeMethod(hookMethod, hookArgs);`
`262`	`274`	`}`
`263`	`275`	`catch (TargetInvocationException exception)`
`264`	`276`	`{`
`@@ -276,13 +288,13 @@ protected sealed override object OnCallHook(string name, object[] args)`
`276`	`288`	`throw;`
`277`	`289`	`}`
`278`	`290`
`279`		`- if (received != h.Parameters.Length)`
	`291`	`+ if (received != hookMethod.Parameters.Length)`
`280`	`292`	`{`
`281`	`293`	`// A copy of the call arguments was used for this method call`
`282`		`- for (int n = 0; n < h.Parameters.Length; n++)`
	`294`	`+ for (int n = 0; n < hookMethod.Parameters.Length; n++)`
`283`	`295`	`{`
`284`	`296`	`// Copy output values for out and by reference arguments back to the calling args`
`285`		`- if (h.Parameters[n].IsOut \|\| h.Parameters[n].ParameterType.IsByRef)`
	`297`	`+ if (hookMethod.Parameters[n].IsOut \|\| hookMethod.Parameters[n].ParameterType.IsByRef)`
`286`	`298`	`{`
`287`	`299`	`args[n] = hookArgs[n];`
`288`	`300`	`}`
`@@ -295,22 +307,23 @@ protected sealed override object OnCallHook(string name, object[] args)`
`295`	`307`	`}`
`296`	`308`	`}`
`297`	`309`
`298`		`- return returnvalue;`
	`310`	`+ return returnValue;`
`299`	`311`	`}`
`300`	`312`
`301`	`313`	`protected List<HookMethod> FindHooks(string name, object[] args)`
`302`	`314`	`{`
`303`	`315`	// Get the full name of the hook `name(argument type 1, argument type 2, ..., argument type x)`
`304`	`316`
`305`	`317`	`// Check the cache if we already found a match for this hook`
`306`		`- List<HookMethod> methods = HooksCache.GetHookMethod(name, args, out HookCache cache);`
`307`		`- if (methods != null)`
	`318`	`+ List<HookMethod> hookMethods = HooksCache.GetHookMethod(name, args, out HookCache cache);`
	`319`	`+ if (hookMethods != null)`
`308`	`320`	`{`
`309`		`- return methods;`
	`321`	`+ return hookMethods;`
`310`	`322`	`}`
	`323`	`+`
`311`	`324`	`List<HookMethod> matches = new List<HookMethod>();`
`312`	`325`	`// Get all hook methods that could match, return an empty list if none match`
`313`		`- if (!Hooks.TryGetValue(name, out methods))`
	`326`	`+ if (!Hooks.TryGetValue(name, out hookMethods))`
`314`	`327`	`{`
`315`	`328`	`return matches;`
`316`	`329`	`}`
`@@ -319,13 +332,15 @@ protected List<HookMethod> FindHooks(string name, object[] args)`
`319`	`332`	`HookMethod exactMatch = null;`
`320`	`333`	`HookMethod overloadedMatch = null;`
`321`	`334`
`322`		`- foreach (HookMethod h in methods)`
	`335`	`+ int hookMethodCount = hookMethods.Count;`
	`336`	`+ for (int i = 0; i < hookMethodCount; i++)`
`323`	`337`	`{`
	`338`	`+ HookMethod hookMethod = hookMethods[i];`
`324`	`339`	`// A base hook should always have a matching signature either directly or through inheritance`
`325`	`340`	`// and should always be called as core functionality depends on it.`
`326`		`- if (h.IsBaseHook)`
	`341`	`+ if (hookMethod.IsBaseHook)`
`327`	`342`	`{`
`328`		`- matches.Add(h);`
	`343`	`+ matches.Add(hookMethod);`
`329`	`344`	`continue;`
`330`	`345`	`}`
`331`	`346`
`@@ -335,10 +350,10 @@ protected List<HookMethod> FindHooks(string name, object[] args)`
`335`	`350`
`336`	`351`	`bool pooledArray = false;`
`337`	`352`
`338`		`- if (received != h.Parameters.Length)`
	`353`	`+ if (received != hookMethod.Parameters.Length)`
`339`	`354`	`{`
`340`	`355`	`// The call argument count is different to the declared callback methods argument count`
`341`		`- hookArgs = ObjectArrayPool.Take(h.Parameters.Length);`
	`356`	`+ hookArgs = ObjectArrayPool.Take(hookMethod.Parameters.Length);`
`342`	`357`	`pooledArray = true;`
`343`	`358`
`344`	`359`	`if (received > 0 && hookArgs.Length > 0)`
`@@ -352,7 +367,7 @@ protected List<HookMethod> FindHooks(string name, object[] args)`
`352`	`367`	`// Create additional parameters for arguments excluded in this hook call`
`353`	`368`	`for (int n = received; n < hookArgs.Length; n++)`
`354`	`369`	`{`
`355`		`- ParameterInfo parameter = h.Parameters[n];`
	`370`	`+ ParameterInfo parameter = hookMethod.Parameters[n];`
`356`	`371`	`if (parameter.DefaultValue != null && parameter.DefaultValue != DBNull.Value)`
`357`	`372`	`{`
`358`	`373`	`// Use the default value that was provided by the method definition`
`@@ -371,16 +386,16 @@ protected List<HookMethod> FindHooks(string name, object[] args)`
`371`	`386`	`hookArgs = args;`
`372`	`387`	`}`
`373`	`388`
`374`		`- if (h.HasMatchingSignature(hookArgs, out bool isExactMatch))`
	`389`	`+ if (hookMethod.HasMatchingSignature(hookArgs, out bool isExactMatch))`
`375`	`390`	`{`
`376`	`391`	`if (isExactMatch)`
`377`	`392`	`{`
`378`		`- exactMatch = h;`
	`393`	`+ exactMatch = hookMethod;`
`379`	`394`	`break;`
`380`	`395`	`}`
`381`	`396`
`382`	`397`	`// Should we determine the level and call the closest overloaded match? Performance impact?`
`383`		`- overloadedMatch = h;`
	`398`	`+ overloadedMatch = hookMethod;`
`384`	`399`	`}`
`385`	`400`
`386`	`401`	`if (pooledArray)`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,8 @@ public List<HookMethod> GetHookMethod(object[] args, int index, out HookCache ca`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`HookCache nextCache;`
`33`		`- if (args[index] == null)`
	`33`	`+ object arg = args[index];`
	`34`	`+ if (arg == null)`
`34`	`35`	`{`
`35`	`36`	`if (!_cache.TryGetValue(NullKey, out nextCache))`
`36`	`37`	`{`
`@@ -40,12 +41,14 @@ public List<HookMethod> GetHookMethod(object[] args, int index, out HookCache ca`
`40`	`41`	`}`
`41`	`42`	`else`
`42`	`43`	`{`
`43`		`- if (!_cache.TryGetValue(args[index].GetType().FullName, out nextCache))`
	`44`	`+ string fullName = arg.GetType().FullName;`
	`45`	`+ if (!_cache.TryGetValue(fullName, out nextCache))`
`44`	`46`	`{`
`45`	`47`	`nextCache = new HookCache();`
`46`		`- _cache.Add(args[index].GetType().FullName, nextCache);`
	`48`	`+ _cache.Add(fullName, nextCache);`
`47`	`49`	`}`
`48`	`50`	`}`
	`51`	`+`
`49`	`52`	`//Interface.Oxide.ServerConsole.AddMessage($"GetHookMethod {key} {index}");`
`50`	`53`	`return nextCache.GetHookMethod(args, index + 1, out cache);`
`51`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,13 +117,11 @@ public bool AddPlugin(Plugin plugin)`
`117`	`117`	`/// <returns></returns>`
`118`	`118`	`public bool RemovePlugin(Plugin plugin)`
`119`	`119`	`{`
`120`		`- if (!loadedPlugins.ContainsKey(plugin.Name))`
	`120`	`+ if (!loadedPlugins.Remove(plugin.Name))`
`121`	`121`	`{`
`122`	`122`	`return false;`
`123`	`123`	`}`
`124`	`124`
`125`		`- loadedPlugins.Remove(plugin.Name);`
`126`		`-`
`127`	`125`	`lock (hookSubscriptions)`
`128`	`126`	`{`
`129`	`127`	`foreach (HookSubscriptions sub in hookSubscriptions.Values)`
`@@ -295,27 +293,29 @@ public object CallHook(string hook, params object[] args)`
`295`	`293`	`continue;`
`296`	`294`	`}`
`297`	`295`
`298`		`- if (value.GetType().IsValueType)`
	`296`	`+ Type valueType = value.GetType();`
	`297`	`+ if (valueType.IsValueType)`
`299`	`298`	`{`
`300`		`- if (!values[i].Equals(finalValue))`
	`299`	`+ if (!value.Equals(finalValue))`
`301`	`300`	`{`
`302`		`- hookConflicts.Add($"{plugin.Name} - {value} ({value.GetType().Name})");`
	`301`	`+ hookConflicts.Add($"{plugin.Name} - {value} ({valueType.Name})");`
`303`	`302`	`}`
`304`	`303`	`}`
`305`	`304`	`else`
`306`	`305`	`{`
`307`		`- if (values[i] != finalValue)`
	`306`	`+ if (value != finalValue)`
`308`	`307`	`{`
`309`		`- hookConflicts.Add($"{plugin.Name} - {value} ({value.GetType().Name})");`
	`308`	`+ hookConflicts.Add($"{plugin.Name} - {value} ({valueType.Name})");`
`310`	`309`	`}`
`311`	`310`	`}`
`312`	`311`	`}`
`313`	`312`	`if (hookConflicts.Count > 0)`
`314`	`313`	`{`
`315`	`314`	`hookConflicts.Add($"{finalPlugin.Name} ({finalValue} ({finalValue.GetType().Name}))");`
`316`		`- Logger.Write(LogType.Warning, "Calling hook {0} resulted in a conflict between the following plugins: {1}", hook, string.Join(", ", hookConflicts.ToArray()));`
	`315`	`+ Logger.Write(LogType.Warning, "Calling hook {0} resulted in a conflict between the following plugins: {1}", hook, hookConflicts.JoinValues(", "));`
`317`	`316`	`}`
`318`	`317`	`}`
	`318`	`+`
`319`	`319`	`ObjectPool.Return(values);`
`320`	`320`	`}`
`321`	`321`	`finally`
`@@ -381,7 +381,7 @@ public object CallDeprecatedHook(string oldHook, string newHook, DateTime expire`
`381`	`381`	`{`
`382`	`382`	`// TODO: Add better handling`
`383`	`383`	`lastDeprecatedWarningAt[oldHook] = now;`
`384`		`- Interface.Oxide.LogWarning($"'{subscriptions.Plugins[0].Name} v{subscriptions.Plugins[0].Version}' is using deprecated hook '{oldHook}', which will stop working on {expireDate.ToString("D")}. Please ask the author to update to '{newHook}'");`
	`384`	`+ Interface.Oxide.LogWarning($"'{subscriptions.Plugins[0].Name} v{subscriptions.Plugins[0].Version}' is using deprecated hook '{oldHook}', which will stop working on {expireDate:D}. Please ask the author to update to '{newHook}'");`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`return CallHook(oldHook, args);`