Update referenced assemblies loop, cleanup

scorteanucosmin · scorteanucosmin · commit f615ed820dc2 · 2026-02-17T19:09:40.000+02:00
diff --git a/src/CSharpPluginLoader.cs b/src/CSharpPluginLoader.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Text.RegularExpressions;
 using Oxide.CSharp.Common;
 using Oxide.Pooling;
@@ -15,14 +16,26 @@ namespace Oxide.Plugins
     public class CSharpPluginLoader : PluginLoader
     {
         public static string[] DefaultReferences = { "mscorlib", "Oxide.Core", "Oxide.CSharp", "Oxide.Common", "System", "System.Core", "System.Data", "System.Xml" };
-        public static HashSet<string> PluginReferences = new HashSet<string>(DefaultReferences);
+        public static HashSet<string> PluginReferences = new(DefaultReferences);
         public static CSharpPluginLoader Instance;
 
         private static CSharpExtension extension;
         private static Dictionary<string, CompilablePlugin> plugins = new Dictionary<string, CompilablePlugin>();
         private static readonly string[] AssemblyBlacklist = { "Newtonsoft.Json", "protobuf-net", "websocket-sharp" };
         private Core.Libraries.Timer timer { get; } = Interface.Oxide.GetLibrary<Core.Libraries.Timer>();
 
+        private readonly List<CompilablePlugin> _compilationQueue = new List<CompilablePlugin>();
+        private readonly CompilerService _compiler;
+
+        public override string FileExtension => ".cs";
+
+        public CSharpPluginLoader(CSharpExtension extension)
+        {
+            Instance = this;
+            CSharpPluginLoader.extension = extension;
+            _compiler = new CompilerService(extension);
+        }
+
         public static CompilablePlugin GetCompilablePlugin(string directory, string name)
         {
             string className = Regex.Replace(name, "_", "");
@@ -35,18 +48,6 @@ public static CompilablePlugin GetCompilablePlugin(string directory, string name
             return plugin;
         }
 
-        public override string FileExtension => ".cs";
-
-        private readonly List<CompilablePlugin> _compilationQueue = new List<CompilablePlugin>();
-        private readonly CompilerService _compiler;
-
-        public CSharpPluginLoader(CSharpExtension extension)
-        {
-            Instance = this;
-            CSharpPluginLoader.extension = extension;
-            _compiler = new CompilerService(extension);
-        }
-
         public void OnModLoaded()
         {
             _compiler.Precheck();
@@ -59,7 +60,7 @@ public void OnModLoaded()
                     continue;
                 }
 
-                System.Reflection.Assembly assembly = extension.GetType().Assembly;
+                Assembly assembly = extension.GetType().Assembly;
                 string assemblyName = assembly.GetName().Name;
 
                 if (AssemblyBlacklist.Contains(assemblyName))
@@ -68,12 +69,18 @@ public void OnModLoaded()
                 }
 
                 PluginReferences.Add(assemblyName);
-                foreach (System.Reflection.AssemblyName reference in assembly.GetReferencedAssemblies())
+
+                AssemblyName[] referencedAssemblies = assembly.GetReferencedAssemblies();
+                int referencedAssemblyCount = referencedAssemblies.Length;
+                for (int i = 0; i < referencedAssemblyCount; i++)
                 {
-                    if (reference != null)
+                    AssemblyName reference = referencedAssemblies[i];
+                    if (reference == null)
                     {
-                        PluginReferences.Add(reference.Name);
+                        continue;
                     }
+
+                    PluginReferences.Add(reference.Name);
                 }
             }
         }
diff --git a/src/CompiledAssembly.cs b/src/CompiledAssembly.cs
@@ -170,6 +170,7 @@ private void ValidateAssembly(Action<byte[], byte[]> callback)
 
                             Interface.Oxide.RootLogger.WriteDebug(LogType.Info, LogEvent.Compile, "CSharp",
                                 $"Patching DirectCallMethod on {typeDefinition.Name}");
+
                             new DirectCallMethod(assemblyDefinition.MainModule, typeDefinition, baseAssembly);
                         }
                         catch (Exception exception)
diff --git a/src/CompilerService.cs b/src/CompilerService.cs
@@ -27,7 +27,7 @@ namespace Oxide.CSharp
     internal class CompilerService
     {
         private readonly Hash<int, Compilation> _compilations;
-        private readonly Queue<CompilerMessage> _messageQueue = new Queue<CompilerMessage>();
+        private readonly Queue<CompilerMessage> _messageQueue = new();
         private Process? _compilerProcess;
         private volatile int _lastId;
         private volatile bool _ready;
@@ -116,22 +116,24 @@ internal bool Precheck()
                 "OXIDEMOD"
             };
 
-            Extension? game = Interface.Oxide.GetAllExtensions().SingleOrDefault(e => e.IsGameExtension);
-            if (game != null)
+            IEnumerable<Extension> extensions = Interface.Oxide.GetAllExtensions();
+
+            Extension? gameExtension = extensions.SingleOrDefault(extension => extension.IsGameExtension);
+            if (gameExtension != null)
             {
-                string name = game.Name.ToUpperInvariant();
-                string branch = game.Branch?.ToUpperInvariant() ?? "PUBLIC";
+                string name = gameExtension.Name.ToUpperInvariant();
+                string branch = gameExtension.Branch?.ToUpperInvariant() ?? "PUBLIC";
                 preprocessors.Add(EscapeSymbolName(name));
                 preprocessors.Add(EscapeSymbolName(name + "_" + branch));
 
-                if (game.Version != default)
+                if (gameExtension.Version != default)
                 {
-                    preprocessors.Add(EscapeSymbolName(name + "_" + game.Version));
-                    preprocessors.Add(EscapeSymbolName(name + "_" + game.Version + "_" + branch));
+                    preprocessors.Add(EscapeSymbolName(name + "_" + gameExtension.Version));
+                    preprocessors.Add(EscapeSymbolName(name + "_" + gameExtension.Version + "_" + branch));
                 }
             }
 
-            foreach (Extension extension in Interface.Oxide.GetAllExtensions())
+            foreach (Extension extension in extensions)
             {
                 try
                 {
@@ -212,9 +214,9 @@ private bool Start()
                     Thread.Sleep(100);
                 }
             }
-            catch (Exception e)
+            catch (Exception exception)
             {
-                Log(LogType.Error, e.Message);
+                Log(LogType.Error, exception.Message);
                 return false;
             }
 
@@ -243,11 +245,11 @@ private bool Start()
                 _compilerProcess.Exited += OnCompilerProcessExited;
                 _compilerProcess.Start();
             }
-            catch (Exception ex)
+            catch (Exception exception)
             {
                 _compilerProcess?.Dispose();
                 _compilerProcess = null;
-                Interface.Oxide.LogException($"Exception while starting compiler", ex);
+                Interface.Oxide.LogException($"Exception while starting compiler", exception);
                 if (_filePath.Contains("'"))
                 {
                     Interface.Oxide.LogError("Server directory path contains an apostrophe, compiler will not work until path is renamed");
@@ -257,15 +259,15 @@ private bool Start()
                     Interface.Oxide.LogError("Compiler may not be set as executable; chmod +x or 0744/0755 required");
                 }
 
-                if (ex.GetBaseException() != ex)
+                Exception baseException = exception.GetBaseException();
+                if (baseException != exception)
                 {
-                    Interface.Oxide.LogException("BaseException: ", ex.GetBaseException());
+                    Interface.Oxide.LogException("BaseException: ", baseException);
                 }
 
-                Win32Exception win32 = ex as Win32Exception;
-                if (win32 != null)
+                if (exception is Win32Exception win32Exception)
                 {
-                    Interface.Oxide.LogError($"Win32 NativeErrorCode: {win32.NativeErrorCode} ErrorCode: {win32.ErrorCode} HelpLink: {win32.HelpLink}");
+                    Interface.Oxide.LogError($"Win32 NativeErrorCode: {win32Exception.NativeErrorCode} ErrorCode: {win32Exception.ErrorCode} HelpLink: {win32Exception.HelpLink}");
                 }
             }
 
@@ -308,16 +310,19 @@ private void OnMessageReceived(CompilerMessage message)
 
                     if (message.Errors != null)
                     {
-                        foreach (CompilerError error in message.Errors)
+                        int errorCount = message.Errors.Count;
+                        for (int i = 0; i < errorCount; i++)
                         {
+                            CompilerError error = message.Errors[i];
                             Log(LogType.Error, $"Compiler error for compilation {compilation.name}: {error.Message}");
 
                             CompilablePlugin? compilablePlugin =
                                 compilation.plugins.SingleOrDefault(pl => pl.ScriptName == error.File);
 
                             if (compilablePlugin == null)
                             {
-                                Interface.Oxide.LogError($"Unable to resolve script error to {error.File}: {error.Message}");
+                                Interface.Oxide.LogError(
+                                    $"Unable to resolve script error to {error.File}: {error.Message}");
                                 continue;
                             }
 
@@ -327,9 +332,10 @@ private void OnMessageReceived(CompilerMessage message)
                             string[] missingRequirementsArray = missingRequirements.ToArray();
                             if (missingRequirementsArray.Length > 0)
                             {
-                                compilablePlugin.CompilerErrors.Add($"Missing dependencies: {string.Join(",", missingRequirementsArray)}");
+                                compilablePlugin.CompilerErrors.Add(
+                                    $"Missing dependencies: {missingRequirementsArray.JoinValues(',')}");
 
-                                Log(LogType.Error, $"[{error.File}] Missing dependencies: {string.Join(",", missingRequirementsArray)}");
+                                Log(LogType.Error, $"[{error.File}] Missing dependencies: {missingRequirementsArray.JoinValues(',')}");
                             }
                             else
                             {
@@ -341,7 +347,7 @@ private void OnMessageReceived(CompilerMessage message)
                     }
 
                     CompilationResult? compilationResult = Constants.Serializer.Deserialize<CompilationResult>(message.Data);
-                    if (compilationResult.Data == null || compilationResult.Data.Length == 0)
+                    if (compilationResult?.Data == null || compilationResult.Data.Length == 0)
                     {
                         compilation.Completed();
                     }
@@ -368,9 +374,9 @@ private void OnMessageReceived(CompilerMessage message)
                         return;
                     }
 
-                    foreach (CompilablePlugin p in compilation.plugins)
+                    foreach (CompilablePlugin compilablePlugin in compilation.plugins)
                     {
-                        p.CompilerErrors.Add(errorMessage);
+                        compilablePlugin.CompilerErrors.Add(errorMessage);
                     }
 
                     compilation.Completed();
@@ -380,6 +386,7 @@ private void OnMessageReceived(CompilerMessage message)
                 {
                     string logMessage =
                         $"Ready signal received from compiler (Startup took: {Math.Round((Interface.Oxide.Now - _startTime) * 1000f)}ms)";
+
                     switch (_messageQueue.Count)
                     {
                         case 0:
@@ -672,19 +679,19 @@ private static bool SetFilePermissions(string filePath)
                     Log(LogType.Info, $"{name} is executable");
                 }
             }
-            catch (Exception ex)
+            catch (Exception exception)
             {
-                Interface.Oxide.LogException($"Unable to check {name} for executable permission", ex);
+                Interface.Oxide.LogException($"Unable to check {name} for executable permission", exception);
             }
             try
             {
                 Syscall.chmod(filePath, FilePermissions.S_IRWXU);
                 Interface.Oxide.LogInfo($"File permissions set for {name}");
                 return true;
             }
-            catch (Exception ex)
+            catch (Exception exception)
             {
-                Interface.Oxide.LogException($"Could not set {filePath} as executable, please set manually", ex);
+                Interface.Oxide.LogException($"Could not set {filePath} as executable, please set manually", exception);
             }
 
             return false;
@@ -716,10 +723,7 @@ private static bool DownloadFile(string url, string path, int retries = 3)
                     Interface.Oxide.LogInfo($"[CSharp] Downloading {fileName}. . .");
                 }
 
-                byte[] data;
-                int code;
-                bool newerFound;
-                if (!TryDownload(url, retries, ref retry, last, out data, out code, out newerFound, ref md5))
+                if (!TryDownload(url, retries, ref retry, last, out byte[] data, out int code, out bool newerFound, ref md5))
                 {
                     string attemptVerb = retries == 1 ? "attempt" : "attempts";
                     Interface.Oxide.LogError($"[CSharp] Failed to download {fileName} after {retry} {attemptVerb} with response code '{code}', please manually download it from {url} and save it here {path}");
@@ -750,9 +754,9 @@ private static bool DownloadFile(string url, string path, int retries = 3)
 
                 return true;
             }
-            catch (Exception e)
+            catch (Exception exception)
             {
-                Interface.Oxide.LogException($"Unexpected error occurred while trying to download {fileName}, please manually download it from {url} and save it here {path}", e);
+                Interface.Oxide.LogException($"Unexpected error occurred while trying to download {fileName}, please manually download it from {url} and save it here {path}", exception);
                 return false;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -170,6 +170,7 @@ private void ValidateAssembly(Action<byte[], byte[]> callback)`
`170`	`170`
`171`	`171`	`Interface.Oxide.RootLogger.WriteDebug(LogType.Info, LogEvent.Compile, "CSharp",`
`172`	`172`	`$"Patching DirectCallMethod on {typeDefinition.Name}");`
	`173`	`+`
`173`	`174`	`new DirectCallMethod(assemblyDefinition.MainModule, typeDefinition, baseAssembly);`
`174`	`175`	`}`
`175`	`176`	`catch (Exception exception)`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ namespace Oxide.CSharp`
`27`	`27`	`internal class CompilerService`
`28`	`28`	`{`
`29`	`29`	`private readonly Hash<int, Compilation> _compilations;`
`30`		`- private readonly Queue<CompilerMessage> _messageQueue = new Queue<CompilerMessage>();`
	`30`	`+ private readonly Queue<CompilerMessage> _messageQueue = new();`
`31`	`31`	`private Process? _compilerProcess;`
`32`	`32`	`private volatile int _lastId;`
`33`	`33`	`private volatile bool _ready;`
`@@ -116,22 +116,24 @@ internal bool Precheck()`
`116`	`116`	`"OXIDEMOD"`
`117`	`117`	`};`
`118`	`118`
`119`		`- Extension? game = Interface.Oxide.GetAllExtensions().SingleOrDefault(e => e.IsGameExtension);`
`120`		`- if (game != null)`
	`119`	`+ IEnumerable<Extension> extensions = Interface.Oxide.GetAllExtensions();`
	`120`	`+`
	`121`	`+ Extension? gameExtension = extensions.SingleOrDefault(extension => extension.IsGameExtension);`
	`122`	`+ if (gameExtension != null)`
`121`	`123`	`{`
`122`		`- string name = game.Name.ToUpperInvariant();`
`123`		`- string branch = game.Branch?.ToUpperInvariant() ?? "PUBLIC";`
	`124`	`+ string name = gameExtension.Name.ToUpperInvariant();`
	`125`	`+ string branch = gameExtension.Branch?.ToUpperInvariant() ?? "PUBLIC";`
`124`	`126`	`preprocessors.Add(EscapeSymbolName(name));`
`125`	`127`	`preprocessors.Add(EscapeSymbolName(name + "_" + branch));`
`126`	`128`
`127`		`- if (game.Version != default)`
	`129`	`+ if (gameExtension.Version != default)`
`128`	`130`	`{`
`129`		`- preprocessors.Add(EscapeSymbolName(name + "_" + game.Version));`
`130`		`- preprocessors.Add(EscapeSymbolName(name + "_" + game.Version + "_" + branch));`
	`131`	`+ preprocessors.Add(EscapeSymbolName(name + "_" + gameExtension.Version));`
	`132`	`+ preprocessors.Add(EscapeSymbolName(name + "_" + gameExtension.Version + "_" + branch));`
`131`	`133`	`}`
`132`	`134`	`}`
`133`	`135`
`134`		`- foreach (Extension extension in Interface.Oxide.GetAllExtensions())`
	`136`	`+ foreach (Extension extension in extensions)`
`135`	`137`	`{`
`136`	`138`	`try`
`137`	`139`	`{`
`@@ -212,9 +214,9 @@ private bool Start()`
`212`	`214`	`Thread.Sleep(100);`
`213`	`215`	`}`
`214`	`216`	`}`
`215`		`- catch (Exception e)`
	`217`	`+ catch (Exception exception)`
`216`	`218`	`{`
`217`		`- Log(LogType.Error, e.Message);`
	`219`	`+ Log(LogType.Error, exception.Message);`
`218`	`220`	`return false;`
`219`	`221`	`}`
`220`	`222`
`@@ -243,11 +245,11 @@ private bool Start()`
`243`	`245`	`_compilerProcess.Exited += OnCompilerProcessExited;`
`244`	`246`	`_compilerProcess.Start();`
`245`	`247`	`}`
`246`		`- catch (Exception ex)`
	`248`	`+ catch (Exception exception)`
`247`	`249`	`{`
`248`	`250`	`_compilerProcess?.Dispose();`
`249`	`251`	`_compilerProcess = null;`
`250`		`- Interface.Oxide.LogException($"Exception while starting compiler", ex);`
	`252`	`+ Interface.Oxide.LogException($"Exception while starting compiler", exception);`
`251`	`253`	`if (_filePath.Contains("'"))`
`252`	`254`	`{`
`253`	`255`	`Interface.Oxide.LogError("Server directory path contains an apostrophe, compiler will not work until path is renamed");`
`@@ -257,15 +259,15 @@ private bool Start()`
`257`	`259`	`Interface.Oxide.LogError("Compiler may not be set as executable; chmod +x or 0744/0755 required");`
`258`	`260`	`}`
`259`	`261`
`260`		`- if (ex.GetBaseException() != ex)`
	`262`	`+ Exception baseException = exception.GetBaseException();`
	`263`	`+ if (baseException != exception)`
`261`	`264`	`{`
`262`		`- Interface.Oxide.LogException("BaseException: ", ex.GetBaseException());`
	`265`	`+ Interface.Oxide.LogException("BaseException: ", baseException);`
`263`	`266`	`}`
`264`	`267`
`265`		`- Win32Exception win32 = ex as Win32Exception;`
`266`		`- if (win32 != null)`
	`268`	`+ if (exception is Win32Exception win32Exception)`
`267`	`269`	`{`
`268`		`- Interface.Oxide.LogError($"Win32 NativeErrorCode: {win32.NativeErrorCode} ErrorCode: {win32.ErrorCode} HelpLink: {win32.HelpLink}");`
	`270`	`+ Interface.Oxide.LogError($"Win32 NativeErrorCode: {win32Exception.NativeErrorCode} ErrorCode: {win32Exception.ErrorCode} HelpLink: {win32Exception.HelpLink}");`
`269`	`271`	`}`
`270`	`272`	`}`
`271`	`273`
`@@ -308,16 +310,19 @@ private void OnMessageReceived(CompilerMessage message)`
`308`	`310`
`309`	`311`	`if (message.Errors != null)`
`310`	`312`	`{`
`311`		`- foreach (CompilerError error in message.Errors)`
	`313`	`+ int errorCount = message.Errors.Count;`
	`314`	`+ for (int i = 0; i < errorCount; i++)`
`312`	`315`	`{`
	`316`	`+ CompilerError error = message.Errors[i];`
`313`	`317`	`Log(LogType.Error, $"Compiler error for compilation {compilation.name}: {error.Message}");`
`314`	`318`
`315`	`319`	`CompilablePlugin? compilablePlugin =`
`316`	`320`	`compilation.plugins.SingleOrDefault(pl => pl.ScriptName == error.File);`
`317`	`321`
`318`	`322`	`if (compilablePlugin == null)`
`319`	`323`	`{`
`320`		`- Interface.Oxide.LogError($"Unable to resolve script error to {error.File}: {error.Message}");`
	`324`	`+ Interface.Oxide.LogError(`
	`325`	`+ $"Unable to resolve script error to {error.File}: {error.Message}");`
`321`	`326`	`continue;`
`322`	`327`	`}`
`323`	`328`
`@@ -327,9 +332,10 @@ private void OnMessageReceived(CompilerMessage message)`
`327`	`332`	`string[] missingRequirementsArray = missingRequirements.ToArray();`
`328`	`333`	`if (missingRequirementsArray.Length > 0)`
`329`	`334`	`{`
`330`		`- compilablePlugin.CompilerErrors.Add($"Missing dependencies: {string.Join(",", missingRequirementsArray)}");`
	`335`	`+ compilablePlugin.CompilerErrors.Add(`
	`336`	`+ $"Missing dependencies: {missingRequirementsArray.JoinValues(',')}");`
`331`	`337`
`332`		`- Log(LogType.Error, $"[{error.File}] Missing dependencies: {string.Join(",", missingRequirementsArray)}");`
	`338`	`+ Log(LogType.Error, $"[{error.File}] Missing dependencies: {missingRequirementsArray.JoinValues(',')}");`
`333`	`339`	`}`
`334`	`340`	`else`
`335`	`341`	`{`
`@@ -341,7 +347,7 @@ private void OnMessageReceived(CompilerMessage message)`
`341`	`347`	`}`
`342`	`348`
`343`	`349`	`CompilationResult? compilationResult = Constants.Serializer.Deserialize<CompilationResult>(message.Data);`
`344`		`- if (compilationResult.Data == null \|\| compilationResult.Data.Length == 0)`
	`350`	`+ if (compilationResult?.Data == null \|\| compilationResult.Data.Length == 0)`
`345`	`351`	`{`
`346`	`352`	`compilation.Completed();`
`347`	`353`	`}`
`@@ -368,9 +374,9 @@ private void OnMessageReceived(CompilerMessage message)`
`368`	`374`	`return;`
`369`	`375`	`}`
`370`	`376`
`371`		`- foreach (CompilablePlugin p in compilation.plugins)`
	`377`	`+ foreach (CompilablePlugin compilablePlugin in compilation.plugins)`
`372`	`378`	`{`
`373`		`- p.CompilerErrors.Add(errorMessage);`
	`379`	`+ compilablePlugin.CompilerErrors.Add(errorMessage);`
`374`	`380`	`}`
`375`	`381`
`376`	`382`	`compilation.Completed();`
`@@ -380,6 +386,7 @@ private void OnMessageReceived(CompilerMessage message)`
`380`	`386`	`{`
`381`	`387`	`string logMessage =`
`382`	`388`	`$"Ready signal received from compiler (Startup took: {Math.Round((Interface.Oxide.Now - _startTime) * 1000f)}ms)";`
	`389`	`+`
`383`	`390`	`switch (_messageQueue.Count)`
`384`	`391`	`{`
`385`	`392`	`case 0:`
`@@ -672,19 +679,19 @@ private static bool SetFilePermissions(string filePath)`
`672`	`679`	`Log(LogType.Info, $"{name} is executable");`
`673`	`680`	`}`
`674`	`681`	`}`
`675`		`- catch (Exception ex)`
	`682`	`+ catch (Exception exception)`
`676`	`683`	`{`
`677`		`- Interface.Oxide.LogException($"Unable to check {name} for executable permission", ex);`
	`684`	`+ Interface.Oxide.LogException($"Unable to check {name} for executable permission", exception);`
`678`	`685`	`}`
`679`	`686`	`try`
`680`	`687`	`{`
`681`	`688`	`Syscall.chmod(filePath, FilePermissions.S_IRWXU);`
`682`	`689`	`Interface.Oxide.LogInfo($"File permissions set for {name}");`
`683`	`690`	`return true;`
`684`	`691`	`}`
`685`		`- catch (Exception ex)`
	`692`	`+ catch (Exception exception)`
`686`	`693`	`{`
`687`		`- Interface.Oxide.LogException($"Could not set {filePath} as executable, please set manually", ex);`
	`694`	`+ Interface.Oxide.LogException($"Could not set {filePath} as executable, please set manually", exception);`
`688`	`695`	`}`
`689`	`696`
`690`	`697`	`return false;`
`@@ -716,10 +723,7 @@ private static bool DownloadFile(string url, string path, int retries = 3)`
`716`	`723`	`Interface.Oxide.LogInfo($"[CSharp] Downloading {fileName}. . .");`
`717`	`724`	`}`
`718`	`725`
`719`		`- byte[] data;`
`720`		`- int code;`
`721`		`- bool newerFound;`
`722`		`- if (!TryDownload(url, retries, ref retry, last, out data, out code, out newerFound, ref md5))`
	`726`	`+ if (!TryDownload(url, retries, ref retry, last, out byte[] data, out int code, out bool newerFound, ref md5))`
`723`	`727`	`{`
`724`	`728`	`string attemptVerb = retries == 1 ? "attempt" : "attempts";`
`725`	`729`	`Interface.Oxide.LogError($"[CSharp] Failed to download {fileName} after {retry} {attemptVerb} with response code '{code}', please manually download it from {url} and save it here {path}");`
`@@ -750,9 +754,9 @@ private static bool DownloadFile(string url, string path, int retries = 3)`
`750`	`754`
`751`	`755`	`return true;`
`752`	`756`	`}`
`753`		`- catch (Exception e)`
	`757`	`+ catch (Exception exception)`
`754`	`758`	`{`
`755`		`- Interface.Oxide.LogException($"Unexpected error occurred while trying to download {fileName}, please manually download it from {url} and save it here {path}", e);`
	`759`	`+ Interface.Oxide.LogException($"Unexpected error occurred while trying to download {fileName}, please manually download it from {url} and save it here {path}", exception);`
`756`	`760`	`return false;`
`757`	`761`	`}`
`758`	`762`	`}`