IEnumerable dan Rekursi menggunakan imbal hasil

Saya memiliki IEnumerable<T>metode yang saya gunakan untuk menemukan kontrol di halaman WebForms.

Metode ini rekursif dan saya mengalami beberapa masalah mengembalikan tipe yang saya inginkan ketika yield returnkembali nilai nilai panggilan rekursif.

Kode saya terlihat sebagai berikut:

    public static IEnumerable<Control> 
                               GetDeepControlsByType<T>(this Control control)
    {
        foreach(Control c in control.Controls)
        {
            if (c is T)
            {
                yield return c;
            }

            if(c.Controls.Count > 0)
            {
                yield return c.GetDeepControlsByType<T>();
            }
        }
    }

Ini saat ini melontarkan kesalahan "Tidak dapat mengonversi tipe ekspresi". Namun jika metode ini mengembalikan tipe IEnumerable<Object>, kode dibuat, tetapi tipe yang salah dikembalikan dalam output.

Apakah ada cara menggunakan yield returnsementara juga menggunakan rekursi?

Di dalam metode yang mengembalikan IEnumerable<T>, yield returnharus kembali T, bukan IEnumerable<T>.

Menggantikan

yield return c.GetDeepControlsByType<T>();

dengan:

foreach (var x in c.GetDeepControlsByType<T>())
{
  yield return x;
}

Anda harus menghasilkan setiap item yang dihasilkan oleh panggilan rekursif:

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
    foreach(Control c in control.Controls)
    {
        if (c is T)
        {
            yield return c;
        }

        if(c.Controls.Count > 0)
        {
            foreach (Control control in c.GetDeepControlsByType<T>())
            {
                yield return control;
            }
        }
    }
}

Perhatikan bahwa ada biaya untuk berulang dengan cara ini - Anda akhirnya akan menciptakan banyak iterator, yang dapat membuat masalah kinerja jika Anda memiliki pohon kontrol yang sangat dalam. Jika Anda ingin menghindari itu, pada dasarnya Anda perlu melakukan rekursi sendiri dalam metode ini, untuk memastikan hanya ada satu iterator (mesin negara) yang dibuat. Lihat pertanyaan ini untuk detail lebih lanjut dan contoh implementasi - tetapi ini jelas menambahkan sejumlah kompleksitas juga.

Seperti yang dicatat oleh Jon Skeet dan Kolonel Panic dalam jawaban mereka, menggunakan yield returnmetode rekursif dapat menyebabkan masalah kinerja jika pohonnya sangat dalam.

Berikut adalah metode ekstensi non-rekursif generik yang melakukan traversal kedalaman-pertama dari urutan pohon:

public static IEnumerable<TSource> RecursiveSelect<TSource>(
    this IEnumerable<TSource> source, Func<TSource, IEnumerable<TSource>> childSelector)
{
    var stack = new Stack<IEnumerator<TSource>>();
    var enumerator = source.GetEnumerator();

    try
    {
        while (true)
        {
            if (enumerator.MoveNext())
            {
                TSource element = enumerator.Current;
                yield return element;

                stack.Push(enumerator);
                enumerator = childSelector(element).GetEnumerator();
            }
            else if (stack.Count > 0)
            {
                enumerator.Dispose();
                enumerator = stack.Pop();
            }
            else
            {
                yield break;
            }
        }
    }
    finally
    {
        enumerator.Dispose();

        while (stack.Count > 0) // Clean up in case of an exception.
        {
            enumerator = stack.Pop();
            enumerator.Dispose();
        }
    }
}

Tidak seperti solusi Eric Lippert , RecursiveSelect bekerja langsung dengan enumerator sehingga tidak perlu memanggil Reverse (yang mendukung seluruh urutan dalam memori).

Menggunakan RecursiveSelect, metode asli OP dapat ditulis ulang seperti ini:

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
    return control.Controls.RecursiveSelect(c => c.Controls).Where(c => c is T);
}

Yang lain memberi Anda jawaban yang benar, tetapi saya pikir kasus Anda tidak akan diuntungkan.

Berikut cuplikan yang mencapai hal yang sama tanpa menghasilkan.

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
   return control.Controls
                 .Where(c => c is T)
                 .Concat(control.Controls
                                .SelectMany(c =>c.GetDeepControlsByType<T>()));
}

Anda harus mengembalikan barang dari pencacah, bukan pencacah itu sendiri, pada detik Andayield return

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
    foreach (Control c in control.Controls)
    {
        if (c is T)
        {
            yield return c;
        }

        if (c.Controls.Count > 0)
        {
            foreach (Control ctrl in c.GetDeepControlsByType<T>())
            {
                yield return ctrl;
            }
        }
    }
}

Saya pikir Anda harus menghasilkan pengembalian setiap kontrol di enumerables.

    public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
    {
        foreach (Control c in control.Controls)
        {
            if (c is T)
            {
                yield return c;
            }

            if (c.Controls.Count > 0)
            {
                foreach (Control childControl in c.GetDeepControlsByType<T>())
                {
                    yield return childControl;
                }
            }
        }
    }

Sintaksis Seredynski benar, tetapi Anda harus berhati-hati untuk menghindari yield returnfungsi rekursif karena itu adalah bencana untuk penggunaan memori. Lihat https://stackoverflow.com/a/3970171/284795 skala itu eksplosif dengan kedalaman (fungsi serupa menggunakan 10% memori di aplikasi saya).

Solusi sederhana adalah menggunakan satu daftar dan memberikannya dengan rekursi https://codereview.stackexchange.com/a/5651/754

/// <summary>
/// Append the descendents of tree to the given list.
/// </summary>
private void AppendDescendents(Tree tree, List<Tree> descendents)
{
    foreach (var child in tree.Children)
    {
        descendents.Add(child);
        AppendDescendents(child, descendents);
    }
}

Atau Anda dapat menggunakan tumpukan dan loop sementara untuk menghilangkan panggilan rekursif https://codereview.stackexchange.com/a/5661/754

Meskipun ada banyak jawaban bagus di luar sana, saya masih akan menambahkan bahwa adalah mungkin untuk menggunakan metode LINQ untuk mencapai hal yang sama,.

Misalnya, kode asli OP dapat ditulis ulang sebagai:

public static IEnumerable<Control> 
                           GetDeepControlsByType<T>(this Control control)
{
   return control.Controls.OfType<T>()
          .Union(control.Controls.SelectMany(c => c.GetDeepControlsByType<T>()));        
}