PluginUtilities.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Loader;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using System.Windows;


namespace RegExpressLibrary;

/*
 * See: https://learn.microsoft.com/en-us/dotnet/core/tutorials/creating-app-with-plugin-support
 */

public class PluginLoadContext : AssemblyLoadContext
{
    private readonly AssemblyDependencyResolver _resolver;


    public PluginLoadContext( string pluginPath )
    {
        _resolver = new AssemblyDependencyResolver( pluginPath );
    }


    protected override Assembly? Load( AssemblyName assemblyName )
    {
        string? assemblyPath = _resolver.ResolveAssemblyToPath( assemblyName );

        return assemblyPath != null ? LoadFromAssemblyPath( assemblyPath ) : null;
    }


    protected override IntPtr LoadUnmanagedDll( string unmanagedDllName )
    {
        string? libraryPath = _resolver.ResolveUnmanagedDllToPath( unmanagedDllName );

        return libraryPath != null ? LoadUnmanagedDllFromPath( libraryPath ) : IntPtr.Zero;
    }
}


public static class PluginLoader
{
    public static readonly JsonSerializerOptions JsonOptions = new( ) { AllowTrailingCommas = true, IncludeFields = true, ReadCommentHandling = JsonCommentHandling.Skip, WriteIndented = true };

    public static async Task<(IReadOnlyList<RegexPlugin>? plugins, IReadOnlyList<RegexPlugin>? noFmPlugins)> LoadEngines( Window ownerWindow, string enginesJsonPath )
    {
        // -- deserialize "Engines.json"

        EnginesData? engines_data;

        try
        {
            using FileStream plugins_stream = File.OpenRead( enginesJsonPath );

            engines_data = await JsonSerializer.DeserializeAsync<EnginesData>( plugins_stream, JsonOptions );
            Debug.WriteLine( $"Total {engines_data?.engines?.Length} paths" );
        }
        catch( Exception exc )
        {
            if (InternalConfig.HandleException($"Failed to load plugins using '{enginesJsonPath}'", exc ))
                throw;

            return (null, null);
        }

        // --- load plugins and their engines

        string plugin_root_folder = Path.GetDirectoryName( enginesJsonPath )!;
        List<RegexPlugin> plugins = [];
        List<RegexPlugin> no_fm_plugins = [];

        if( engines_data?.engines != null )
        {
            foreach( EngineData engine_data in engines_data.engines )
            {
                if ( InternalConfig.limited_engine_dlls?.Length > 0 && !InternalConfig.limited_engine_dlls.Any( dll => engine_data.path.Contains(dll, StringComparison.CurrentCultureIgnoreCase) ) )
                {
                    Debug.WriteLine( $"Skipping plugin due to limited_engine_dlls \"{engine_data.path}\"..." );
                    continue;
                }
                string plugin_absolute_path = Path.Combine( plugin_root_folder, engine_data.path! );

                try
                {
                    Debug.WriteLine( $"Trying to load plugin \"{plugin_absolute_path}\"..." );

                    PluginLoadContext load_context = new( plugin_absolute_path );

                    var assembly = load_context.LoadFromAssemblyName( new AssemblyName( Path.GetFileNameWithoutExtension( plugin_absolute_path ) ) );

                    var plugin_type = typeof( RegexPlugin );

                    foreach( Type type in assembly.GetTypes( ) )
                    {
                        if( plugin_type.IsAssignableFrom( type ) )
                        {
                            try
                            {
                                Debug.WriteLine( $"Making plugin \"{type.FullName}\"..." );
                                RegexPlugin plugin = (RegexPlugin)Activator.CreateInstance( type )!;
                                plugins.Add( plugin );
                                if( engine_data.no_fm ) no_fm_plugins.Add( plugin );
                            }
                            catch( Exception exc )
                            {
                                if (InternalConfig.HandleException( $"Failed to create plugin \"{engine_data.path}\"", exc ))
                                    throw;

                            }
                        }
                    }
                }
                catch( Exception exc )
                {
                    if (InternalConfig.HandleException( $"Failed to create plugin \"{engine_data.path}\"", exc ))
                       throw;
                }
            }
        }

#if DEBUG
        Debug.WriteLine( $"Total plugins: {plugins.Count}" );

        foreach( var p in plugins )
        {
            foreach( var eng in p.GetEngines( ) )
            {
                Debug.WriteLine( $"   {eng.Kind} {eng.Version}" );
            }
        }
#endif
        if( plugins.Count == 0 )
        {
            MessageBox.Show( ownerWindow, $"No engines loaded using '{plugin_root_folder}'.\r\n", "Error", MessageBoxButton.OK, MessageBoxImage.Exclamation );

            return (null, null);
        }

        return (plugins, no_fm_plugins);
    }
}