卸載 AssemblyLoadContext.Net 6 核心拋出異常`System.ExecutionEngineException`

Question

我編寫了一個簡單的插件管理器，它在創建插件實例並立即卸載它時工作。 但是，當插件實例的創建和卸載是通過不同的方法完成時，它會拋出以下異常而沒有任何進一步的信息：

"Exception of type 'System.ExecutionEngineException' was thrown."

知道會發生什么嗎？ 我確實檢查過，這似乎不是因為創建插件以在與卸載上下文不同的線程上運行。

這是我的代碼：

public static class PluginManager
{
     private static readonly ILogger _logger;
     private static readonly Dictionary<string, WeakReference> _weakReferences;
     private static List<PluginConfiguration> _pluginConfigurations;

static PluginManager()
{
    _logger = LogManager.GetCurrentClassLogger();
    _weakReferences = new Dictionary<string, WeakReference>();
}

public static void Configure(List<PluginConfiguration> pluginConfigurations)
{
    _pluginConfigurations = pluginConfigurations;
}

public static List<string> GetPluginNames()
{
    return _pluginConfigurations.Select(x => x.Name).ToList();
}

public static PluginConfiguration GetPluginConfiguration(string pluginName)
{
    return _pluginConfigurations.FirstOrDefault(x => x.Name == pluginName);
}

public static List<PluginConfiguration> GetPluginConfigurations()
{
    return _pluginConfigurations;
}


[MethodImpl(MethodImplOptions.NoInlining)]
public static T GetPlugin<T>(string pluginName)
{
    var assemblyPath = $"{SharedDataModule.CoreConfiguration.PluginRootDirectory}/{pluginName}/bin/Debug/net6.0-windows/{pluginName}.dll";
    var alc = new PluginAssemblyLoadContext(assemblyPath);
    Assembly assembly = alc.LoadFromAssemblyPath(assemblyPath);
    var type = assembly.GetTypes().First(t => t.Name == pluginName);

    //store weak reference
    _weakReferences[pluginName] = new WeakReference(alc, trackResurrection: true);

    //instantiate plugin
    var plugin = Activator.CreateInstance(type, _pluginConfigurations.FirstOrDefault(x => x.Name == pluginName));

    _logger.Info($"Successfully subscribed to {pluginName} plugin");
    
    return (T)plugin;
}

public static void Unload(string pluginName)
{
    if (_weakReferences.ContainsKey(pluginName) == false)
        return;

    //obtain weak reference
    var weakRef = _weakReferences[pluginName];

    //try to remove weak reference
    _weakReferences.Remove(pluginName);

    //unload
    ((PluginAssemblyLoadContext) weakRef.Target).Unload();
    
    var task = Task.Run(() =>
    {
        for (var i = 1; weakRef.IsAlive == true && i <= 10; i++)
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            Task.Delay(200).Wait();
        }

        if (weakRef.IsAlive == false)
            _logger.Info($"Plugin {pluginName} was successfully unloaded");
        else
            _logger.Error($"Plugin {pluginName} could not be unloaded");
    });
}

private class PluginAssemblyLoadContext : AssemblyLoadContext
{
    private readonly string _assemblyToLoadPath;
    private readonly AssemblyDependencyResolver _resolver;

    public PluginAssemblyLoadContext(string mainAssemblyToLoadPath) : base(isCollectible: true)
    {
        _assemblyToLoadPath = mainAssemblyToLoadPath;
        _resolver = new AssemblyDependencyResolver(mainAssemblyToLoadPath);
    }

    protected override Assembly Load(AssemblyName name)
    {
        string assemblyPath = _resolver.ResolveAssemblyToPath(name);
        if (assemblyPath != null)
        {
            return LoadFromAssemblyPath(assemblyPath);
        }

        return null;
    }
}

}