Sixdegreeoffreedomdynamicloadsimulationdevice/IModel/Tools/PluginsLoader.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Loader;
using System.Text;
using System.Threading.Tasks;

namespace IModel.Tools
{
    public class PluginsLoader
    {
        private string _Path = "";
        private List<Assembly> LoadedAssemblies = new List<Assembly>();
        [AllowNull]
        private AssemblyDependencyResolver resolver;
        private List<string> AllDlls = new List<string>();
        private PluginsLoader()
        {

        }
        public List<T> Load<T>(string path)
        {
            try
            {
                _Path = path;
                resolver = new AssemblyDependencyResolver(path);
                AssemblyLoadContext.Default.Resolving += Default_Resolving;
                AssemblyLoadContext.Default.ResolvingUnmanagedDll += Default_ResolvingUnmanagedDll;
                AllDlls.Clear();
                AllDlls.AddRange(System.IO.Directory.GetFiles(path, "*.dll", System.IO.SearchOption.AllDirectories));
                var result = AllDlls
                    .SelectMany(x =>
                    {
                        try
                        {
                            var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(x);
                            var types = assembly.GetTypes();
                            return types.Where(x => x.GetInterface(typeof(T).FullName!) != null && x.IsAnsiClass && !x.IsAbstract);
                        }
                        catch
                        {

                        }
                        return new Type[0];
                    })
                    .Where(x => x != null)
                    .Select(x =>
                    {
                        return (T)Activator.CreateInstance(x!)!;
                    })
                    .Where(x => x != null)
                    .ToList();
                //AssemblyLoadContext.Default.Resolving -= Default_Resolving;
                return result;
            }
            catch
            {
                return new List<T>();
            }
        }
        [DllImport("kernel32.dll")]
        private extern static nint LoadLibrary(string path);
        private nint Default_ResolvingUnmanagedDll(Assembly arg1, string arg2)
        {
            var fileinfo = new FileInfo(arg1.Location);
            if (fileinfo?.Directory == null) return 0;
            var file = fileinfo.Directory.GetFiles(arg2, SearchOption.AllDirectories).FirstOrDefault()?.FullName;
            if(System.IO.File.Exists(file))
            {
                return LoadLibrary(file);
            }
            throw new NotImplementedException();
        }

        private System.Reflection.Assembly? Default_Resolving(AssemblyLoadContext arg1, System.Reflection.AssemblyName arg2)
        {
            var assembly = AssemblyLoadContext.Default.Assemblies.FirstOrDefault(x => x.FullName == arg2.FullName);
            if (assembly != null) return assembly;
            assembly = LoadedAssemblies.FirstOrDefault(x => x.FullName == arg2.FullName);
            if (assembly != null) return assembly;
            string? path = resolver.ResolveAssemblyToPath(arg2);
            if(!string.IsNullOrEmpty(path))
            {
               assembly =  arg1.LoadFromAssemblyPath(path);
                if(assembly!=null)
                {
                    LoadedAssemblies.Add(assembly);
                    return assembly;
                }
            }
            else
            {
                var results = AllDlls.Where(x => x.IndexOf(arg2.Name!) >= 0).ToList();
                results.ForEach(x =>
                {
                    try
                    {
                        var tempassembly = arg1.LoadFromAssemblyPath(x);
                        if (tempassembly != null)
                        {
                            LoadedAssemblies.Add(tempassembly);
                        }
                    }
                    catch
                    {

                    }
                });
                assembly = LoadedAssemblies.FirstOrDefault(x => x.FullName == arg2.FullName);
                if (assembly != null) return assembly;
            }
            return null;
        }

        static PluginsLoader()
        {

        }
        public static PluginsLoader Defalut { get; } = new PluginsLoader();
    }
}