Module.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using JetBrains.Annotations;
using SDG.Framework.Modules;
using SDG.Unturned;

namespace FixLibrary;

[UsedImplicitly]
public class Module : IModuleNexus
{
 private ConcurrentDictionary<string, Assembly>? _loadedAssemblies;
 private List<Library>? _libraries;
 private const string DiscordSupportUrl = "https://discord.gg/2yG5t869uq";
 private const string GitHubUrl = "https://github.com/UnturnedCommunity/FixLibrary";

 public void initialize()
 {
 var assembly = typeof(Module).Assembly;
 var assemblyName = assembly.GetName();

 CommandWindow.Log($"Loading FixLibrary... {assemblyName.Name} {assemblyName.Version} this could take for a while!");
 CommandWindow.Log($"Discord Support: {DiscordSupportUrl}");
 CommandWindow.Log($"GitHub: {GitHubUrl}");

 var moduleDirectory = string.Empty;
 var assemblyFileName = string.Empty;

 foreach (var module in ModuleHook.modules)
 {
 // ReSharper disable once InvertIf
 if (module.assemblies is { Length: > 0 } && module.assemblies[0] == assembly)
 {
 moduleDirectory = Path.GetFullPath(module.config.DirectoryPath);
 assemblyFileName = Path.GetFileName(module.config.Assemblies[0].Path);
 break;
 }
 }

 if (string.IsNullOrEmpty(moduleDirectory))
 {
 throw new Exception("Failed to get FixLibrary module directory");
 }

 _loadedAssemblies = [];
 _libraries = Directory
 .GetFiles(moduleDirectory, "*.dll", SearchOption.TopDirectoryOnly)
 .Where(x => !Path.GetFileName(x).Equals(assemblyFileName, StringComparison.OrdinalIgnoreCase))
 .Select(GetLibrary)
 .ToList();
 ModuleHook.PreVanillaAssemblyResolve += UnturnedPreVanillaAssemblyResolve;

 foreach (var library in _libraries)
 {
 if (_loadedAssemblies.ContainsKey(library.Name))
 {
 // Loaded on Assembly Resolve
 continue;
 }

 CommandWindow.Log($"LOADED: {library.Name} {library.Path}");

 var loadedAssembly = Assembly.Load(library.Content, library.Symbols);
 _loadedAssemblies.TryAdd(loadedAssembly.GetName().Name, loadedAssembly);
 }

 CommandWindow.Log("Loaded FixLibrary!");
 }
 public void shutdown()
 {
 _libraries?.Clear();
 _libraries = null;
 _loadedAssemblies?.Clear();
 _loadedAssemblies = null;
 ModuleHook.PreVanillaAssemblyResolve -= UnturnedPreVanillaAssemblyResolve;
 }

 private static Library GetLibrary(string assemblyFilePath)
 {
 var fileName = Path.GetFileNameWithoutExtension(assemblyFilePath);
 var symbolsFilePath = Path.ChangeExtension(assemblyFilePath, "pdb");
 var symbols = File.Exists(symbolsFilePath) ? File.ReadAllBytes(symbolsFilePath) : null;
 var content = File.ReadAllBytes(assemblyFilePath);
 return new Library
 {
 Path = assemblyFilePath,
 Name = fileName,
 Content = content,
 Symbols = symbols,
 };
 }
 private Assembly? UnturnedPreVanillaAssemblyResolve(object sender, ResolveEventArgs args)
 {
 var assembly = FindLoadedAssembly(args)
 ?? TryLoadNotLoadedAssembly(args);
 return assembly;
 }
 private Assembly? FindLoadedAssembly(ResolveEventArgs args)
 {
 var assemblyName = new AssemblyName(args.Name);
 CommandWindow.Log($"FindLoadedAssembly: {assemblyName.Name}");
 return _loadedAssemblies!.TryGetValue(assemblyName.Name, out var loadedAssembly)
 ? loadedAssembly
 : null;
 }
 /// <summary>
 /// This way we solve a problem when Library dependent on another Library.
 /// And its very important to load it on first Assembly Resolve because
 /// somehow if you don't resolve it first time it will break everything.
 /// </summary>
 private Assembly? TryLoadNotLoadedAssembly(ResolveEventArgs args)
 {
 var assemblyName = new AssemblyName(args.Name);
 var library = _libraries!.FirstOrDefault(x =>
 assemblyName.Name == x.Name);
 if (library != null)
 {
 CommandWindow.Log($"TryLoadNotLoadedAssembly: {library.Name} {library.Path}");
 var assembly = Assembly.Load(library.Content);
 _loadedAssemblies!.TryAdd(assemblyName.Name, assembly);
 return assembly;
 }
 return null;
 }

 private class Library
 {
 public string Path { get; set; }
 public string Name { get; set; }
 public byte[] Content { get; set; }
 public byte[]? Symbols { get; set; }
 }
}