Question

I’ve got two generic base classes. The second generic class has a constraint on its parameter of the first class.

abstract class FirstClass<T> {...}

abstract class SecondClass<U> where U : FirstClass {...}

This does not work, because FirstClass is not defined. So I need to do this.

abstract class FirstClass<T> {...}

abstract class SecondClass<U, T> where U : FirstClass<T> {...}

Which works. However, this makes implementing these abstract classes ugly.

class SomeClass {...}

class MyFirstClass : FirstClass<SomeClass> {...}

class MySecondClass : SecondClass<MyFirstClass, SomeClass> {...}

This seems redundant to me because I’m specifying SomeClass twice. Is there a way to declare it in such a way that T from FirstClass is automatically the U for SecondClass. What I would really like this to look like is.

class SomeClass {...}

class MyFirstClass : FirstClass<SomeClass> {...}

class MySecondClass : SecondClass<MyFirstClass> {...}

While I doubt this exact scenario is possible, is there a cleaner what to do what I am trying to do?

Edit

Several people have suggested making an IFirstClass interface. But my definitions are closer to this.

class FirstClass<T>
{
    public T MyObj { get; set; }
}

class SecondClass<U, T> where U : FirstClass<T>
{
    U MyFirstClass { get; set; }
}

With an interface I cannot access MyFirstClass.MyObj from SecondClass. While I could create a object T MyObj { get; set; } on IFirstClass, then use new to hide it, silverlight throws a fit in the binding if I do this.

Answer 1

If you are actually using the generic type arguments to FirstClass (as, from your edit, it sounds like you are), then no, what you’re looking for is unfortunately not possible. The compiler does not differentiate between type arguments that are related and those that are not.