为什么 C# 编译器对双 IEnumerable<T> 和 foreach T 感到满意？

Question

我知道这段代码不起作用（并且以一种可行的方式编写它没有问题）。 我想知道编译器如何构建没有任何错误。如果你在哪里运行它，你会得到运行时错误？ （假设数据不为空）

using System;
using System.Collections.Generic;

public class Class1
{
    public void Main()
    {
        IEnumerable<IEnumerable<Foo>> data = null;

        foreach(Foo foo in data){
            foo.Bar();
        }
    }

}

public class Foo {
    public void Bar() { }
}

Answer 1

这是因为foreach 不会在您的特定情况下进行编译时检查。如果你构建了工作代码，你会得到a InvalidCastException at run-time。

using System.Collections.Generic;

public class Test
{
    internal class Program
    {
        public static void Main()
        {
            var item = new Foo();
            var inner = new List<Foo>();
            var outer = new List<List<Foo>>();

            inner.Add(item);
            outer.Add(inner);

            IEnumerable<IEnumerable<Foo>> data = outer;

            foreach (Foo foo in data)
            {
                foo.Bar();
            }
        }

    }


    public class Foo
    {
        public void Bar()
        {
        }
    }
}

做foreach (Foo foo in data)相当于调用

IEnumerator enumerator = ((IEnumerable)data).GetEnumerator();
Foo foo; //declared here in C# 4 and older
while(enumerator.MoveNext())
{
    //Foo foo; //declared here in C# 5 and newer

    foo = (Foo)enumerator.Current; //Here is the run time error in your code.

    //The code inside the foreach loop.
    {
        foo.Bar();
    }
}

所以你看它并不关心你传入的是什么类型，只要foo = (Foo)enumerator.Current;调用成功。

---

它没有抛出任何编译时错误的原因是IEnumerable<T> 是covariant。这意味着我可以通过任何基于Foo 或更多派生自Foo 的类。因此，如果我可以创建一个继承自 Foo 的第二类，该类也将支持 IEnumerable<Foo> 并让我的列表包含它，这将导致强制转换失败。

//This code compiles fine in .NET 4.5 and runs without throwing any errors.
internal class Program
{
    public static void Main()
    {
        var item = new Baz();
        var inner = new List<Baz>();
        inner.Add(item);

        IEnumerable<IEnumerable<Foo>> data = inner;

        foreach (Foo foo in data)
        {
            foo.Bar();
        }
    }
}

public class Foo
{
    public void Bar()
    {
    }
}

public class Baz : Foo, IEnumerable<Foo>
{
    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator<Foo> IEnumerable<Foo>.GetEnumerator()
    {
        throw new NotImplementedException();
    }
}

但是，如果您将 Foo 标记为 sealed，编译器现在知道不再存在派生类，然后将引发编译器错误

Answer 2

由于您明确指定了类型，foreach 的每次迭代都将尝试（在运行时）将当前项目转换为 Foo。这和写这个没什么不同：

IEnumerable<IEnumerable<Foo>> data = null;
foreach (object item in data)
{
    Foo foo = (Foo)item;
    foo.Bar();
}

或者更直接地说，这个：

IEnumerable<Foo> data = null;
Foo foo = (Foo)data;

编译器不会抱怨它不会抱怨转换到接口或从接口转换的原因：它无法证明转换无效（有关示例，请参见 here为什么）。

请注意，相比之下，如果您使用具体类而不是接口IEnumerable，那么您将收到编译时错误。例如：

IEnumerable<List<Foo>> data = null;

foreach(Foo foo in data){  // compile-time error here: "cannot convert List<Foo> to Foo"
    foo.Bar();
}

Answer 3

您可以通过将Foo 类标记为sealed 来使编译时错误发生：

public sealed class Foo
{
    public void Bar() { }
}

否则，编译器无法确定是否可以转换。

Answer 4

非常好的问题！这是我从@Jon Skeet 读到的一个未解决的问题： Do "type-safe" and "strongly typed" mean the same thing? 我还阅读了 msdn 中的一些博客。 @slaks 博客也不错 http://blog.slaks.net/2011/09/c-is-not-type-safe.html