Question

我正在构建以下类：

abstract class Foo
{
    protected abstract void Process(FooProcessor<T> processor)
}

我需要的是让T成为子Foo类的类型：

class FooChild : Foo
{
    protected override void Process(FooProcessor<FooChild> processor)
    {
    }
}

可以实现吗？如果是这样，怎么样？

Answer 1

像自我约束这样的东西会让你暴露派生类型并同时约束：

abstract class Foo<T> where T : Foo<T>
{
    protected abstract void Process(FooProcessor<T> processor);
}

然后派生类型将自己定义为目标：

class FooChild : Foo<FooChild>
{
    protected override void Process(FooProcessor<FooChild> processor)
    {
    }
}

请注意，此设计往往只有一小部分用途。此外，您无法指定Foo作为基础而无需指定其泛型类型。

还有一个关于如何滥用此设计的blog post from Eric Lippert，因此您可能希望通过希望让受保护的方法直接引用派生类来考虑您实际尝试实现的目标。

您可能最好使用接口来封装您尝试实现的行为。

Answer 2

你的意思是：

class FooProcessor<T>
{
}

abstract class Foo<T>
{
    protected abstract void Process(FooProcessor<T> processor);
}

class FooChild : Foo<FooChild>
{
    protected override void Process(FooProcessor<FooChild> processor)
    {
    }
}

使用界面实现起来会更容易：

interface FooProcessor<T>
{
}

interface Foo<T>
{
    void Process(FooProcessor<T> processor);
}

class FooChild : Foo<FooChild>
{
    void Foo<FooChild>.Process(FooProcessor<FooChild> processor)
    {
        this.Process((FooProcessorFooChild)processor);
    }

    protected void Process(FooProcessorFooChild processor)
    {
    }
}

class FooProcessorFooChild : FooProcessor<FooChild>
{
}

自我泛型

2 个答案: