Fixes publishing

Projects/Server/AssemblyHandler.cs

@@ -0,0 +1,169 @@
+/***************************************************************************
+ *                            AssemblyHandler.cs
+ *                           --------------------
+ *   begin                : May 1, 2002
+ *   copyright            : (C) The RunUO Software Team
+ *   email                : info@runuo.com
+ *
+ *   $Id$
+ *
+ ***************************************************************************/
+
+/***************************************************************************
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ ***************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace Server
+{
+  public static class AssemblyHandler
+  {
+    private static Dictionary<Assembly, TypeCache> m_TypeCaches = new Dictionary<Assembly, TypeCache>();
+    private static TypeCache m_NullCache;
+    public static Assembly[] Assemblies { get; set; }
+
+    public static string AssembliesPath = EnsureDirectory("Assemblies");
+
+    public static void LoadScripts(string path = null) =>
+      Assemblies = Directory.GetFiles(path ?? AssembliesPath, "*.dll")
+        .Select(t => AssemblyLoadContext.Default.LoadFromAssemblyPath(t)).ToArray();
+
+    public static void Invoke(string method)
+    {
+      List<MethodInfo> invoke = new List<MethodInfo>();
+
+      for (int a = 0; a < Assemblies.Length; ++a)
+        invoke.AddRange(Assemblies[a].GetTypes()
+          .Select(t => t.GetMethod(method, BindingFlags.Static | BindingFlags.Public)).Where(m => m != null));
+
+      invoke.Sort(new CallPriorityComparer());
+
+      for (int i = 0; i < invoke.Count; ++i)
+        invoke[i].Invoke(null, null);
+    }
+
+    public static TypeCache GetTypeCache(Assembly asm)
+    {
+      if (asm == null) return m_NullCache ??= new TypeCache(null);
+
+      if (m_TypeCaches.TryGetValue(asm, out TypeCache c))
+        return c;
+
+      return m_TypeCaches[asm] = new TypeCache(asm);
+    }
+
+    public static Type FindTypeByFullName(string fullName) => FindTypeByFullName(fullName, true);
+
+    public static Type FindTypeByFullName(string fullName, bool ignoreCase)
+    {
+      Type type = null;
+
+      for (int i = 0; type == null && i < Assemblies.Length; ++i)
+        type = GetTypeCache(Assemblies[i]).GetTypeByFullName(fullName, ignoreCase);
+
+      return type ?? GetTypeCache(Core.Assembly).GetTypeByFullName(fullName, ignoreCase);
+    }
+
+    public static Type FindTypeByName(string name) => FindTypeByName(name, true);
+
+    public static Type FindTypeByName(string name, bool ignoreCase)
+    {
+      Type type = null;
+
+      for (int i = 0; type == null && i < Assemblies.Length; ++i)
+        type = GetTypeCache(Assemblies[i]).GetTypeByName(name, ignoreCase);
+
+      return type ?? GetTypeCache(Core.Assembly).GetTypeByName(name, ignoreCase);
+    }
+
+    public static string EnsureDirectory(string dir)
+    {
+      string path = Path.Combine(Core.BaseDirectory, dir);
+
+      if (!Directory.Exists(path))
+        Directory.CreateDirectory(path);
+
+      return path;
+    }
+  }
+
+  public class TypeCache
+  {
+    public TypeCache(Assembly asm)
+    {
+      Types = asm?.GetTypes() ?? Type.EmptyTypes;
+
+      Names = new TypeTable(Types.Length);
+      FullNames = new TypeTable(Types.Length);
+
+      Type typeofTypeAliasAttribute = typeof(TypeAliasAttribute);
+
+      for (int i = 0; i < Types.Length; ++i)
+      {
+        Type type = Types[i];
+
+        Names.Add(type.Name, type);
+        FullNames.Add(type.FullName, type);
+
+        if (type.IsDefined(typeofTypeAliasAttribute, false))
+        {
+          object[] attrs = type.GetCustomAttributes(typeofTypeAliasAttribute, false);
+
+          if (attrs.Length > 0 && attrs[0] is TypeAliasAttribute attr)
+            for (int j = 0; j < attr.Aliases.Length; ++j)
+              FullNames.Add(attr.Aliases[j], type);
+        }
+      }
+    }
+
+    public Type[] Types{ get; }
+
+    public TypeTable Names{ get; }
+
+    public TypeTable FullNames{ get; }
+
+    public Type GetTypeByName(string name, bool ignoreCase) => Names.Get(name, ignoreCase);
+
+    public Type GetTypeByFullName(string fullName, bool ignoreCase) => FullNames.Get(fullName, ignoreCase);
+  }
+
+  public class TypeTable
+  {
+    private Dictionary<string, Type> m_Sensitive, m_Insensitive;
+
+    public TypeTable(int capacity)
+    {
+      m_Sensitive = new Dictionary<string, Type>(capacity);
+      m_Insensitive = new Dictionary<string, Type>(capacity, StringComparer.OrdinalIgnoreCase);
+    }
+
+    public void Add(string key, Type type)
+    {
+      m_Sensitive[key] = type;
+      m_Insensitive[key] = type;
+    }
+
+    public Type Get(string key, bool ignoreCase)
+    {
+      Type t;
+
+      if (ignoreCase)
+        m_Insensitive.TryGetValue(key, out t);
+      else
+        m_Sensitive.TryGetValue(key, out t);
+
+      return t;
+    }
+  }
+}