Türe göre WPF penceresindeki tüm denetimleri bulun

Pencere üzerindeki tüm denetimleri türlerine göre bulmanın bir yolunu arıyorum,

örneğin: tümünü bul TextBoxes, belirli arayüzü uygulayan tüm kontrolleri bul vb.

Bu hile yapmalı

public static IEnumerable<T> FindVisualChildren<T>(DependencyObject depObj) where T : DependencyObject
{
    if (depObj != null)
    {
        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
        {
            DependencyObject child = VisualTreeHelper.GetChild(depObj, i);
            if (child != null && child is T)
            {
                yield return (T)child;
            }

            foreach (T childOfChild in FindVisualChildren<T>(child))
            {
                yield return childOfChild;
            }
        }
    }
}

o zaman kontrolleri numaralandırırsınız

foreach (TextBlock tb in FindVisualChildren<TextBlock>(window))
{
    // do something with tb here
}

Bu en kolay yol:

IEnumerable<myType> collection = control.Children.OfType<myType>(); 

burada kontrol pencerenin kök öğesidir.

@Bryce Kahle'nin cevabını @Mathias Lykkegaard Lorenzen'in önerisini ve kullanımını takip etmek için uyarladım LogicalTreeHelper.

Tamam görünüyor. ;)

public static IEnumerable<T> FindLogicalChildren<T> ( DependencyObject depObj ) where T : DependencyObject
{
    if( depObj != null )
    {
        foreach( object rawChild in LogicalTreeHelper.GetChildren( depObj ) )
        {
            if( rawChild is DependencyObject )
            {
                DependencyObject child = (DependencyObject)rawChild;
                if( child is T )
                {
                    yield return (T)child;
                }

                foreach( T childOfChild in FindLogicalChildren<T>( child ) ) 
                {
                    yield return childOfChild;
                }
            }
        }
    }
}

(Sırasıyla @Benjamin Berry & @David R tarafından belirtildiği gibi Sekme kontrollerini veya Grup Kutuları içindeki Izgaraları kontrol etmeyecektir.) (Ayrıca @ öğlenin önerisini takip etti ve gereksiz çocuğu kaldırdı!

Yardımcı sınıfları VisualTreeHelperveya ilgilendiğiniz ağacaLogicalTreeHelper bağlı olarak kullanın . Her ikisi de bir öğenin alt öğelerini almak için yöntemler sağlar (sözdizimi biraz farklı olsa da). Genellikle bu sınıfları belirli bir türün ilk oluşumunu bulmak için kullanırım, ancak bu türdeki tüm nesneleri bulmak için kolayca değiştirebilirsiniz:

public static DependencyObject FindInVisualTreeDown(DependencyObject obj, Type type)
{
    if (obj != null)
    {
        if (obj.GetType() == type)
        {
            return obj;
        }

        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
        {
            DependencyObject childReturn = FindInVisualTreeDown(VisualTreeHelper.GetChild(obj, i), type);
            if (childReturn != null)
            {
                return childReturn;
            }
        }
    }

    return null;
}

VisualTreeHelper.GetChildrenCount(depObj);Yukarıdaki birkaç örnekte kullanılan satırın, GroupBoxözellikle GroupBoxa içeren Gridve alt Gridöğeleri içeren es için sıfırdan farklı bir sayı döndürmediğini buldum . Bunun GroupBoxbirden fazla çocuk içermesine izin verilmemesi ve bunun kendi Contentmülkünde depolanması nedeniyle olabileceğine inanıyorum . GroupBox.ChildrenMülk türü yoktur . Bunu çok verimli bir şekilde yapmadığımdan eminim, ancak bu zincirdeki ilk "FindVisualChildren" örneğini aşağıdaki gibi değiştirdim:

public IEnumerable<T> FindVisualChildren<T>(DependencyObject depObj) where T : DependencyObject 
{ 
    if (depObj != null) 
    {
        int depObjCount = VisualTreeHelper.GetChildrenCount(depObj); 
        for (int i = 0; i <depObjCount; i++) 
        { 
            DependencyObject child = VisualTreeHelper.GetChild(depObj, i); 
            if (child != null && child is T) 
            { 
                yield return (T)child; 
            }

            if (child is GroupBox)
            {
                GroupBox gb = child as GroupBox;
                Object gpchild = gb.Content;
                if (gpchild is T)
                {
                    yield return (T)child; 
                    child = gpchild as T;
                }
            }

            foreach (T childOfChild in FindVisualChildren<T>(child)) 
            { 
                yield return childOfChild; 
            } 
        }
    }
} 

Belirli bir türdeki tüm alt öğelerin bir listesini almak için şunları kullanabilirsiniz:

private static IEnumerable<DependencyObject> FindInVisualTreeDown(DependencyObject obj, Type type)
{
    if (obj != null)
    {
        if (obj.GetType() == type)
        {
            yield return obj;
        }

        for (var i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
        {
            foreach (var child in FindInVisualTreeDown(VisualTreeHelper.GetChild(obj, i), type))
            {
                if (child != null)
                {
                    yield return child;
                }
            }
        }
    }

    yield break;
}

Örneğin, bir sekme denetiminin alt sekme denetimini bulabilmeniz için özyinelemede küçük bir değişiklik.

    public static DependencyObject FindInVisualTreeDown(DependencyObject obj, Type type)
    {
        if (obj != null)
        {
            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            {
                DependencyObject child = VisualTreeHelper.GetChild(obj, i);

                if (child.GetType() == type)
                {
                    return child;
                }

                DependencyObject childReturn = FindInVisualTreeDown(child, type);
                if (childReturn != null)
                {
                    return childReturn;
                }
            }
        }

        return null;
    }

İşte jenerik sözdizimine sahip başka bir kompakt sürüm:

    public static IEnumerable<T> FindLogicalChildren<T>(DependencyObject obj) where T : DependencyObject
    {
        if (obj != null) {
            if (obj is T)
                yield return obj as T;

            foreach (DependencyObject child in LogicalTreeHelper.GetChildren(obj).OfType<DependencyObject>()) 
                foreach (T c in FindLogicalChildren<T>(child)) 
                    yield return c;
        }
    }

Ve işte böyle çalışıyor

    private T FindParent<T>(DependencyObject item, Type StopAt) where T : class
    {
        if (item is T)
        {
            return item as T;
        }
        else
        {
            DependencyObject _parent = VisualTreeHelper.GetParent(item);
            if (_parent == null)
            {
                return default(T);
            }
            else
            {
                Type _type = _parent.GetType();
                if (StopAt != null)
                {
                    if ((_type.IsSubclassOf(StopAt) == true) || (_type == StopAt))
                    {
                        return null;
                    }
                }

                if ((_type.IsSubclassOf(typeof(T)) == true) || (_type == typeof(T)))
                {
                    return _parent as T;
                }
                else
                {
                    return FindParent<T>(_parent, StopAt);
                }
            }
        }
    }

VisualTreeHelper kullanmanın yalnızca Visual veya Visual3D türetilmiş denetimlerde çalıştığını unutmayın. Diğer öğeleri de incelemeniz gerekiyorsa (örn. TextBlock, FlowDocument vb.), VisualTreeHelper kullanmak bir istisna atar.

Gerekirse mantıksal ağaca geri dönen bir alternatif:

http://www.hardcodet.net/2009/06/finding-elements-in-wpf-tree-both-ways

Ben bir yorum eklemek istedim ama ben sadece "Cevap" olabilir 50'den az puan var. XAML "TextBlock" nesnelerini almak için "VisualTreeHelper" yöntemini kullanırsanız, bunun da XAML "Button" nesnelerini yakalayacağını unutmayın. "TextBlock" nesnesini Textblock.Text parametresine yazarak yeniden başlatırsanız, Button.Content parametresini kullanarak Button metnini artık değiştiremezsiniz. Düğme, Textblock'tan kendisine yazılan metni kalıcı olarak gösterir. Metin yazma eylemi (alındığı andan itibaren -

foreach (TextBlock tb in FindVisualChildren<TextBlock>(window))
{
// do something with tb here
   tb.Text = ""; //this will overwrite Button.Content and render the 
                 //Button.Content{set} permanently disabled.
}

Bu soruna geçici bir çözüm bulmak için, bir XAML "TextBox" kullanmayı deneyebilir ve bir XAMAL Düğmesini taklit etmek için yöntemler (veya Olaylar) ekleyebilirsiniz. XAML "TextBox", "TextBlock" aramasıyla toplanmaz.

C ++ / CLI sürümüm

template < class T, class U >
bool Isinst(U u) 
{
    return dynamic_cast< T >(u) != nullptr;
}

template <typename T>
    T FindVisualChildByType(Windows::UI::Xaml::DependencyObject^ element, Platform::String^ name)
    {
        if (Isinst<T>(element) && dynamic_cast<Windows::UI::Xaml::FrameworkElement^>(element)->Name == name)
        {
            return dynamic_cast<T>(element);
        }
        int childcount = Windows::UI::Xaml::Media::VisualTreeHelper::GetChildrenCount(element);
        for (int i = 0; i < childcount; ++i)
        {
            auto childElement = FindVisualChildByType<T>(Windows::UI::Xaml::Media::VisualTreeHelper::GetChild(element, i), name);
            if (childElement != nullptr)
            {
                return childElement;
            }
        }
        return nullptr;
    };

Bazı nedenlerden dolayı, burada gönderilen cevapların hiçbiri MainWindow'umdaki belirli bir kontrolde bulunan tüm tip kontrolleri almama yardımcı oldu. Onları yinelemek için tüm menü öğelerini tek bir menüde bulmam gerekiyordu. Menünün tüm doğrudan torunları değildi, bu yüzden yukarıdaki kodlardan herhangi birini kullanarak sadece ilk lilne toplamak başardı. Bu eklenti yöntemi, buradan sonuna kadar okumaya devam edecek herkes için sorun için benim çözümüm.

public static void FindVisualChildren<T>(this ICollection<T> children, DependencyObject depObj) where T : DependencyObject
    {
        if (depObj != null)
        {
            var brethren = LogicalTreeHelper.GetChildren(depObj);
            var brethrenOfType = LogicalTreeHelper.GetChildren(depObj).OfType<T>();
            foreach (var childOfType in brethrenOfType)
            {
                children.Add(childOfType);
            }

            foreach (var rawChild in brethren)
            {
                if (rawChild is DependencyObject)
                {
                    var child = rawChild as DependencyObject;
                    FindVisualChildren<T>(children, child);
                }
            }
        }
    }

Umarım yardımcı olur.

Kabul edilen cevap , henüz ayrıştırılmamış ağaç dalları için adımları geri izlemeden ve tekrarlamadan önce, ilk alt dalı olabildiğince derin takip ederek keşfedilen unsurları mümkün olduğunca derin takip ederek keşfedilen unsurları az çok düzensiz döndürür .

İçinde soyundan elemanlarını gerekirse azalan sırayla doğrudan çocukların vb sonra, ilk çocuklarını vermiştir ve olacak, aşağıdaki algoritma çalışır:

public static IEnumerable<T> GetVisualDescendants<T>(DependencyObject parent, bool applyTemplates = false)
    where T : DependencyObject
{
    if (parent == null || !(child is Visual || child is Visual3D))
        yield break;

    var descendants = new Queue<DependencyObject>();
    descendants.Enqueue(parent);

    while (descendants.Count > 0)
    {
        var currentDescendant = descendants.Dequeue();

        if (applyTemplates)
            (currentDescendant as FrameworkElement)?.ApplyTemplate();

        for (var i = 0; i < VisualTreeHelper.GetChildrenCount(currentDescendant); i++)
        {
            var child = VisualTreeHelper.GetChild(currentDescendant, i);

            if (child is Visual || child is Visual3D)
                descendants.Enqueue(child);

            if (child is T foundObject)
                yield return foundObject;
        }
    }
}

Ortaya çıkan unsurlar en yakından en uzağa doğru sıralanacaktır. Bu, örneğin bir tür ve koşulda en yakın alt öğeyi arıyorsanız yararlı olacaktır:

var foundElement = GetDescendants<StackPanel>(someElement)
                       .FirstOrDefault(o => o.SomeProperty == SomeState);

@Bryce, gerçekten güzel bir cevap.

VB.NET sürümü:

Public Shared Iterator Function FindVisualChildren(Of T As DependencyObject)(depObj As DependencyObject) As IEnumerable(Of T)
    If depObj IsNot Nothing Then
        For i As Integer = 0 To VisualTreeHelper.GetChildrenCount(depObj) - 1
            Dim child As DependencyObject = VisualTreeHelper.GetChild(depObj, i)
            If child IsNot Nothing AndAlso TypeOf child Is T Then
                Yield DirectCast(child, T)
            End If
            For Each childOfChild As T In FindVisualChildren(Of T)(child)
                Yield childOfChild
            Next
        Next
    End If
End Function

Kullanım (bu, bir penceredeki tüm TextBox'ları devre dışı bırakır):

        For Each tb As TextBox In FindVisualChildren(Of TextBox)(Me)
          tb.IsEnabled = False
        Next

Visual Tree Helpers olmadan daha kolay buldum:

foreach (UIElement element in MainWindow.Children) {
    if (element is TextBox) { 
        if ((element as TextBox).Text != "")
        {
            //Do something
        }
    }
};