WPF

<DataGridTemplateColumn x:Name="..." Header="...">
<DataGridTemplateColumn.CellTemplate>
  <DataTemplate>
    <TextBlock Text="{Binding Path=City}" Style="..."/>
  </DataTemplate>
</DataGridTemplateColumn.CellTemplate>
                                        <DataGridTemplateColumn.CellEditingTemplate>
  <DataTemplate>
    <ComboBox ... />
  </DataTemplate>
</DataGridTemplateColumn.CellEditingTemplate>
</DataGridTemplateColumn>

<Window.CommandBindings>
        <CommandBinding Command="{x:Static my:MainWindow.CustomRoutedCommand}"
                    Executed="ExecutedCustomCommand"
                    CanExecute="CanExecuteCustomCommand" />
</Window.CommandBindings>

Public Shared CustomRoutedCommand As New RoutedCommand()

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

   'Initialize hotkeys
   Dim customCommandBinding As New CommandBinding(CustomRoutedCommand, AddressOf ExecutedCustomCommand)
   Dim saveKeyGesture As New KeyGesture(Key.F1)
   CustomRoutedCommand.InputGestures.Add(saveKeyGesture)

End Sub

Public Sub ExecutedCustomCommand(ByVal sender As Object, ByVal e As ExecutedRoutedEventArgs)

        If (Keyboard.GetKeyStates(Key.F1) = KeyStates.Down) Then 
            SaveRecord()
        End If

End Sub

<data:DataGridTextColumn
       Header="Employee ID"
       Binding={"Binding EmployeeId"}>
<data:DataGridTextColumn
       Header="Job Name"
       Binding="{Binding EmployeeJobId, Converter={StaticResource JobIdToJobNameConverter}}">

public class JobIdToJobNameConverter : IValueConverter
{
    public object Convert
        (object value,
         Type targetType,
         object parameter,
         CultureInfo culture)
    {
        Job job = JobsProvider.GetJobs().FirstOrDefault
                      (p => p.JobId.Equals ((int) value));
        return job == null ? string.Empty : job.JobName;
    }

    public object ConvertBack
        (object value,
         Type targetType,
         object parameter,
         CultureInfo culture)
    {
        return DependencyProperty.UnsetValue;
    }
}

<ContentControl Content={Binding}/>

<DataTemplate DataType={x:Type local:Person}>...</DataType>
<DataTemplate DataType={x:Type local:Pet}>...</DataType>

public class TemplatedContent : Section
    {
        private static readonly DependencyProperty ContentProperty = DependencyProperty.Register("Content", typeof(object), typeof(TemplatedContent), new PropertyMetadata(OnContentChanged));
        private static readonly DependencyProperty TemplateProperty = DependencyProperty.Register("Template", typeof(DataTemplate), typeof(TemplatedContent), new PropertyMetadata(OnTemplateChanged));

        public TemplatedContent()
        {
            //Helpers.FixupDataContext(this);
            Loaded += TemplatedContent_Loaded;
        }

        private void TemplatedContent_Loaded(object sender, RoutedEventArgs e)
        {
            GenerateContent(Template, Content);
        }

        public object Content
        {
            get { return GetValue(ContentProperty); }
            set { SetValue(ContentProperty, value); }
        }

        public DataTemplate Template
        {
            get { return (DataTemplate)GetValue(TemplateProperty); }
            set { SetValue(TemplateProperty, value); }
        }


        private void GenerateContent(DataTemplate template, object content)
        {
            Blocks.Clear();
            if (template != null && content != null)
            {
                FrameworkContentElement element = Helpers.LoadDataTemplate(template);
                element.DataContext = content;
                //Helpers.UnFixupDataContext(element);
                Blocks.Add(Helpers.ConvertToBlock(content, element));
            }
        }

        private void GenerateContent()
        {
            GenerateContent(Template, Content);
        }

        private void OnContentChanged(object newValue)
        {
            if (IsLoaded)
                GenerateContent(Template, newValue);
        }

        private void OnTemplateChanged(DataTemplate newValue)
        {
            if (IsLoaded)
                GenerateContent(newValue, Content);
        }

        private static void OnContentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((TemplatedContent)d).OnContentChanged(e.NewValue);
        }

        private static void OnTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((TemplatedContent)d).OnTemplateChanged((DataTemplate)e.NewValue);
        }
    }

<FlowDocument>
	<local:TemplatedContent Content={Binding}>
	 <local:TemplatedContent.Template>
			<DataTemplate DataType={x:Type local:Person}>...</DataTemplate>
	 </local:TemplatedContent.Template>
	</local:TemplatedContent>
</FlowDocument>

<FlowDocument>
	<local:TemplatedContent Content={Binding}>
	</local:TemplatedContent>
</FlowDocument>

<DataTemplate DataType={x:Type local:Person}>...</DataTemplate>