TabControl.ContentTemplateSelector Propriedade

public:
 property System::Windows::Controls::DataTemplateSelector ^ ContentTemplateSelector { System::Windows::Controls::DataTemplateSelector ^ get(); void set(System::Windows::Controls::DataTemplateSelector ^ value); };

public System.Windows.Controls.DataTemplateSelector ContentTemplateSelector { get; set; }

member this.ContentTemplateSelector : System.Windows.Controls.DataTemplateSelector with get, set

Public Property ContentTemplateSelector As DataTemplateSelector

Valor de Propriedade

Um ContentTemplateSelector. A predefinição é null.

Exemplos

O exemplo seguinte utiliza a ContentTemplateSelector propriedade para mostrar o conteúdo de uma TabItem de forma diferente, dependendo da cidade natal da pessoa selecionada.

<DataTemplate x:Key="DetailTemplate">
  <Border Width="300" Height="100" Margin="20"
          BorderBrush="Aqua" BorderThickness="1" Padding="8">
    <Grid>
      <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition/>
        <RowDefinition/>
      </Grid.RowDefinitions>
      <Grid.ColumnDefinitions>
        <ColumnDefinition Width="100"/>
        <ColumnDefinition/>
      </Grid.ColumnDefinitions>
      <TextBlock Grid.Row="0" Grid.Column="0" Text="First Name:"/>
      <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Path=FirstName}"/>
      <TextBlock Grid.Row="1" Grid.Column="0" Text="Last Name:"/>
      <TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding Path=LastName}"/>
      <TextBlock Grid.Row="2" Grid.Column="0" Text="Home Town:"/>
      <TextBox Grid.Row="2" Grid.Column="1" Text="{Binding Path=HomeTown}"/>
    </Grid>
  </Border>
</DataTemplate>

<DataTemplate x:Key="SeattleTemplate">
  <DataTemplate.Resources>
    <Style TargetType="TextBlock">
      <Setter Property="FontSize" Value="16"/>
    </Style>
  </DataTemplate.Resources>
  <Border Width="300" Height="100" Margin="20"
          BorderBrush="DarkSeaGreen" BorderThickness="3" Padding="15">
    <Grid>
      <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition/>
        <RowDefinition/>
      </Grid.RowDefinitions>
      <Grid.ColumnDefinitions>
        <ColumnDefinition Width="120"/>
        <ColumnDefinition/>
      </Grid.ColumnDefinitions>
      <TextBlock Grid.Row="0" Grid.Column="0" Text="Please welcome"/>
      <DockPanel Grid.Row="0" Grid.Column="1" >
        <TextBlock Text="{Binding Path=FirstName}"/>
        <TextBlock Text=" "/>
        <TextBlock Text="{Binding Path=LastName}"/>
      </DockPanel>
      <TextBlock Grid.Row="1" Grid.ColumnSpan="2" Text="from the Emerald City!"/>
    </Grid>
  </Border>
</DataTemplate>

<!--Bind to the collection MyFriends and use a DataTemplateSelector
to specify the appearance of the content.-->
<TabControl Name="tabCtrl1" Width="400" Height="200" 
         ItemsSource="{Binding Source={StaticResource MyFriends}}"
         ContentTemplateSelector="{StaticResource PersonSelector}"/>

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.ObjectModel;
using System.ComponentModel;

namespace TabControlContentTemplateSelector
{
    // Create a class that represents a person.  
    // This class contains a person's first name, last name, 
    // and hometown.
    public class Person : INotifyPropertyChanged
    {
        private string firstname;
        private string lastname;
        private string hometown;

        public event PropertyChangedEventHandler PropertyChanged;

        public Person()
        {
        }

        public Person(string first, string last, string town)
        {
            this.firstname = first;
            this.lastname = last;
            this.hometown = town;
        }

        public override string ToString()
        {
            return firstname.ToString();
        }

        public string FirstName
        {
            get { return firstname; }
            set
            {
                firstname = value;
                OnPropertyChanged("FirstName");
            }
        }

        public string LastName
        {
            get { return lastname; }
            set
            {
                lastname = value;
                OnPropertyChanged("LastName");
            }
        }

        public string HomeTown
        {
            get { return hometown; }
            set
            {
                hometown = value;
                OnPropertyChanged("HomeTown");
            }
        }

        protected void OnPropertyChanged(string info)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }
    }

public class PersonTemplateSelector : DataTemplateSelector
{
    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {

        // The content of each TabItem is a Person object.
        if (item is Person)
        {
            Person person = item as Person;

            Window win = Application.Current.MainWindow;

            // Select one of the DataTemplate objects, based on the 
            // person's home town.
            if (person.HomeTown == "Seattle")
            {
                return win.FindResource("SeattleTemplate") as DataTemplate;
            }
            else
            {
                return win.FindResource("DetailTemplate") as DataTemplate;
            }
        }

        return null;
    }
}

Imports System.ComponentModel

Public Class Person
    Implements INotifyPropertyChanged

    ' Events
    Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged

    ' Methods
    Public Sub New()
    End Sub

    Public Sub New(ByVal first As String, ByVal last As String, ByVal town As String)
        Me._firstname = first
        Me._lastname = last
        Me._hometown = town
    End Sub

    Private Sub OnPropertyChanged(ByVal info As String)
        RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(info))
    End Sub

    Public Overrides Function ToString() As String
        Return Me._firstname.ToString
    End Function


    ' Properties
    Public Property FirstName() As String
        Get
            Return Me._firstname
        End Get
        Set(ByVal value As String)
            Me._firstname = value
            Me.OnPropertyChanged("FirstName")
        End Set
    End Property

    Public Property HomeTown() As String
        Get
            Return Me._hometown
        End Get
        Set(ByVal value As String)
            Me._hometown = value
            Me.OnPropertyChanged("HomeTown")
        End Set
    End Property

    Public Property LastName() As String
        Get
            Return Me._lastname
        End Get
        Set(ByVal value As String)
            Me._lastname = value
            Me.OnPropertyChanged("LastName")
        End Set
    End Property


    ' Fields
    Private _firstname As String
    Private _hometown As String
    Private _lastname As String
End Class

Public Class PersonTemplateSelector
    Inherits DataTemplateSelector

    Public Overrides Function SelectTemplate(ByVal item As Object, _
                     ByVal container As DependencyObject) As DataTemplate

        ' The content of each TabItem is a Person object.
        If TypeOf item Is Person Then

            Dim person As Person = item

            Dim win As Window = Application.Current.MainWindow

            ' Select one of the DataTemplate objects, based on the 
            ' person's home town.
            If person.HomeTown = "Seattle" Then
                Return win.FindResource("SeattleTemplate")
            Else
                Return win.FindResource("DetailTemplate")

            End If
        End If

        Return Nothing
    End Function

End Class

Observações

Normalmente, cria-se um DataTemplateSelector quando tem mais do que um DataTemplate para o mesmo tipo de objetos e quer fornecer a sua própria lógica para escolher a DataTemplate aplicar com base nas propriedades de cada objeto de dados. Note que, se tiver objetos de diferentes tipos, pode definir a DataType propriedade no DataTemplate. Se fizeres isso, então não há necessidade de criar um DataTemplateSelector. Além disso, se tiver objetos do mesmo tipo mas com propriedades diferentes, pode também considerar usar um DataTrigger ou um conversor de dados. Para mais informações, consulte Visão Geral da Templação de Dados.

Para criar um seletor de templates, crie uma classe que herde e DataTemplateSelector sobreponha o SelectTemplate método. Depois de a sua classe estar definida, pode atribuir uma instância da classe à propriedade do seletor de template do seu elemento.

Se tanto as ContentTemplateSelector propriedades como as ContentTemplate estiverem definidas, então esta propriedade é ignorada.

Uso de atributos XAML

<object ContentTemplateSelector="{ResourceExtension DataTemplateSelectorClassKey}"/>

Uso do elemento de propriedade XAML

<object>
  <object.ContentTemplateSelector>
    <MyDataTemplateSelectorImplementation .../>
  </object.ContentTemplateSelector>
</object>

Valores XAML

ResourceExtension Um dos seguintes: StaticResource, ou DynamicResource. Consulte Recursos XAML.

DataTemplateSelectorClassKey A chave que identifica a implementação do seletor que está a ser solicitada. A chave refere-se a uma classe derivada que implementa uma sobreposição prática SelectTemplate . Para informações sobre como mapear a sua classe personalizada, veja XAML Namespaces e Namespace Mapping para WPF XAML. Também podes adicionar programaticamente uma instância da tua DataTemplateSelector classe como recurso a um dicionário de recursos.

MyDataTemplateSelectorImplementação Uma classe derivada de DataTemplateSelector e sobrepõe-se SelectTemplatea . Para informações sobre como mapear a sua classe personalizada, veja XAML Namespaces e Namespace Mapping para WPF XAML.

Informação de Propriedade de Dependência