继承返回泛型类型的函数

Question

I'm attempting to write two classes, call 'em Parent and Child.

parent is an abstract class that defines a function that returns a (sort of) generic type

public abstract class Parent
{
     public abstract KeyValuePair<K,V> foo(someInputs);
}

with the intention being that Child can override this function to return a KeyValuePair with different types as the key and value.

public abstract class Child
{
     public override KeyValuePair<string,int> foo(someInputs)
     {
          return(new KeyValuePair<string,int>(someInput1,someInput2);
     }
}

This achieves the goal of communicating to the user developing the child(future me) that the function needs to return a KeyValuePair, but that I am free to use whatever KeyValuePair I want.

Unfortunately though it seems the only way to achieve this is to also make the class generic,

public abstract class Parent<K,V>

and pass K and V down to the abstract function.

This means that when I am writing the child, I need to define the same types for the class (which is now generic) and function return. If they do not match, the compiler poops itself (with good reason).

Is there a way to have these "semi generic" return types without making the class generic?

Answer 1

Classes with different generic parameters are totally different things.

KeyValuePair<string, int>

KeyValuePair<string, Graphics>

For example, the above two KeyValuePairs are not interchangeable.

Let say, you have 2 child classes:

public abstract class Child1 : Parent
{
    public override KeyValuePair<string, int> foo() { ... }
}

public abstract class Child2 : Parent
{
    public override KeyValuePair<string, Graphics> foo() { ... }
}

Parent class has no way to satisfy both children in one declaration.

free to use whatever KeyValuePair I want

Therefore, such freedom is not logically correct.

Answer 2

You can have children implement a generic interface and a non-generic base class (if necessary)?

public abstract Parent
{
   // common non-generic methods
}

public interface IFooable<T>
{
    KeyValuePair<string, T> Foo();
}

public class Child1 : Parent, IFooable<int>
{
    public virtual KeyValuePair<string, int> Foo()
    {
    }
}

public class Child2 : Parent, IFooable<string>, IFooable<bool>
{
    public KeyValuePair<string, string> Foo()
    {
    }

    public KeyValuePair<string, bool> Foo()
    {
    }
}