C# 使用类和接口定义泛型对象

在处理泛型对象时，我很难理解如何要求类扩展接口。我发现这很难解释，但我希望在创建泛型对象时能够需要一个类和一个接口

我已经创造了我能想到的最简单的版本——希望这能更好地解释我的问题

abstract class Base
{}
class Class1 : Base, IComparable<Base>
{
    public int CompareTo(Base other)
    {
        return GetHashCode().CompareTo(other.GetHashCode());
    }
}
class Class2 : Base, IComparable<Base>
{
    public int CompareTo(Base other)
    {
        return GetHashCode().CompareTo(other.GetHashCode());
    }
}
class Class3 : Base
{}
class Program
{
    // This list should only accept objects that extend (Base & IComparable<Base>)
    public static List<Base> BigList = new List<Base>();

    static void Main(string[] args)
    {
        Class1 c1 = new Class1();
        Class2 c2 = new Class2();
        Class3 c3 = new Class3();
        BigList.Add(c1);
        BigList.Add(c2);
        // This should not be allowed because Class3 does not extend IComparable<Base>
        BigList.Add(c3);

        Check(new Class1());
    }
    public static void Check(Base bb)
    {
        foreach (Base b in BigList)
        {
            // Assert that this is true
            IComparable<Base> c = (IComparable<Base>)b;

            if (c.CompareTo(bb) < 0)
                Console.WriteLine("Less Than");
            else if (c.CompareTo(bb) == 0)
                Console.WriteLine("Equal");
            else if (c.CompareTo(bb) > 0)
                Console.WriteLine("Greater Than");
        }
    }
}

抽象类基类
{}
类1：基，i可比较
{
公共整数比较（基本其他）
{
返回GetHashCode（）.CompareTo（other.GetHashCode（））；
}
}
类别2：基础，可比较
{
公共整数比较（基本其他）
{
返回GetHashCode（）.CompareTo（other.GetHashCode（））；
}
}
第三类：基本类
{}
班级计划
{
//此列表应仅接受扩展的对象（基本和IComparable）
public static List BigList=new List（）；
静态void Main（字符串[]参数）
{
Class1 c1=新的Class1（）；
Class2 c2=新的Class2（）；
Class3 c3=新的Class3（）；
添加（c1）；
添加（c2）；
//这是不允许的，因为Class3不扩展IComparable
添加（c3）；
检查（新类别1（））；
}
公共静态无效检查（基本bb）
{
foreach（BigList中的基b）
{
//断言这是真的
i可比c=（i可比）b；
如果（c.CompareTo（bb）<0）
控制台。写入线（“小于”）；
如果（c.CompareTo（bb）==0）
控制台。写入线（“相等”）；
如果（c.CompareTo（bb）>0）
控制台。写入线（“大于”）；
}
}
}

从代码中的内联注释可以看出，我希望列表

BigList

要求添加的对象扩展

Base

并实现

IComparable

。但这并不是真正的多重继承，因为它只是一个类（和一个接口）

有人知道这样做的方法吗

编辑

谢谢大家的评论。基本上，答案有两种：创建一个中间类，或者使用

List

#2不是一个选项，因为在我们实际需要的基础中有逻辑#1是最可行的选择，也是我们勉强同意的选择。这种方法的问题是，这会在实际的类层次结构中增加混乱和复杂性

不管C#不让我们做我们想做的事情，我们都必须用中间类来做。谢谢大家。

这个怎么样：

abstract class Base {
}

abstract class Intermediate : Base, IComparable<Base> {
}

class Class1 : Intermediate {
}

class Class2 : Intermediate {
}

class Class3 : Base {
}

public static List<Intermediate> BigList = new List<Intermediate>();
BigList.Add(new Class1()); // ok
BigList.Add(new Class2()); // ok
BigList.Add(new Class3()); // error

---

为什么不创建另一个继承base并实现IComparable的类呢

public class ComparableBase :Base, IComparable<Base>
{
....
}

class Class2 : ComparableBase 
{
    public int CompareTo(Base other)
    {
        return GetHashCode().CompareTo(other.GetHashCode());
    }
}

public static List<ComparableBase > BigList = new List<ComparableBase >();

public class compariablebase:Base，iCompariable
{
....
}
类别2：可比数据库
{
公共整数比较（基本其他）
{
返回GetHashCode（）.CompareTo（other.GetHashCode（））；
}
}
public static List BigList=new List（）；

如果您将BigList设置为一个

列表，该列表应获得您在检查方法中显示的行为

public static List<IComparable<Base>> BigList = new List<IComparable<Base>>();
static void Main(string[] args)
{
    Class1 c1 = new Class1();
    Class2 c2 = new Class2();
    Class3 c3 = new Class3();
    BigList.Add(c1);
    BigList.Add(c2);
    // This will now cause a compile error
    // BigList.Add(c3);

    Check(new Class1());
}

public static void Check(Base bb)
{
    foreach (IComparable<Base> c in BigList)
    {
        if (c.CompareTo(bb) < 0)
            Console.WriteLine("Less Than");
        else if (c.CompareTo(bb) == 0)
            Console.WriteLine("Equal");
        else if (c.CompareTo(bb) > 0)
            Console.WriteLine("Greater Than");
    }
}

publicstaticlist BigList=newlist（）；
静态void Main（字符串[]参数）
{
Class1 c1=新的Class1（）；
Class2 c2=新的Class2（）；
Class3 c3=新的Class3（）；
添加（c1）；
添加（c2）；
//这将导致编译错误
//添加（c3）；
检查（新类别1（））；
}
公共静态无效检查（基本bb）
{
foreach（BigList中的i可比较c）
{
如果（c.CompareTo（bb）<0）
控制台。写入线（“小于”）；
如果（c.CompareTo（bb）==0）
控制台。写入线（“相等”）；
如果（c.CompareTo（bb）>0）
控制台。写入线（“大于”）；
}
}
IMO，没有中间类的实现可以这样做：

abstract class Base{}

class Class1 : Base, IComparable<Base>{}

class Class2 : Base, IComparable<Base>{}

class Class3 : Base{}

var BigList = new List<IComparable<Base>>();

BigList.Add(new Class1());
BigList.Add(new Class2());
BigList.Add(new Class3()); // error

抽象类基类{}
类Class1：基，i可比较{}
类2：基，IComparable{}
类3：基{}
var BigList=新列表（）；
添加（新的Class1（））；
添加（新类2（））；
添加（新类3（））；//错误

您可以比较如下：

public static void Check(Base BB){
 foreach (var c in BigList)
    {
        if (c.CompareTo(bb) < 0)
            Console.WriteLine("Less Than");
        else if (c.CompareTo(bb) == 0)
            Console.WriteLine("Equal");
        else if (c.CompareTo(bb) > 0)
            Console.WriteLine("Greater Than");
    }
}

公共静态无效检查（基本BB）{
foreach（BigList中的var c）
{
如果（c.CompareTo（bb）<0）
控制台。写入线（“小于”）；
如果（c.CompareTo（bb）==0）
控制台。写入线（“相等”）；
如果（c.CompareTo（bb）>0）
控制台。写入线（“大于”）；
}
}
如果不创建自己的数据结构、重构类层次结构或创建Add（）helper方法，就不可能实现所需的功能。为什么不将类型列表（）设为BigList？//这是不允许的，因为Class2不扩展IComparable>>>Class2:Base，IComparable，er我不想打断它，但class 2确实扩展了它；）然而，第三班有not@Osiris：差不多概括了我的想法。你不能用List来做，你必须用List来做，但我可以创建一个不从基继承的类，它可以存储在List中：class NoBase:ICombarable{}。我认为这是他的一个条件。
public static void Check(Base BB){
 foreach (var c in BigList)
    {
        if (c.CompareTo(bb) < 0)
            Console.WriteLine("Less Than");
        else if (c.CompareTo(bb) == 0)
            Console.WriteLine("Equal");
        else if (c.CompareTo(bb) > 0)
            Console.WriteLine("Greater Than");
    }
}