如何将子类型传递给父 class C# 中的泛型

Question

I am currently consuming a third party dll and have no option to switch off of it or not use it. I have a class that looks like this:

public abstract class ParentClass<T> : ApiClass<T> where T : ApiClass<T>
{
    //...stuff
}

This causes a few problems if I want to make a Dictionary or return the ParentClass type so that I don't need to know which child class it is beforehand. To make it easier to develop around this I would like to do something like this:

//ChildClass should be what is passed to the generic, without directly referencing it
public abstract class ParentClass : ApiClass<InheritedClass>
{
    //...stuff
}

public class ChildClass : ParentClass
{

}

//Now I could define a dictionary like
Dictionary<KeyClass, ParentClass> Map;

Defining it like the second example would allow me to create a Dictionary as where the first one I'm not sure I can define a Dictionary when I don't have a value for the Generic? A bit more info about the ApiClass, the definition for the ApiClass looks like this:

public abstract class ApiClass<Wrapper> : OtherApiClass where Wrapper : ApiClass<Wrapper>
{
    //...Stuff
}

So in a scenario like this, how would I define my ParentClass without a Generic, but where the type passed to ApiClass is the child class of the ParentClass (the ApiClass explicitly needs the child type)?

Edit: Clarified a bit on the value of InheritedClass

Edit2: I am not looking for alternatives, I am asking for how to. If I pass anything other than the last inherited class (the current ParentClass I defined at the beginning of the question) the Api will crash. If the syntax existed it would look something like

public abstract class ParentClass : ApiClass<typeof(this)>

Answer 1

I imagine that the third-party library you're using defines ApiClass like this:

public abstract class ApiClass<T> where T : ApiClass<T>

That's an example of the Curiously recurring template pattern .

Let's turn this in to a concrete example:

public abstract class ApiClass<T> where T : ApiClass<T>
{
    public abstract T GetNewInstance();
}

If I had that code, I could consume it like this:

public class MyApiClass : ApiClass<MyApiClass>
{
    public override MyApiClass GetNewInstance()
    {
        return new MyApiClass();
    }
}

This allows MyApiClass to have an method, defined as an abstract method in that parent class, that knows about the current instance. Eric Lippert discusses this here .

It has the downside that it can be abused:

public class MyNefariousApiClass : ApiClass<MyApiClass>
{
    public override MyApiClass GetNewInstance()
    {
        throw new NotImplementedException();
    }
}

That's legal, but C# doesn't have a way of enforcing that you use class itself as the generic parameter. If we had class MyNefariousApiClass: ApiClass<this> it would, but we don't.

Now, when you say you have a class public abstract class ParentClass<T>: ApiClass<T> where T: ApiClass<T> that that's your code for consuming the third-party library.

If so, then that's not the normal way to consume this pattern. If you're overriding the class it should look like this:

public abstract class ParentClass<T> : ApiClass<T> where T : ParentClass<T>

We can then take this to it's final point and define the ChildClass like so:

public class ChildClass : ParentClass<ChildClass>
{ }

Now, if you want a dictionary that can hold any such ChildClass then you are stuck as the parent is generic. The only somewhat sensible workaround is to use an interface.

public interface IParent
{ }

public abstract class ParentClass<T> : ApiClass<T>, IParent where T : ParentClass<T> 
{ }

Then you can write Dictionary<KeyClass, IParent> dictionary = new... .