Kembalikan semua enumerables dengan pengembalian hasil sekaligus; tanpa melalui perulangan

Saya memiliki fungsi berikut untuk mendapatkan kesalahan validasi kartu. Pertanyaan saya berkaitan dengan berurusan dengan GetErrors. Kedua metode memiliki tipe pengembalian yang sama 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
}

Apakah mungkin untuk mengembalikan semua kesalahan GetMoreErrorstanpa harus menyebutkannya?

Kalau dipikir-pikir ini mungkin pertanyaan bodoh, tapi aku ingin memastikan aku tidak salah.

Ini jelas bukan pertanyaan bodoh, dan itu adalah sesuatu yang didukung F # yield!untuk seluruh koleksi vs yielduntuk satu item. (Itu bisa sangat berguna dalam hal rekursi ekor ...)

Sayangnya itu tidak didukung di C #.

Namun, jika Anda memiliki beberapa metode yang masing-masing mengembalikan IEnumerable<ErrorInfo>, Anda dapat menggunakan Enumerable.Concatuntuk membuat kode Anda lebih sederhana:

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

Ada satu perbedaan yang sangat penting antara kedua implementasi: yang satu ini akan memanggil semua metode segera , meskipun itu hanya akan menggunakan iterator yang dikembalikan satu per satu. Kode Anda yang ada akan menunggu sampai di-looped melalui semua yang ada di GetMoreErrors()dalamnya bahkan sebelum menanyakan tentang kesalahan selanjutnya.

Biasanya ini tidak penting, tetapi perlu memahami apa yang akan terjadi ketika.

Anda dapat mengatur semua sumber kesalahan seperti ini (nama metode dipinjam dari jawaban 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();
}

Anda kemudian dapat mengulanginya secara bersamaan.

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

Atau Anda dapat meratakan sumber kesalahan dengan SelectMany.

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

Eksekusi metode di GetErrorSourcesakan ditunda juga.

Saya datang dengan yield_cuplikan singkat :

Berikut ini cuplikan 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>

Saya tidak melihat ada yang salah dengan fungsi Anda, saya akan mengatakan itu melakukan apa yang Anda inginkan.

Pikirkan Yield sebagai mengembalikan elemen dalam Enumerasi akhir setiap kali itu dipanggil, jadi ketika Anda memilikinya di loop foreach seperti itu, setiap kali itu dipanggil mengembalikan 1 elemen. Anda memiliki kemampuan untuk menempatkan pernyataan bersyarat di muka Anda untuk memfilter hasil. (hanya dengan tidak menghasilkan kriteria pengecualian Anda)

Jika Anda menambahkan hasil berikutnya nanti dalam metode ini, itu akan terus menambahkan 1 elemen ke enumerasi, sehingga memungkinkan untuk melakukan hal-hal seperti ...

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

Saya terkejut tidak ada yang berpikir untuk merekomendasikan metode Ekstensi sederhana IEnumerable<IEnumerable<T>>untuk membuat kode ini tetap ditangguhkan pelaksanaannya. Saya penggemar eksekusi yang ditangguhkan karena berbagai alasan, salah satunya adalah jejak memori yang kecil bahkan untuk enumerables yang sangat besar.

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;
            }
        }
    }
}

Dan Anda bisa menggunakannya dalam kasus Anda seperti ini

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
}

Demikian pula, Anda dapat menghilangkan fungsi pembungkus DoGetErrorsdan hanya pindah UnWrapke lokasi panggilan.

Ya, adalah mungkin untuk mengembalikan semua kesalahan sekaligus. Kembalikan a List<T>atau ReadOnlyCollection<T>.

Dengan mengembalikan IEnumerable<T>Anda mengembalikan urutan sesuatu. Pada permukaan yang mungkin terlihat identik dengan mengembalikan koleksi, tetapi ada sejumlah perbedaan, Anda harus ingat.

Koleksi

• Penelepon dapat memastikan bahwa koleksi dan semua item akan ada ketika koleksi dikembalikan. Jika koleksi harus dibuat per panggilan, mengembalikan koleksi adalah ide yang sangat buruk.
• Sebagian besar koleksi dapat dimodifikasi ketika dikembalikan.
• Koleksi ini berukuran terbatas.

Urutan

• Dapat disebutkan - dan itu cukup banyak yang bisa kita katakan dengan pasti.
• Urutan yang dikembalikan itu sendiri tidak dapat dimodifikasi.
• Setiap elemen dapat dibuat sebagai bagian dari menjalankan urutan (yaitu pengembalian IEnumerable<T>memungkinkan untuk evaluasi malas, kembali List<T>tidak).
• Suatu urutan mungkin tidak terbatas dan dengan demikian menyerahkannya kepada pemanggil untuk memutuskan berapa banyak elemen yang harus dikembalikan.