我将如何在功能上重新实现（或接近重新实现）C＃中的泛型？

Question

I want to be able to write a series of classes in an inheritance hierarchy. Each class has to have a member Foo of a type T specific to that class. In case it's relevant, no classes in this hierarchy will contain duplicate Foo classes.

My initial thought was to do this with generics. For example,

public class ExampleBase<T> where T: GenericType
{
    public T Foo
    {
        get;
        set;
    }
}

public class ExampleChildOne<T> : ExampleBase<T> where T : GenericTypeTwo {}

public class ExampleChildLeaf : ExampleChildOne<GenericTypeLeaf> {}

public class GenericType {}

public class GenericTypeTwo : GenericType {}

public class GenericTypeLeaf : GenericTypeTwo {}

With this code, I am able to write things like var foo = new ExampleChildLeaf().Foo; The variable is the type I want, which is GenericTypeLeaf. This is good. However, I am unable to do something like ExampleBase example = new ExampleChildLeaf(); because ExampleBase requires a generic type. I also can't do ExampleBase<GenericType> example = new ExampleChildLeaf(); because ExampleChildLeaf doesn't actually extend ExampleBase<GenericType> .

I've also tried a non-generic way to do this. Each class had its own Foo which had the proper type (so one would have a GenericType Foo, one would have GenericTypeLeaf Foo, etc.). The issue with this is that I can't override one Foo with a different one, since the types are different.

So. That all said, is there any way for me to functionally do something similar? It's okay if it's a bit convoluted, because this will be in a library that should pretty much never me modified. My goal is to make it as easy for the end user to use while abstracting away all of the generic arguments.

Also, I wasn't able to come up with a great way to phrase the title question. I would appreciate suggestions for that as well. Thanks!

Answer 1

When you want ExampleBase example = new ExampleChildLeaf(); , this would possible by creating a non-generic base class that didn't know about Foo , but could still have the other functionality (assuming there is other functionality). That's pretty similar to how Task and Task<T> work.

public class ExampleBase
{
    //....
}

public class ExampleBase<T> : ExampleBase where T: GenericType
{
    public T Foo
    {
        get;
        set;
    }
}