一次性返回所有可枚举的yield return； 不循环

Question

我有以下函数来获取卡的验证错误。 我的问题涉及处理 GetErrors。 两种方法都具有相同的返回类型 IEnumerable。

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 中的所有错误，而不必枚举它们？

Answer 1

F# 支持整个集合的 yield! 和单个项目的 yield。 （这对于尾递归而言非常有用...）

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

但是，如果您有多个方法，每个方法都返回 IEnumerable，则可以使用 Enumerable.Concat 使代码更简单：

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

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

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

Answer 2

您可以像这样设置所有错误源（方法名称借用 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 中方法的执行也会被延迟。

Answer 3

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

通过返回 IEnumerable，您将返回一个序列。 从表面上看，这似乎与返回集合相同，但您应该记住有许多区别。

集合

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

序列

• 是可以枚举的——这几乎就是我们能肯定地说的全部内容。
• 返回的序列本身无法修改。
• 每个元素可以作为运行序列的一部分来创建（即返回IEnumerable允许延迟求值，而返回List则不允许）。
• 序列可能是无限的，因此将其留给调用者来决定应返回多少个元素。

Answer 4

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

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 移动到调用站点。

Answer 5

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

将 Yield 视为每次调用它时都会在最终枚举中返回一个元素，因此当您将它放在 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;
    }
  }
}

Answer 6

我想出了一个快速的 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>