Question

我有一个像这样的基类：

class FooBase
{
    public bool Do(int p) { /* Return stuff. */ }
}

这样的儿童班：

class Foo<T> : FooBase
{
    private Dictionary<T, int> Dictionary;

    public bool Do(T p)
    {
        int param;
        if (!Dictionary.TryGetValue(p, out param))
            return false;
        return base.Do(param);
    }
}

如果用户创建一个名为“fooString”的Foo<string>对象，那么他可以同时调用fooString.Do(5)和fooString.Do("test")但是如果他创建一个名为“fooInt”的Foo<int>对象，他只能调用派生类的Do方法。无论T是什么，我都更喜欢第二种。

这两个类中的Do方法基本上都做同样的事情。派生类中的一个使用给定参数从Dictionary<T, int>获取整数，并使用它调用基类的Do方法。

这就是为什么我要在FooBase中隐藏Foo<T>的Do方法。我怎样才能实现这个或类似的东西？任何克服这一点的设计建议都会很好。

Answer 1

但是如果他创建一个名为“fooInt”的Foo<int>对象，他只能调用派生类的Do方法。

不，那不是真的。如果声明的变量类型为FooBase，它仍将调用FooBase方法。你并没有真正阻止访问FooBase.Do - 你只是隐藏它。

FooBase foo = new Foo<int>();
foo.Do(5); // This will still call FooBase.Do

显示以下内容的完整示例代码：

using System;

class FooBase
{
    public bool Do(int p) { return false; }
}

class Foo<T> : FooBase
{
    public bool Do(T p) { return true; }
}

class Test
{
    static void Main()
    {
        FooBase foo1 = new Foo<int>();
        Console.WriteLine(foo1.Do(10)); // False

        Foo<int> foo2 = new Foo<int>();
        Console.WriteLine(foo2.Do(10)); // True
    }
}

这就是我想在Foo中隐藏FooBase的Do方法的原因。

您需要考虑Liskov's Substitutability Principle。

Foo<T>不应来自FooBase（使用合成而非继承）或 FooBase.Do不应该可见（例如，使其受到保护）。

Answer 2

您可以使用protected Do方法构建一个抽象的基类，并重写当前的FooBase类以继承Foo<T>：

public abstract class FooBaseAbstract
{
    protected bool Do(int p)
    {
        return true;
    }
}

// You can use this one just as your current FooBase class
public class FooBase : Foo<int>
{
}

public class Foo<T> : FooBaseAbstract
{
    public bool Do(T p)
    {
        if (true /* some test here */)
        {
            return base.Do(4);
        }

        return false;
    }
}

（当然改变了班级名称）

隐藏通用派生类中的基类方法

2 个答案: