How can I use a type with generic arguments as a constraint?

Question

I would like to specify a constraint which is another type with a generic argument.

class KeyFrame<T>
{
    public float Time;
    public T Value;
}

// I want any kind of Keyframe to be accepted
class Timeline<T> where T : Keyframe<*>
{
}

But this cannot be done in c# as of yet, (and I really doubt it will ever be). Is there any elegant solution to this rather than having to specify the type of the keyframe argument?:

class Timeline<TKeyframe, TKeyframeValue> 
     where TKeyframe : Keyframe<TKeyframeValue>,
{
}

Answer 1

As TimeLine is most likely an aggregation of KeyFrames, wouldn't something like:

class TimeLine<T>
{
private IList<KeyFrame<T>> keyFrameList;
...
}

fulfill your requirements nicely?

Answer 2

If the type T that Timeline<T> represents is the same as the type KeyFrame<T> represents you can just go with:

class Timeline<T>
{
  List<KeyFrame<T>> _frames = new List<KeyFrame<T>>(); //Or whatever...

  ...
}

If type T represents something different between the classes that implies that Timeline<T> can contain multiple types of KeyFrame's in which case you should create a more abstract implementation of KeyFrame and use that in Timeline<T>.

Answer 3

Read about this from Eric Lippert's blog Basically, you have to find a way to refer to the type you want without specifying the secondary type parameter.

In his post, he shows this example as a possible solution:

public abstract class FooBase
{
  private FooBase() {} // Not inheritable by anyone else
  public class Foo<U> : FooBase {...generic stuff ...}

  ... nongeneric stuff ...
}

public class Bar<T> where T: FooBase { ... }
...
new Bar<FooBase.Foo<string>>()

Hope that helps, Troy

Answer 4

Maybe nesting Timeline inside KeyFrame would make sense in your design:

class KeyFrame<T> { 
  public float Time; 
  public T Value; 

  class Timeline<U> where U : Keyframe<T> { 
  } 
}