WPF: Find All Child Controls Of A Type

The following DependencyObject extension method (compatible with both WPF and Silverlight) recursively traverses the visual tree searching for children of the type specified by type parameter TChild before returning a collection containing the matches.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;


namespace WPFFindAllChildren
{
    public static class DependencyObjectExtension
    {
        public static List<TChild> FindChildren<TChild>(this DependencyObject d)
            where TChild : DependencyObject
        {
            List<TChild> children = new List<TChild>();

            int childCount = VisualTreeHelper.GetChildrenCount(d);

            for (int i = 0; i < childCount; i++)
            {
                DependencyObject o = VisualTreeHelper.GetChild(d, i);

                if (o is TChild)
                    children.Add(o as TChild);

                foreach (TChild c in o.FindChildren<TChild>())
                    children.Add(c);
            }

            return children;
        }
    }
}

Usage

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;

namespace WPFFindAllChildren
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();            
        }

        void Window1_Loaded(object sender, RoutedEventArgs e)
        {
            StackPanel stack1 = new StackPanel();
            stack1.Children.Add(new CheckBox());
            stack1.Children.Add(new CheckBox());

            StackPanel stack2 = new StackPanel();
            stack2.Children.Add(new CheckBox());
            stack2.Children.Add(stack1);

            LayoutRoot.Children.Add(stack2);

            this.FindChildren<CheckBox>().ForEach(x => x.IsChecked = true);
        }
    }
}

Download Sample

The remote server returned an error: NotFound. - Yet Another Cause And Solution

Having encountered this error while working with Silverlight and WCF the number of potential fixes I found while searching was overwhelming. To get an idea of just how many causes there are for this error take a look at this thread. None of the solutions appeared relevant to my application, so I decided to dig further by setting includeExceptionDetailInFault in the service's web.config to true. This yielded no new information so I moved on to observing the HTTP traffic with Fiddler. To my surprise the ASP.NET development server was closing the connection with no response. Even stranger was the fact that this behavior was only exhibited by one of my operation contracts when certain parameters were passed to it--the rest of my operation contracts worked fine! Naturally I stepped through the problematic method and everything appeared to be working. Seeing this I knew that the problem had to be in the data contract returned, so I resorted to trial and error: one by one I tested the service with different data members nulled. Finally I discovered the data member causing the issue and the actual problem: circular references. After setting the IsReference property of my data contract to true the CommunicationException disappeared. Below is a sample WCF service that displays the aforementioned issue along with comments noting the fix.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

namespace NotFoundWcfService1
{
    // Setting the IsReference parameter of this 
    // attribute to true eliminates NotFound error
    [DataContract]
    public class Item
    {
        [DataMember]
        public List<Category> Categories { get; set; }
    }

    [DataContract]
    public class Category
    {
        [DataMember]
        public List<Item> Items { get; set; }
    }

    [ServiceContract]
    public class Service1
    {
        [OperationContract]
        public Item GetItem()
        {
            Item c = new Item()
            {
                Categories = new List<Category>()
                {
                    new Category()
                    {
                        Items = new List<Item>()
                    }
                }
            };

            // Commenting this out makes the operation
            // contract appear to work. Tricky!
            c.Categories[0].Items.Add(c);

            return c;
        }
    }
}

The Easy Way To Synchronously Call WCF Services In Silverlight

If you're reading this you probably know why Microsoft tries to force the use of asynchronous WCF service calls in Silverlight. If not and you cannot infer based on your knowledge of threading I suggest you read up on the matter.

While Microsoft may have a strong case for their decision, it can lead to bloated, messy code when several service calls are chained together. The following extension method, through heavy use of reflection, allows for synchronous service calls. Remember, do not block the UI thread.

ICommunicationObjectExtension.cs

using System;
using System.Net;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.ServiceModel;

namespace SyncWCFCalls
{
    public static class ICommunicationObjectExtension
    {
        public static TEventArgs SynchronousCall<TEventArgs>(this ICommunicationObject Client,
            string Method, params object[] Parameters)
            where TEventArgs : EventArgs
        {
            Type clientType = Client.GetType();

            string methodName = Method + "Async";
            string completedName = Method + "Completed";

            MethodInfo[] methods = null;

            try
            {
                methods = clientType.GetMethods().Where(x =>
                    x.Name == methodName).ToArray();
            }
            catch { }

            if (methods == null || methods.Length == 0)
            {
                throw new MissingMethodException(methodName + " not found");
            }

            MethodInfo method = null;

            try
            {
                method = methods.Single(x =>
                    x.GetParameters().Length == Parameters.Length);
            }
            catch { }

            if (method == null)
            {
                throw new MissingMethodException(methodName +
                    " parameter count mismatch");
            }

            EventInfo completedEvent = null;

            try
            {
                completedEvent = clientType.GetEvent(completedName);
            }
            catch { }

            if (completedEvent == null)
                throw new MissingMemberException(completedName + " not found");

            ManualResetEvent reset = new ManualResetEvent(false);

            EventHandler<TEventArgs> completedHandler = null;

            TEventArgs args = null;

            completedHandler = (s, e) =>
            {
                completedEvent.RemoveEventHandler(Client, completedHandler);

                args = e;

                reset.Set();
            };

            completedEvent.AddEventHandler(Client, completedHandler);

            method.Invoke(Client, Parameters);

            reset.WaitOne();

            return args;
        }
    }
}

Asynchronous WCF Service Call

void AsyncTest()
{
    CalculatorServiceClient client = new CalculatorServiceClient();

    Guid addState1 = Guid.NewGuid(), addState2 = Guid.NewGuid();

    client.AddCompleted += (s, e) =>
    {
        if ((Guid)e.UserState == addState1)
        {
            // Do something with AddCompletedEventArgs                    
            client.AddAsync(e.Result, 10, addState2);
        }
        else if ((Guid)e.UserState == addState2)
        {
            // Do something with AddCompletedEventArgs
            client.SubtractAsync(e.Result, 5);
        }
    };

    client.SubtractCompleted += (s, e) =>
    {
        // Do something with SubtractCompletedEventArgs
    };

    client.AddAsync(1, 1, addState1);
}

Synchronous WCF Service Call

void SyncTest()
{
    CalculatorServiceClient client = new CalculatorServiceClient();

    ThreadPool.QueueUserWorkItem(x =>
    {
        AddCompletedEventArgs addArgs1 =
            client.SynchronousCall<AddCompletedEventArgs>("Add", 1, 1);
        // Do something with AddCompletedEventArgs

        AddCompletedEventArgs addArgs2 =
            client.SynchronousCall<AddCompletedEventArgs>("Add", 
                addArgs1.Result, 10);
        // Do something with AddCompletedEventArgs

        SubtractCompletedEventArgs subtractArgs =
            client.SynchronousCall<SubtractCompletedEventArgs>("Subtract",
                addArgs2.Result, 5);
        // Do something with SubtractCompletedEventArgs
    });
}

Updated 3/21/2010

ObservableItemCollection Class

While working with WPF data binding I often found myself populating an ObservableCollection with instances of classes that implement INotifyPropertyChanged, and then subscribing the same method to the PropertyChanged event of each element. To eliminate such boilerplate code, I derived from ObservableCollection to create ObservableItemCollection. When the PropertyChanged event of any element of the the collection is raised, the ObservableItemCollection's own PropertyChanged event is invoked. Coincidentally Microsoft is planning on releasing a similar class with the same name.

using System;
using System.ComponentModel;
using System.Collections.Specialized;
using System.Collections.ObjectModel;

namespace ExploringDotNet
{
    public class ObservableItemCollection<T> : ObservableCollection<T>
    {
        public event PropertyChangedEventHandler ItemPropertyChanged;

        void Item_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (ItemPropertyChanged != null)
                ItemPropertyChanged(sender, e);
        }

        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
        {
            if (e.NewItems != null)
                foreach (INotifyPropertyChanged i in e.NewItems)
                    i.PropertyChanged += Item_PropertyChanged;

            if (e.OldItems != null)
                foreach (INotifyPropertyChanged i in e.OldItems)
                    i.PropertyChanged -= Item_PropertyChanged;

            base.OnCollectionChanged(e);
        }
    }
}

Enumerating ResourceDictionary Keys in Silverlight 2

The Microsoft response to this need is that the feature was not implemented in Silverlight 2. However, enumerating ResourceDictionary Keys is possible through the use of reflection. Aside from the performance cost incurred by reflection, the only other caveat I'm aware of is that the end-user must have the Silverlight 3 runtime installed for this to work.

ResourceDictionary dictionary = new ResourceDictionary()
{
    { "a", "" },
    { "b", "" },
    { "c", "" }
};

PropertyInfo prop = typeof(ResourceDictionary).GetProperty("Keys");
object[] keys = prop.GetValue(dictionary, null) as object[];

foreach (object o in keys)
    MessageBox.Show(o.ToString());