为什么我的类型没有标记为相等

在SO上还有其他一些关于这个问题的问题，但我觉得它们都没有真正提供可靠的答案。

我最近经常搞乱反射，我想检查实现某个接口的几个程序集中包含的类型。

所以我有一个名为BESCollector的类，它实现了ICollector

public class BESCollector : ICollector
{
  // ...
}

在这里，我加载程序集，遍历所有类型，看看该类型是否包含 ICollector 类型的接口......

Assembly pluginAssembly = Assembly.ReflectionOnlyLoadFrom(pluginConfig.AssemblyLocation);
IEnumerable<Type> types = pluginAssembly.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(ICollector)));

。这不会产生任何结果:(。调试时，我可以清楚地看到它确实包含此类型。我在 if 循环中中断

Assembly pluginAssembly = Assembly.ReflectionOnlyLoadFrom(pluginConfig.AssemblyLocation);
IEnumerable<Type> types = pluginAssembly.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(ICollector)));
foreach (Type type in pluginAssembly.GetTypes())
{
    Type[] interfaces = type.GetInterfaces();
    if (interfaces.Contains(typeof(ICollector)))
    {
        Console.WriteLine(@"'o/");
    }
}

这些结果直接来自调试器。在这里你可以看到interfaces包含一个类型，即ICollector：

-       interfaces  {System.Type[1]}    System.Type[]
  +     [0] {Name = "ICollector" FullName = "SquidReports.DataCollector.Interface.ICollector"}  System.Type {System.ReflectionOnlyType}

我.GetInterfaces()调用的类型显然是BESCollector：

+       type    {Name = "BESCollector" FullName = "SquidReports.DataCollector.Plugin.BES.BESCollector"} System.Type {System.ReflectionOnlyType}

但相等陈述interfaces.Contains(typeof(ICollector))永远不会被评估为真实。

只是为了让您认为我在这里没有混淆类型，当我在调试时将鼠标悬停在(typeof(ICollector))上时，它会清楚地显示SquidReports.DataCollector.Interface.ICollector.

当然，这确实有效：

Type[] interfaces = type.GetInterfaces();
if (interfaces.Any(t => t.Name == typeof(ICollector).Name))
{
    Console.WriteLine(@"'o/");
}

但这并没有告诉我很多，除了同名的类型这一事实。

此外，为什么此检查失败？

if (typeof(ICollector).Equals(typeof(ICollector)))
{
    Console.WriteLine("EQUALIZED");
}

为什么我的第一次相等性检查失败？更具体地说，类型相等在 C# 5.0 中如何工作？是否没有具体实现.等于（）为"类型"类型？

编辑：

应I Quality Catalyst的要求，下面的快速测试了如果在同一程序集中定义接口和类，则相等性是否会计算为true。这确实有效：

class Program
{
    public interface ITest
    {
    }
    public class Test : ITest
    {
        public int ID { get; set; }
    }
    static void Main(string[] args)
    {
        Type[] interfaces = (typeof(Test)).GetInterfaces();
        if (interfaces.Any(t => t == typeof(ITest)))
        {
            Console.WriteLine(@"'o/");
        }
    }
}

编辑2：这是ICollector的实现

public interface ICollector
{
    IDbRelay DbRelay { get; set; }
    ILogManager LogManager { get; set; }
    void Init(ILogManager logManager, IDbRelay dbRelay);
    void Execute();
}

但是，我相信我可能错过了一个重要的细节。我在这里使用三个程序集：

1. 我正在进行相等性检查的"主"（SquidReports.DataCollector）程序集
2. 包含 ICollector 的"接口"（SquidReports.DataCollector.Interface）组件
3. 包含 BESCollector 定义的"插件"（SquidReports.DataCollector.Plugin.BES）程序集

值得注意的是，"接口"（SquidReports.DataCollector.Interface）是从ReflectionOnlyAssemblyResolve事件加载的，如下所示，因为ReflectionOnlyLoadFrom（）不会自动解析依赖关系：

public Assembly ReflectionOnlyAssemblyResolve(object sender, ResolveEventArgs args)
{
    // This event is used to resolve dependency problems. We need to return the requested assembly in this method.
    // We should probably look in two locations:
    //   1. The SquidReports.DataCollector folder
    //   2. The Corresponding folder in SquidReports.DataCollector'Plugins    
    // Let's first turn the 'full' assembly name into something more compact
    AssemblyName assemblyName = new AssemblyName(args.Name);
    this.Logger.LogMessage(LogLevel.Debug, String.Format("Attempting to resolve Assembly {0} to load {0}", assemblyName.Name, args.RequestingAssembly.GetName().Name));
    // Let's also get the location where the requesting assembly is located
    DirectoryInfo pluginDirectory = Directory.GetParent(args.RequestingAssembly.Location);
    string assemblyFileName = String.Format("{0}.dll", assemblyName.Name);
    if (File.Exists(assemblyFileName))
    {
        // It's in the main bin folder, let's try to load from here
        return Assembly.ReflectionOnlyLoadFrom(assemblyFileName);
    }
    else if (File.Exists(Path.Combine(pluginDirectory.FullName, assemblyFileName)))
    {
        // It's in the plugin folder, let's load from there
        return Assembly.ReflectionOnlyLoadFrom(Path.Combine(pluginDirectory.FullName, assemblyFileName));
    }
    return null;
}

EDIT3：在下面Joe的建议下，我再次使用它调试了应用程序：

if (type.Name == "BESCollector")
{
    Type[] interfaces = type.GetInterfaces();
    Type interface1 = interfaces[0];
    Type interface2 = typeof(ICollector);
    Console.WriteLine("");
}

我复制了interface1和interface2的完整属性，然后将它们放在文件差异中。

我认为，结果可能已经解决了我的问题：

interface1描述如下：

interface1  {Name = "ICollector" FullName = "SquidReports.DataCollector.Interface.ICollector"}  System.Type {System.ReflectionOnlyType}

而interface2是这样描述的：

interface2  {Name = "ICollector" FullName = "SquidReports.DataCollector.Interface.ICollector"}  System.Type {System.RuntimeType}

那么我假设问题是由于{System.RuntimeType} ！= {System.ReflectionOnlyType}引起的，并且Assembly.ReflectionOnlyLoadFrom（）应该为此负责吗？