reusable datatemplate binding to celltemplate - wpf

Question

I have the following datagrid
<DataGrid x:Name="dataGrid1"
AutoGenerateColumns="False"
ItemsSource="{Binding}">
<DataGrid.Resources>
<DataTemplate DataType="{x:Type DataTypes:Foo}" x:Key="dTemp">
<TextBox Background="{Binding BgColor}" Text="{Binding Path=RowId}"/>
</DataTemplate>
<DataTemplate DataType="{x:Type DataTypes:Foo}" x:Key="dTemp2">
<TextBox Background="{Binding BgColor}" Text="{Binding Path=Alias}"/>
</DataTemplate>
</DataGrid.Resources>
<DataGrid.Columns>
<DataGridTemplateColumn CellTemplate="{StaticResource dTemp}"/>
<DataGridTemplateColumn CellTemplate="{StaticResource dTemp2}"/>
</DataGrid.Columns>
</DataGrid>
and in the codebehind I have:
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Media;
namespace WpfApplication1
{
public partial class MainWindow : Window
{
public ObservableCollection<Foo[]> ObservableCollection;
public MainWindow()
{
InitializeComponent();
this.ObservableCollection = new ObservableCollection<Foo[]>();
Foo[] ocoll = new Foo[3];
ocoll[0] = (new Foo(1, "FIRST ARRAY FIRST ROW FIRST COLUMN", Brushes.Aqua));
ocoll[1] = (new Foo(2, "FIRST ARRAY FIRST ROW SECOND COLUMN", Brushes.Red));
ocoll[2] = (new Foo(3, "FIRST ARRAY FIRST ROW THIRD COLUMN", Brushes.Green));
Foo[] ocoll2 = new Foo[3];
ocoll2[0] = (new Foo(4, "SECOND ARRAY SECOND ROW FIRST COLUMN", Brushes.Aqua));
ocoll2[1] = (new Foo(5, "SECOND ARRAY SECOND ROW SECOND COLUMN", Brushes.Red));
ocoll2[2] = (new Foo(6, "SECOND ARRAY SECOND ROW THIRD COLUMN", Brushes.Green));
this.ObservableCollection.Add(ocoll);
this.ObservableCollection.Add(ocoll2);
dataGrid1.DataContext = ObservableCollection;
}
}
public class Foo
{
public int RowId { get; set; }
public string Alias { get; set; }
public Brush BgColor { get; set; }
public Foo(int rowId, string #alias, Brush bgColor)
{
this.RowId = rowId;
this.Alias = alias;
this.BgColor = bgColor;
}
}
}
The Object Foo has more than 30 properties (I only wrote 2 in here to make it easier to follow)..
the question is:
do I really have to define 30 different datatemplates (like dTemp, dTemp2, ... see above) to bind the CellTemplate of each DataGridTemplateColumn to it ?

Answer 1

You can create just one implicit DataTemplate for your data type if you do not declare an x:Key value for it:
<DataTemplate DataType="{x:Type DataTypes:YourDataType}">
<TextBox Text="{Binding TextDescription}" Background="{Binding Color}" />
</DataTemplate>
This will automatically be applied to all of your instances of your data type that are within the scope of this DataTemplate, eg. put it in your control Resources or Application.Resources section.
UPDATE >>>
Unfortunately, you still don't seem to have it right. If you re-read my original answer, you should see that I specified that you do not declare an x:Key value for the DataTemplate.
Furthermore, you previously said that all of the DataTemplates would be the same, but now you have added two different ones, so this method will no longer work.
UPDATE 2 >>>
MSDN states that 'A DataTemplate describes the visual structure of a data object'. It might be clearer if it said that a DataTemplate can show the properties of one type of data object. However, only one DataTemplate is required to be defined per object type if you do not declare an x:Key value for it. So if you define one for a particular type, all instances of that type will be automatically rendered according to that DataTemplate.
You asked me 'how to set the DataTemplate to display more than one element in it'... if by that you mean 'how to apply the DataTemplate to more than one instance of the defined data type', the answer is simply to not declare an x:Key value for it and do not set the DataGridTemplateColumn.CellTemplate property. Using this method would render each item with the same UI controls, but with the different values from each instance.
However, if you mean 'how to display different instances of the defined data type differently' as is currently shown in your question, then the answer is shown in your question... you would have to explicitly declare each one with a x:Key value and set the DataGridTemplateColumn.CellTemplate property to the named DataTemplate.