Explicit implementation of interface's GetEnumerator causes stack overflow
<p>I'm doing my best to code against interfaces whenever possible, but I'm having some issues when it comes to collections. For example, here are a couple interfaces I'd like to use.</p>

<pre><code>public interface IThing {}

public interface IThings : IEnumerable&lt;IThing&gt; {}
</code></pre>

<p>Here are the implementations. In order to implement IEnumerable&lt;IThing&gt; I need to explicitly implement IEnumerable&lt;IThing&gt;.GetEnumerator() in Things.</p>

<pre><code>public class Thing : IThing {}

public class Things : List&lt;Thing&gt;, IThings
{
    IEnumerator&lt;IThing&gt; IEnumerable&lt;IThing&gt;.GetEnumerator()
    {
        // This calls itself over and over
        return this.Cast&lt;IThing&gt;().GetEnumerator();
    }
}
</code></pre>

<p>The problem is that the GetEnumerator implementation causes a stack overflow. It calls itself over and over again. I can't figure out why it'd decide to call that implementation of GetEnumerator instead of the implementation provided by the result of this.Cast&lt;IThing&gt;(). Any ideas what I'm doing wrong? I'm willing to bet it's something extremely silly...</p>

<p>Here's some simple test code for the above classes:</p>

<pre><code>static void Enumerate(IThings things)
{
    foreach (IThing thing in things)
    {
        Console.WriteLine("You'll never get here.");
    }
}

static void Main()
{
    Things things = new Things();
    things.Add(new Thing());

    Enumerate(things);
}
</code></pre>
