title: Inheritance design using Interface + abstract class. Good practice?
body: <p>I'm not really sure how to title this question but basically I have an interface like this:</p>
  
  <pre><code>public interface IFoo
  {
      string ToCMD();
  }
  </code></pre>
  
  <p>a couple of absract classes which implement IFoo like:</p>
  
  <pre><code>public abstract class Foo : IFoo
  {
     public abstract string ToCMD();
  }
  
  public abstract class Bar : IFoo
  {
      public abstract string ToCMD();
  }
  </code></pre>
  
  <p>then classes which inherit Foo and Bar:</p>
  
  <pre><code>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.
  </code></pre>
  
  <p>I am doing this so that when I have my custom list like:</p>
  
  <pre><code>public class Store&lt;T&gt; : List&lt;T&gt;  where T : IFoo {}
  </code></pre>
  
  <p>I then can restrict the types that go in it but by having the interface it will still take any type of IFoo.</p>
  
  <p>Something like:</p>
  
  <pre><code>Store&lt;Foo&gt; store = new Store&lt;Foo&gt;(); //Only Foo types will work.
  store.Add(new FooClass1()); //Will compile.
  
  Store&lt;IFoo&gt; store = new Store&lt;IFoo&gt;(); //All IFoo types will work.
  store.Add(new FooClass1()); //Will compile.
  store.Add(new BarClass()); //Will compile.
  </code></pre>
  
  <p>My question is:  Is this an ok way of going about this? or is there a better way?</p>
  
  <p>EDIT: Picture->
  <img src="https://i.stack.imgur.com/RqPPj.jpg" alt="alt text"></p>