patch for UI

PluginManager/Loaders/Loader.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using PluginManager.Interfaces;
+using PluginManager.Others;
+
+namespace PluginManager.Loaders
+{
+    internal class LoaderArgs : EventArgs
+    {
+        internal string?    PluginName { get; init; }
+        internal string?    TypeName   { get; init; }
+        internal bool       IsLoaded   { get; init; }
+        internal Exception? Exception  { get; init; }
+        internal object?    Plugin     { get; init; }
+    }
+
+    internal class Loader<T>
+    {
+        internal delegate void FileLoadedEventHandler(LoaderArgs args);
+
+        internal event FileLoadedEventHandler? FileLoaded;
+
+        internal delegate void PluginLoadedEventHandler(LoaderArgs args);
+
+        internal event PluginLoadedEventHandler? PluginLoaded;
+
+
+        private string path      { get; }
+        private string extension { get; }
+
+
+        internal Loader(string path, string extension)
+        {
+            this.path      = path;
+            this.extension = extension;
+        }
+
+        internal List<T>? Load()
+        {
+            List<T>  list  = new List<T>();
+            if (!Directory.Exists(path))
+            {
+                Directory.CreateDirectory(path);
+                return null;
+            }
+
+            string[] files = Directory.GetFiles(path, $"*.{extension}", SearchOption.AllDirectories);
+            foreach (var file in files)
+            {
+                Assembly.LoadFrom(file);
+                if (FileLoaded != null)
+                {
+                    LoaderArgs args = new LoaderArgs() { Exception = null, TypeName = nameof(T), IsLoaded = false, PluginName = file, Plugin = null };
+                    FileLoaded.Invoke(args);
+                }
+            }
+
+            try
+            {
+                Type interfaceType = typeof(T);
+                Type[] types = AppDomain.CurrentDomain.GetAssemblies()
+                    .SelectMany(a => a.GetTypes())
+                    .Where(p => interfaceType.IsAssignableFrom(p) && p.IsClass)
+                    .ToArray();
+
+
+                list.Clear();
+                foreach (Type type in types)
+                {
+                    try
+                    {
+                        T plugin = (T)(Activator.CreateInstance(type)!);
+                        list.Add(plugin);
+
+
+                        if (PluginLoaded != null) { PluginLoaded.Invoke(new() { Exception = null, IsLoaded = true, PluginName = type.FullName, TypeName = nameof(T), Plugin = plugin }); }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (PluginLoaded != null) { PluginLoaded.Invoke(new() { Exception = ex, IsLoaded = false, PluginName = type.FullName, TypeName = nameof(T) }); }
+                    }
+                }
+            }
+            catch (Exception ex) { Functions.WriteErrFile(ex.ToString()); }
+
+
+            return list;
+        }
+    }
+}