Verim iadesi kullanılarak sayısız ve özyineleme

IEnumerable<T>Bir WebForms sayfasında denetimleri bulmak için kullandığım bir yöntem var.

Yöntem özyinelemeli ve yield returnözyinelemeli çağrının değeri returnig olduğunda istediğim türü döndüren bazı sorunlar yaşıyorum .

Kodum aşağıdaki gibi görünüyor:

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

Bu, şu anda bir "İfade türü dönüştürülemiyor" hatası veriyor. Ancak bu yöntem tür döndürürse IEnumerable<Object>, kod oluşturulur, ancak çıkışta yanlış tür döndürülür.

yield returnÖzyineleme yaparken de kullanmanın bir yolu var mı ?

Donduğu bir yöntem İçinde IEnumerable<T>, yield returndönmek zorundadır T, bir değil IEnumerable<T>.

değiştirmek

yield return c.GetDeepControlsByType<T>();

ile:

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

Özyinelemeli çağrı ile verilen öğelerin her birini vermeniz gerekir :

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

Bu şekilde tekrarlamanın bir maliyeti olduğunu unutmayın - çok fazla yineleyici oluşturursunuz, bu da gerçekten derin bir kontrol ağacınız varsa bir performans sorunu oluşturabilir. Bundan kaçınmak istiyorsanız, temel olarak tek bir yineleyici (durum makinesi) oluşturulduğundan emin olmak için özyinelemeyi yöntem içinde kendiniz yapmanız gerekir. Daha fazla ayrıntı ve örnek bir uygulama için bu soruya bakın - ancak bu belli bir karmaşıklık da getirir.

Jon Skeet ve Albay Panic'in yanıtlarında belirttiği gibi, yield returnözyinelemeli yöntemlerde kullanmak ağaç çok derinse performans sorunlarına neden olabilir.

İşte bir ağaç dizisinin derinlik-ilk geçişini gerçekleştiren genel özyinelemeli olmayan bir uzatma yöntemi:

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

Eric Lippert'in çözümünün aksine , RecursiveSelect doğrudan numaralandırıcılar ile çalışır, böylece Reverse (bellekteki tüm diziyi tamponlar) çağırması gerekmez.

RecursiveSelect kullanarak, OP'nin orijinal yöntemi aşağıdaki gibi yeniden yazılabilir:

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

Diğerleri size doğru cevabı verdi, ancak davanızın getiriden fayda sağladığını düşünmüyorum.

İşte aynı şeyi başaramayan bir pasaj.

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

İkincinizde öğeleri numaralandırıcıdan değil, numaralandırıcıdan iade etmeniz gerekir.yield 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;
            }
        }
    }
}

Bence numaralandırılabilir her kontrol dönüş vermek zorunda.

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

Seredynski'nin sözdizimi doğrudur, ancak yield returnyinelemeli işlevlerden kaçınmaya dikkat etmelisiniz, çünkü bu bellek kullanımı için bir felakettir. Bkz. Https://stackoverflow.com/a/3970171/284795 derinlikle patlayıcı bir şekilde ölçekleniyor (benzer bir işlev, uygulamamda belleğin% 10'unu kullanıyordu).

Basit bir çözüm, bir listeyi kullanmak ve listeyi yineleme ile iletmektir 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);
    }
}

Alternatif olarak, yinelenen çağrıları ortadan kaldırmak için bir yığın ve bir while döngüsü kullanabilirsiniz https://codereview.stackexchange.com/a/5661/754

Orada çok iyi cevaplar olsa da, yine de aynı şeyi gerçekleştirmek için LINQ yöntemlerini kullanmak mümkün olduğunu ekleyebilirim.

Örneğin, OP'nin orijinal kodu şu şekilde yeniden yazılabilir:

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