We will be using the DataTemplateSelector class which exists in the System.Windows.Controls namespace of the PresentationFramework assembly. This class contains just one method:

public virtual DataTemplate SelectTemplate(object item, DependencyObject container)


You will notice that the method is a virtual one enabling deriving classes to override it and provide their own implementation. For some reason the standard DataTemplateSelector class can be instantiated and the implementation of the SelectTemplate method simply returns null. If anyone knows why this is I would love to hear.

So basicly we have one method which accepts two parameters. An item which is the object according to which we plan to make our DataTemplate selection and a container which is the DependencyObject which will contain the DataTemplate. Lets take the following SoccerPlayer abstract base class containing these two properties:

public int Number { get; set; }
public string Name { get; set; }


And two concrete classes deriving from it, a Midfielder and a Defender:

public class Defender : SoccerPlayer
{
public int TacklingRating { get; set; }
public int Strength { get; set; }
}


public class Midfielder : SoccerPlayer
{
public int PassingAccuracy { get; set; }
}


Each adding its own special properties. Now we have a situation were we display a list of SoccerPlayer which will show the common properties (Number, Name) and whenever a selection is made in the list we want to display the extended details in a different section of the view (master-detail). We want the detailed display to change according to the type of the actual SoccerPlayer selected, after all, each type will require different labels and bindings in order to properly display all the information.

We will create unique DataTemplates for each of the player types:

<DataTemplate x:Key="MidfielderTemplate">
<TextBlock Foreground="Red">
<TextBlock Text="Passing Accuracy:" />
<TextBlock Text="{Binding Path=PassingAccuracy}"
Margin="5,0,0,0" />
TextBlock>
DataTemplate>

<DataTemplate x:Key="DefenderTemplate">
<TextBlock Foreground="Blue">
<TextBlock Text="Tackling Rating:" />
<TextBlock Text="{Binding Path=TacklingRating}"
Margin="5,0,5,0" />
<TextBlock Text="Strength:" />
<TextBlock Text="{Binding Path=Strength}"
Margin="5,0,0,0" />
TextBlock>
DataTemplate>


And now its time to create a DataTemplateSelector which, according to the type of the item, will return the proper DataTemplate :

public class PlayerTemplateSelector : DataTemplateSelector
{
public DataTemplate MidfielderTemplate { get; set; }
public DataTemplate DefenderTemplate { get; set; }

public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
if (item is Midfielder)
{
return MidfielderTemplate;
}
if (item is Defender)
{
return DefenderTemplate;
}

return null;
}
}


So as you can see… we override the SelectTemplate method and provide our logic. The reason I defined two properties of DataTemplate type is so i`ll be able to link up the DataTemplates all through XAML in the following manner:

<local:PlayerTemplateSelector x:Key="PlayerTemplateSelector" MidfielderTemplate="{StaticResource MidfielderTemplate}" DefenderTemplate="{StaticResource DefenderTemplate}" />


Now all we need is to use some kind of container which allows us to set a DataTemplateSelector. Every object deriving from ContentControl allows this (Label, Button etc.) but if no special functionality is required from the control we can use a very lightweight ContentPresenter:

<ContentPresenter Content="{Binding Path=SelectedItem, ElementName=MainPlayersList}" ContentTemplateSelector="{StaticResource PlayerTemplateSelector}" />


The Content of the ContentPresenter is bound to the SelectedItem of our list container (In this case MainPlayersList is a simple ListBox) and so whenever it changes this triggers a template selection using the specified selector.

We can clearly see that DataTemplateSelector is a great tool to handle display of versatile data in some region of our view. Another great use for the DataTemplateSelector is where we want to change the controls available to the user according to certain mode selections. For example: A user can decide wether to enter some string input or to enter a date, according to the user’s selection the proper control will appear to allow simple and easy data entry…

In conclusion, great tool which makes alot of common WPF UI tasks very simple… two thumbs up…