Não tenho muita certeza de como nomear essa pergunta, mas basicamente tenho uma interface como esta:

public interface IFoo
{
    string ToCMD();
}

algumas classes absract que implementam o IFoo, como:

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

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

então classes que herdam Foo e 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.

Estou fazendo isso para que quando eu tiver minha lista personalizada, como:

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

Em seguida, posso restringir os tipos que o compõem, mas, tendo a interface, ainda será necessário qualquer 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.

Minha pergunta é: essa é uma maneira correta de fazer isso? Ou há um jeito melhor?

EDIT: Imagem->