No estoy realmente seguro de cómo titular esta pregunta, pero básicamente tengo una interfaz como esta:

public interface IFoo
{
    string ToCMD();
}

un par de clases de absract que implementan IFoo como:

public abstract class Foo : IFoo
{
   public abstract string ToCMD();
}

public abstract class Bar : IFoo
{
    public abstract string ToCMD();
}

luego clases que heredan Foo y Bar:

public class FooClass1 : Foo
{
    public override string ToCMD()
    {return "Test";}
} ///there are about 10 foo classes.

public class BarClass : Bar
{
    public override string ToCMD()
    {return "BarClass";}
} ///about the same for bar classes.

Estoy haciendo esto para que cuando tenga mi lista personalizada como:

public class Store<T> : List<T>  where T : IFoo {}

Entonces puedo restringir los tipos que van en él, pero al tener la interfaz, todavía tomará cualquier tipo de IFoo.

Algo como:

Store<Foo> store = new Store<Foo>(); //Only Foo types will work.
store.Add(new FooClass1()); //Will compile.

Store<IFoo> store = new Store<IFoo>(); //All IFoo types will work.
store.Add(new FooClass1()); //Will compile.
store.Add(new BarClass()); //Will compile.

Mi pregunta es: ¿Es esta una forma correcta de hacer esto? ¿O hay un mejor camino?

EDITAR: Imagen->