检测IEnumerable“状态机”

我刚刚读了一篇有趣的文章，《用C＃收益回报变得太可爱了》

这让我想知道最好的方法是检测IEnumerable是否是实际的可枚举集合，或者它是使用yield关键字生成的状态机。

例如，您可以将DoubleXValue（来自本文）修改为以下内容：

private void DoubleXValue(IEnumerable<Point> points)
{
    if(points is List<Point>)
      foreach (var point in points)
        point.X *= 2;
    else throw YouCantDoThatException();
}

问题1）有更好的方法吗？

问题2）创建API时，我应该担心这一点吗？

据我了解，您的问题似乎基于不正确的前提。让我看看我是否可以重构推理：

• 链接到的文章介绍了自动生成的序列如何表现出“惰性”行为，并说明了这如何导致违反直觉的结果。
• 因此，我可以通过检查是否自动生成来确定给定的IEnumerable实例是否将表现出这种惰性行为。
• 我怎么做？

问题在于第二个前提是错误的。即使您可以检测到给定的IEnumerable是否是迭代器块转换的结果（是的，也有这样做的方法），但这也无济于事，因为假设是错误的。让我们说明一下原因。

class M { public int P { get; set; } }
class C
{
  public static IEnumerable<M> S1()
  {
    for (int i = 0; i < 3; ++i) 
      yield return new M { P = i };
  }

  private static M[] ems = new M[] 
  { new M { P = 0 }, new M { P = 1 }, new M { P = 2 } };
  public static IEnumerable<M> S2()
  {
    for (int i = 0; i < 3; ++i)
      yield return ems[i];
  }

  public static IEnumerable<M> S3()
  {
    return new M[] 
    { new M { P = 0 }, new M { P = 1 }, new M { P = 2 } };
  }

  private class X : IEnumerable<M>
  {
    public IEnumerator<X> GetEnumerator()
    {
      return new XEnum();
    }
    // Omitted: non generic version
    private class XEnum : IEnumerator<X>
    {
      int i = 0;
      M current;
      public bool MoveNext()
      {
        current = new M() { P = i; }
        i += 1;
        return true;
      }
      public M Current { get { return current; } }
      // Omitted: other stuff.
    }
  }

  public static IEnumerable<M> S4()
  {
    return new X();
  }

  public static void Add100(IEnumerable<M> items)
  {
    foreach(M item in items) item.P += 100;
  }
}

好吧，我们有四种方法。S1和S2是自动生成的序列；S3和S4是手动生成的序列。现在假设我们有：

var items = C.Sn(); // S1, S2, S3, S4
S.Add100(items);
Console.WriteLine(items.First().P);

S1和S4的结果为0；每次枚举序列时，都会获得对创建的M的新引用。S2和S3的结果为100；每次枚举序列时，都会得到与上次获得的M相同的引用。序列代码是否自动生成与所枚举的对象是否具有参照身份的问题正交。这两个属性-自动生成和引用身份-实际上彼此无关。您链接到的文章对其进行了一些补充。

除非序列提供者被记录为总是提供具有引用身份的对象，否则假设这样做是不明智的。

我认为关键概念是您应将任何IEnumerable<T>集合视为不可变的：不应从中修改对象，而应使用新对象创建新集合：

private IEnumerable<Point> DoubleXValue(IEnumerable<Point> points)
{
    foreach (var point in points)
        yield return new Point(point.X * 2, point.Y);
}

（或者使用LINQ更加简洁地编写同样的内容Select()。）

如果您实际上要修改集合中的项目，请不要使用IEnumerable<T>，IList<T>或者使用（或者IReadOnlyList<T>如果您不想修改集合本身，也可以只修改其中的项目，并且使用的是.Net 4.5）：

private void DoubleXValue(IList<Point> points)
{
    foreach (var point in points)
        point.X *= 2;
}

这样，如果有人尝试将您的方法与一起使用IEnumerable<T>，它将在编译时失败。

我个人认为该文章中强调的问题是由于IEnumerable这些天来许多C＃开发人员过度使用了接口。当您需要对象集合时，它似乎已成为默认类型-但是，有很多信息IEnumerable根本无法告诉您……关键的是：它是否已被修正*。

如果发现需要检测an IEnumerable确实是an IEnumerable还是其他，则说明抽象泄漏了，并且您可能处于参数类型过于松散的情况。如果您需要IEnumerable单独提供的额外信息，请通过选择其他接口之一（例如ICollection或）来明确要求IList。

编辑下降投票者 请返回并仔细阅读问题。OP正在寻求一种方法，以确保IEnumerable实例在传递给他的API方法之前已经实现。我的回答解决了这个问题。关于正确的使用方式，还有一个更广泛的问题IEnumerable，当然，对OP粘贴的代码的期望是基于对该较广泛问题的误解，但是OP并未询问如何正确使用IEnumerable或如何使用不可变类型。不赞成我没有回答没有提出的问题是不公平的。

* 我使用术语reify，其他人使用stabilize或materialize。我认为社区尚未采用通用约定。