立即退还所有可枚举的收益；没有循环

我具有以下功能来获取卡的验证错误。我的问题与处理GetErrors有关。两种方法具有相同的返回类型IEnumerable<ErrorInfo>。

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    var errors = GetMoreErrors(card);
    foreach (var e in errors)
        yield return e;

    // further yield returns for more validation errors
}

是否可以返回所有错误GetMoreErrors而不必通过错误进行枚举？

考虑一下这可能是一个愚蠢的问题，但是我想确保自己没有错。

这绝对不是一个愚蠢的问题，它是F＃支持yield!的整个集合与yield单个项目的支持。（就尾递归而言，这可能非常有用...）

不幸的是，C＃不支持它。

但是，如果您有几种方法各自返回IEnumerable<ErrorInfo>，则可以使用Enumerable.Concat来简化代码：

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    return GetMoreErrors(card).Concat(GetOtherErrors())
                              .Concat(GetValidationErrors())
                              .Concat(AnyMoreErrors())
                              .Concat(ICantBelieveHowManyErrorsYouHave());
}

但这两种实现之间有一个非常重要的区别：即使一次只使用返回的迭代器，该实现也会立即调用所有方法。您现有的代码将一直等待，直到它遍历所有内容，GetMoreErrors()然后才询问下一个错误。

通常这并不重要，但是值得了解何时会发生什么。

您可以像这样设置所有错误源（方法名称是从Jon Skeet的答案中借用的）。

private static IEnumerable<IEnumerable<ErrorInfo>> GetErrorSources(Card card)
{
    yield return GetMoreErrors(card);
    yield return GetOtherErrors();
    yield return GetValidationErrors();
    yield return AnyMoreErrors();
    yield return ICantBelieveHowManyErrorsYouHave();
}

然后，您可以同时遍历它们。

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    foreach (var errorSource in GetErrorSources(card))
        foreach (var error in errorSource)
            yield return error;
}

或者，您可以使用 SelectMany。

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    return GetErrorSources(card).SelectMany(e => e);
}

中方法的执行GetErrorSources也将延迟。

我想出了一个简短的yield_摘要：

这是片段XML：

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Author>John Gietzen</Author>
      <Description>yield! expansion for C#</Description>
      <Shortcut>yield_</Shortcut>
      <Title>Yield All</Title>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <Default>items</Default>
          <ID>items</ID>
        </Literal>
        <Literal Editable="true">
          <Default>i</Default>
          <ID>i</ID>
        </Literal>
      </Declarations>
      <Code Language="CSharp"><![CDATA[foreach (var $i$ in $items$) yield return $i$$end$;]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

我看不到您的功能有什么问题，我想说它在做您想要的事情。

可以将Yield看作是每次调用最终Enumeration时都返回一个元素，因此，当您将它放在这样的foreach循环中时，每次调用它都会返回1个元素。您可以将条件语句放入foreach中以过滤结果集。（只需不遵守您的排除标准）

如果稍后在该方法中添加后续收益，它将继续向枚举中添加1个元素，从而可以执行以下操作...

public IEnumerable<string> ConcatLists(params IEnumerable<string>[] lists)
{
  foreach (IEnumerable<string> list in lists)
  {
    foreach (string s in list)
    {
      yield return s;
    }
  }
}

令我惊讶的是，没有人想到推荐一种简单的Extension方法IEnumerable<IEnumerable<T>>来使此代码保持其延迟执行。我之所以喜欢延迟执行，原因有很多，其中之一是即使对于大量的可枚举对象，内存占用量也很小。

public static class EnumearbleExtensions
{
    public static IEnumerable<T> UnWrap<T>(this IEnumerable<IEnumerable<T>> list)
    {
        foreach(var innerList in list)
        {
            foreach(T item in innerList)
            {
                yield return item;
            }
        }
    }
}

您可以在这种情况下使用它

private static IEnumerable<ErrorInfo> GetErrors(Card card)
{
    return DoGetErrors(card).UnWrap();
}

private static IEnumerable<IEnumerable<ErrorInfo>> DoGetErrors(Card card)
{
    yield return GetMoreErrors(card);

    // further yield returns for more validation errors
}

同样，您可以取消包装函数，DoGetErrors而直接移至UnWrap呼叫站点。

是的，可以一次返回所有错误。只需返回一个List<T>或ReadOnlyCollection<T>。

通过返回 IEnumerable<T>您将返回一个序列的东西。从表面上看，这与返回收藏集相同，但是有许多区别，您应该牢记。

馆藏

• 返回集合时，调用者可以确保集合和所有项目都存在。如果必须在每次调用时创建集合，则返回集合是一个非常糟糕的主意。
• 返回时可以修改大多数集合。
• 集合的大小是有限的。

顺序

• 可以列举-这几乎是我们可以肯定地说的全部。
• 返回的序列本身无法修改。
• 每个元素都可以作为序列运行的一部分来创建（即返回IEnumerable<T>允许进行延迟评估，返回List<T>则不允许）。
• 一个序列可能是无限的，因此将其留给调用方来决定应返回多少个元素。