4

在使用泛型对象时，我在弄清楚如何要求类扩展接口时遇到了一些麻烦。我发现这很难解释，但我希望在创建我的通用对象时能够需要一个类和一个接口。

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

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");
        }
    }
}

正如您从代码中的内联注释中看到的那样，我希望该列表BigList要求添加的对象扩展Base AND实现IComparable<Base>。这并不是真正的多重继承，因为它只是一个类（和一个接口）。

有谁知道这样做的方法？

编辑

感谢大家的评论。基本上答案有两种形式：创建一个中级类，或者使用List<IComparable<Base>>. #2 不是一个选项，因为 Base 中有我们确实需要的逻辑。#1 是最可行的选择，也是我们不情愿的选择。这种方法的问题是这将在实际的类层次结构中增加的混乱和复杂性。

不管 C# 是否不允许我们做我们想做的事，那么我们将不得不使用中间类来做。谢谢大家。

4

4 回答 4

7

那这个呢：

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<Base>，否则您可以声明Base为

abstract class Base : IComparable<Base> {
}
于 2012-05-11T15:19:22.533 回答
0

为什么不创建另一个继承基并实现 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 >();
于 2012-05-11T15:22:31.823 回答
0

如果您将 Bi​​gList 设置为List<IComparable<Base>>应该获得您在 Check 方法中显示的行为。

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");
    }
}
于 2012-05-11T15:24:38.313 回答
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

你可以比较为：

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");
    }
}
于 2012-05-11T15:28:05.070 回答