C# Linq.除功能外“其他功能”；至少有一个对象必须实现IComparable。”；

基本上我有一个实现IEquatable的容器（如下所示的示例）

公共类容器类：IEquatable
{
公共IEnumerable自定义类{get；set；}
公共覆盖布尔等于（对象对象对象）{…}
公共布尔等于（容器类其他）{…}
公共静态布尔运算符==（容器类cc1，容器类cc2）{…}
公共静态布尔运算符！=（容器类cc1，容器类cc2）{…}
公共重写int GetHashCode（）{…}
}

以及一个CustomClass，它还实现了IEquatable

public class CustomClass : IEquatable<CustomClass>
{
        public string stringone { get; set; }
        public string stringtwo { get; set; }

        public override bool Equals(object obj) { ... }
        public bool Equals(CustomClass other) { ... }
        public static bool operator ==(CustomClass cc1, CustomClass cc2) { ... }
        public static bool operator !=(CustomClass cc1, CustomClass cc2) { ... }
        public override int GetHashCode() { ... }
}

public类CustomClass:IEquatable
{
公共字符串stringone{get；set；}
公共字符串stringtwo{get；set；}
公共覆盖布尔等于（对象对象对象）{…}
公共布尔等于（自定义类其他）{…}
公共静态布尔运算符==（CustomClass cc1，CustomClass cc2）{…}
公共静态布尔运算符！=（CustomClass cc1，CustomClass cc2）{…}
公共重写int GetHashCode（）{…}
}

所有这些都可以正常工作，例如，下面的工作

IEnumerable<CustomClass> customclassone = new List<CustomClass>
    {
        new CustomClass { stringone = "hi" },
        new CustomClass { stringone = "lo" }
    };
IEnumerable<CustomClass> customclasstwo = new List<CustomClass>
    {
        new CustomClass { stringone = "hi" }
    };

var diff = customclassone.Except(customclasstwo);

ContainerClass containerclassone = new ContainerClass 
{
    CustomClass = customclassone.AsEnumerable()
};
ContainerClass containerclasstwo = new ContainerClass 
{
    CustomClass = customclasstwo.AsEnumerable()
};

var diff2 = containerclassone.CustomClass.Except(customclasstwo.CustomClass);

IEnumerable customclassone=新列表
{
新自定义类{stringone=“hi”}，
新自定义类{stringone=“lo”}
};
IEnumerable CustomClass2=新列表
{
新自定义类{stringone=“hi”}
};
var diff=customclassone.Exception（CustomClassII）；
ContainerClass containerclassone=新的ContainerClass
{
CustomClass=customclassone.AsEnumerable（）
};
ContainerClass containerclasstwo=新的ContainerClass
{
CustomClass=customclasstwo.AsEnumerable（）
};
var diff2=containerclassone.CustomClass.Exception（CustomClass2.CustomClass）；

在此代码之后，枚举时diff和diff2都包含预期的结果。然而，如果我尝试

IEnumerable<CustomClass> oldCustom = oldContainerClass.CustomClass;
IEnumerable<CustomClass> newcustom = newContainerClass.CustomClass;
var exceptlist = oldCustom.Except(newcustom);

IEnumerable oldCustom=oldContainerClass.CustomClass；
IEnumerable newcustom=newContainerClass.CustomClass；
var exceptlist=oldCustom.Except（newcustom）；

---

当我尝试枚举exceptlist时，我得到“至少有一个对象必须实现IComparable”。oldCustom和newCustom与上述工作示例中的唯一区别在于它们的填充方式。有人知道为什么会发生这种情况吗？

我怀疑您试图对

ContainerClass.CustomClass的这些内容进行排序。由于延迟执行，在迭代之前您不知道有问题，而
Except（）
只是一种转移注意力的方法
CustomClass
未实现
IComparable
接口，因此排序失败并出现该错误。您的
CustomClass
应该实现
IComparable
接口，或者您应该在
OrderBy（）上传入一个
icomparaler

e、 g

尽管这将有助于了解您为这些属性分配的确切内容，以便我们可以为您提供更准确的原因。
如果您不介意的话，我把代码压缩了一点，这样我们就不必做太多的滚动来阅读它。你能提供
oldcontainerclass
和
newcontainercals
的代码吗？你能生成一个简短但完整的程序来演示这个问题吗？我不明白为什么仅仅从您展示的代码中就会出现这种情况。（您不应该需要==和！=运算符来演示它。）您可能是对的。。。除了不需要IComparable之外，我很笨，你右边的一个在CustomClass中获取变量哈希代码的代码试图排序，但没有比较器
IEnumerable<CustomClass> oldCustom = oldContainerClass.CustomClass;
IEnumerable<CustomClass> newcustom = newContainerClass.CustomClass;
var exceptlist = oldCustom.Except(newcustom);

oldContainerClass.CustomClass = someListOfSomeType.OrderBy(x => x.CustomClasss, myComparer)
                                                  .Select(x => x.CustomClass);