イールドリターンを含むすべての列挙型を一度に返します。ループせずに

カードの検証エラーを取得する次の関数があります。私の質問は、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());
}

ただし、2つの実装には非常に重要な違いが1つあります。これは、返された反復子を一度に1つしか使用しない場合でも、すべてのメソッドをすぐに呼び出します。既存のコードは、次のエラーについて尋ねる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は、呼び出されるたびに最後の列挙の要素を返すと考えてください。そのため、このようなforeachループで要素を呼び出すと、呼び出されるたびに1つの要素が返されます。結果セットをフィルタリングするために、条件付きステートメントをforeachに置くことができます。（単にあなたの除外基準に屈しないことによって）

メソッドの後半で後続のyieldを追加すると、列挙に1つの要素が追加され続け、次のようなことが可能になります...

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

IEnumerable<IEnumerable<T>>このコードで遅延実行を維持するために、単純な拡張メソッドを推奨する人が誰もいないとは思いません。私は多くの理由で遅延実行のファンです。それらの1つは、巨大な列挙子であってもメモリフットプリントが小さいことです。

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>ない場合）。
• シーケンスは無限である可能性があるため、返される要素の数を決定する呼び出し元に任せることができます。