C# 自泛型类型

我正在构建以下类：

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

---

这是可以实现的吗？如果是，如何使用？

类似于自约束的东西将允许您公开派生类型，同时还可以约束：

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

抽象类Foo，其中T:Foo
{
受保护的抽象无效进程（FooProcessor）；
}

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

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

类FooChild:Foo
{
受保护的覆盖无效进程（FooProcessor）
{
}
}

但请注意，这种设计往往只有一小部分用途。此外，如果不指定它的泛型类型，就无法将

Foo

作为基引用

还有一个关于如何滥用这个设计的问题，所以你可能想考虑你希望通过你的受保护方法直接引用派生类。 您最好使用接口来封装您试图实现的行为。

您的意思是：

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)
    {
    }
}

类处理器 { } 抽象类Foo { 受保护的抽象无效进程（FooProcessor）； } Foo类儿童：Foo { 受保护的覆盖无效进程（FooProcessor） { } } 使用接口更容易实现：

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>
{
}

接口处理器
{
}
接口Foo
{
无效处理（FooProcessor）；
}
Foo类儿童：Foo
{
void Foo.Process（Foo处理器）
{
this.Process（（FooProcessorFooChild）处理器）；
}
受保护的无效进程（FooProcessorFooChild处理器）
{
}
}
类FooProcessorFooChild:FooProcessor
{
}

我认为这是不可能的，因为Foo是泛型的——没有非泛型的Fooclass@SergeyMetlov我以前见过这种方法能够从基类型向派生类公开强类型引用，它总是感觉有点倒退，老实说，我个人并不需要使用这种方法。@SergeyBerezovskiy抱歉，我忘记了

Foo

约束的一般参数。

FooChild:Foo

这很奇怪。。有没有办法避免这种令人困惑的签名？@SergeyMetlov:第二个更好吗？注：我个人更喜欢第一个。和我一样。更复杂。@Patrickhoffman:事实上，请不要删除它。如果没有其他选择，这里的一些评论对未来的读者来说就没有任何意义了。@O.R.Mapper:rollback！

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>
{
}