继承通用抽象

Question

我不确定这是否可能，希望得到一些澄清。

我有一个这样的类结构：

public class FooBase
{
    //Some base class
}

public class BarBase
{
    //Some base class    
}

public class Foo : FooBase
{
    //Implementation
}

public class Bar : BarBase
{
    //Implementation
}

public abstract class FooBarHolderAbstract<T, V> where T: FooBase where V: BarBase
{
}

public class MyFooBarHolderImpl : FooBarHolderAbstract<Foo, Bar>
{
}

public class FooBarTest
{
    public void DoSomethingWithFooBar<T>() where T : FooBarHolderAbstract<FooBase, BarBase>
    {
        //Do something tith the obj
    }

    public void RunTest()
    {
        //This doesn't work, compiler says MyFooBarHolder is not convertible to FooBarHolderAbstract<FooBase, BarBase>
        DoSomethingWithFooBar<MyFooBarHolderImpl>();
    }
}

在 FooBarTest 类中，我想创建一个接受泛型参数的方法，该方法继承自具有两个泛型参数的抽象类。 MyFooBarHolderImpl 类扩展了抽象基类，并使用继承自抽象类的泛型参数类型的类型指定其泛型参数。

当我尝试调用此方法 (DoSomethingWithFooBar()) 时，编译器告诉我 MyFooBarHolderImpl 类型必须可转换为 FooBarHolderAbstract

这是根本无法完成的事情，还是我缺少概念/语法？

提前致谢！

Answer 1

不清楚，你要在DoSomethingWithFooBar做什么，因为你没有传递任何参数，但这里有另一种选择：

public class FooBarTest
{
    public void DoSomethingWithFooBar<TFooBase, TBarBase>(FooBarHolderAbstract<TFooBase, TBarBase> obj) 
        where TFooBase : FooBase
        where TBarBase : BarBase
    {
        //Do something tith the obj
    }

    public void RunTest()
    {
        DoSomethingWithFooBar<Foo, Bar>(new MyFooBarHolderImpl());
    }
}

或

public class FooBarTest
{
    public void DoSomethingWithFooBar<TFooBase, TBarBase, THolder>() 
        where TFooBase : FooBase
        where TBarBase : BarBase
        where THolder : FooBarHolderAbstract<TFooBase, TBarBase>
    {
        //Do something tith the obj
    }

    public void RunTest()
    {
        DoSomethingWithFooBar<Foo, Bar, MyFooBarHolderImpl>();
    }
}

Answer 2

你必须写你的FooBarTest 如下。您必须将T 的DoSomethingWithFooBar<T> 定义为FooBarHolderAbstract<Foo, Bar>

    public class FooBarTest
    {
        public void DoSomethingWithFooBar<T>() where T : FooBarHolderAbstract<Foo, Bar>
        {
            //Do something tith the obj
        }

        public void RunTest()
        {                         
            DoSomethingWithFooBar<MyFooBarHolderImpl>();
        }
    }

Answer 3

好吧，它不能直接完成 - FooBarHolderAbstract<Foo, Bar> 不是 FooBarHolderAbstract<FooBase, BarBase>。目前尚不清楚您是否可以在逻辑上拥有它，因为我们不知道抽象类中有什么。

您基本上是在寻找generic covariance，但无论如何类都不支持 - 所以您可能想要引入一个接口：

public interface IFooBarHolder<out T, out V>
    where T: FooBase
    where V: BarBase
{
    // Define what you need in here
}

public abstract class FooBarHolderAbstract<T, V> : IFooBarHolder<T, V>
    where T : FooBase
    where V : BarBase
{

}

此时，您可以将FooBarTest 更改为：

public void DoSomethingWithFooBar<T>() where T : IFooBarHolder<FooBase, BarBase>
{
    //Do something with the obj
}

...因为IFooBarHolder<Foo, Bar> 是 IFooBarHolder<FooBase, BarBase>。

但是，这仅在您可以为在“out”位置使用T 和V 的接口定义所有操作时才有效，例如从方法返回类型。如果您需要它们在“输入”位置，例如作为方法参数，你被卡住了——因为期望 Foo 的方法无法处理任何其他类型的 FooBase。