为什么我的程序集需要按特定顺序加载？

Question

我正在编写一个简单的插件，偶然发现 contractType.IsAssignableFrom(pluginType) 根据加载顺序返回不同的结果。

在插件上调用 IsAssignableFrom 按预期返回 True。
但是如果我在加载插件之前加载合同程序集，插件上的 IsAssignableFrom返回 False。

我正在运行 Win10 和 dotnet4.7，但我怀疑这有什么相关性。

---

代码

[TestMethod]
public void SimplyLoadingPlugin_Succeeds()
{
    var plugin = Assembly.LoadFrom(PluginPathFilename);
    var res = typeof(Contract).IsAssignableFrom(plugin.GetExportedTypes().Single());

    Assert.IsTrue(res); // Succeeds.
}

[TestMethod]
public void LoadingContractAndThenPlugin_Fails()
{
    var contract = Assembly.LoadFrom(ContractPathFilename);
    var plugin = Assembly.LoadFrom(PluginPathFilename);
    var res = typeof(Contract).IsAssignableFrom(plugin.GetExportedTypes().Single());

    Assert.IsTrue(res); // Fails.
}

为了让测试更难：
如果我自己运行LoadingContractAndThenPlugin_Fails 测试失败。但是如果我一起运行测试，它取决于顺序。首先运行 SimplyLoadingPlugin_Succeeds 和最后运行 LoadingContractAndThenPlugin_Fails 会使两个测试都变为绿色，但以相反的顺序运行它们会使两者都失败。
所以不知何故，在插件之前加载合同给我带来了一些麻烦。
我在 GAC 中看不到任何相关内容。

---

以下是所需的所有文件。中的路径可能需要更新。
4 个项目，每个项目一个文件。 1 个解决方案。

Contract.cs（一个库项目）

public abstract class Contract
{
    public abstract int Version { get; set; }
}

Plugin.cs（一个库项目）

public class Plugin : Contract
{
    public override int Version { get; set; }
}

Tests.cs（一个测试项目）

[TestClass]
public class Tests
{
    private const string PluginPath = @"C:\DATA\Projekt\LoadFromOrder\Plugin\bin\Debug";
    private string PluginPathFilename = Path.Combine(PluginPath, "Plugin.dll");
    private string ContractPathFilename = Path.Combine(PluginPath, "Contract.dll");

    [TestMethod]
    public void SimplyLoadingPlugin_Succeeds()
    {
        var plugin = Assembly.LoadFrom(PluginPathFilename);
        var res = typeof(Contract).IsAssignableFrom(plugin.GetExportedTypes().Single());

        Assert.IsTrue(res); // Succeeds.
    }

    [TestMethod]
    public void LoadingContractAndThenPlugin_Fails()
    {
        var contract = Assembly.LoadFrom(ContractPathFilename);
        var plugin = Assembly.LoadFrom(PluginPathFilename);
        var res = typeof(Contract).IsAssignableFrom(plugin.GetExportedTypes().Single());

        Assert.IsTrue(res); // Fails.
    }

    // BEGIN ---- Update. ----
    [TestMethod]
    public void LoadingPluginFromTestProject_Succeeds()
    {
        var contract = Assembly.LoadFrom(
            @"C:\DATA\Projekt\LoadFromOrder\TestProject\bin\Debug\Contract.dll");
        var plugin = Assembly.LoadFrom(PluginPathFilename);
        var res = typeof(Contract.Contract).IsAssignableFrom(plugin.GetExportedTypes().Single());

        Assert.IsTrue(res); // Succeeds.
    }
    // END ---- Update. ----

}

Program.cs（控制台项目）

class Program
{
    static void Main(string[] args)
    {
        var tests = new Tests();
        try
        {
            System.Console.WriteLine("Press A for Success and B for Fail.");
            switch (System.Console.ReadKey(true).Key)
            {
                case ConsoleKey.A:
                    tests.SimplyLoadingPlugin_Succeeds();
                    break;
                case ConsoleKey.B:
                    tests.LoadingContractAndThenPlugin_Fails();
                    break;
            }
            System.Console.WriteLine("SUCCESS");
        }
        catch (Exception exc)
        {
            System.Console.WriteLine($"FAIL: {exc.Message}");
        }
    }
}

Answer 1

通过使用Assembly.LoadFrom 加载Contract，您正在创建引用歧义。该库已经加载，这就是为什么我们可以这样做 typeof(Contract) 无需再次加载它......

我的建议：使用反射来确定你有哪些引用，只加载那些不存在的引用，这里是一个示例代码 sn-p：

        var dllFiles = Directory.GetFiles(DIR, "*.DLL", SearchOption.AllDirectories);
        var plugins = new HashSet<Assembly>();

        var references = typeof(Program).Assembly.GetReferencedAssemblies();
        foreach (var dllPath in dllFiles)
        {
            string name = Path.GetFileNameWithoutExtension(dllPath);
            if (!references.Any(x => x.Name == name) && !plugins.Any(x => x.GetName().Name == name))
                plugins.Add(Assembly.LoadFrom(dllPath));
        }

在该示例中，我们获取给定目录（包括子目录）的每个 DLL，DIR 可以是像 ..\..\.. 这样的相对路径，并且只加载那些不在程序集引用中的路径。

这是包含两个插件项目的完整解决方案：
https://github.com/heldersepu/csharp-proj/tree/master/PluginSystem

Answer 2

正如@HelderSepu 所说，第二次加载合同程序集可能是问题所在。

我建议您以不同但更简单的方式进行测试。而不是手动（重新）加载测试中的程序集，只需在测试项目中添加对程序集/项目的引用，并直接引用typeof(Contract)和typeof(Plugin)并检查是否typeof(Contract).IsAssignableFrom(typeof(Plugin))。没什么复杂的，只需添加对测试项目的引用即可。

您不需要测试程序集是否正确加载，CLR 会处理它。您需要测试插件程序集是否包含Contract 定义。无论您的架构可能有什么用例，您应该担心的不是程序集加载是否有效；是插件是否被正确实现。