Style.TargetType Propriedade

public:
 property TypeName TargetType { TypeName get(); void set(TypeName value); };

TypeName TargetType();

void TargetType(TypeName value);

public System.Type TargetType { get; set; }

var typeName = style.targetType;
style.targetType = typeName;

Public Property TargetType As Type

<Style TargetType="typeName"/>

Valor da propriedade

O tipo de objeto ao qual o estilo é aplicado. Esse valor geralmente é definido em XAML, não em código. Consulte Comentários.

Exemplos

Este exemplo cria dois estilos: um para um TextBlock e outro para um TextBox. Cada estilo é aplicado a duas instâncias de um controle para criar uma aparência uniforme para cada TextBlock um e TextBox. O exemplo define a propriedade FrameworkElement.Style de cada controle fazendo referência ao Estilo como uma extensão de marcação {StaticResource}.

<StackPanel x:Name="rootPanel">
  <StackPanel.Resources>
    <!--Create a Style for a TextBlock to specify that the
              Foreground equals Navy, FontSize equals 14, and
              VerticalAlignment equals Bottom.-->
    <Style TargetType="TextBlock" x:Key="TextBlockStyle">
      <Setter Property="Foreground" Value="Navy"/>
      <Setter Property="FontSize" Value="14"/>
      <Setter Property="VerticalAlignment" Value="Bottom"/>
    </Style>

    <!--Create a Style for a TextBox that specifies that
              the Width is 200, Height is 30, Margin is 4,
              Background is LightBlue, and FontSize is 14.-->
    <Style TargetType="TextBox" x:Key="TextBoxStyle">
      <Setter Property="Width" Value="200"/>
      <Setter Property="Height" Value="30"/>
      <Setter Property="Margin" Value="4"/>
      <Setter Property="FontSize" Value="14"/>
      <Setter Property="Background">
        <Setter.Value>
          <LinearGradientBrush StartPoint="0,0.5" EndPoint="1,0.5">
            <GradientStop Color="White" Offset="0.0"/>
            <GradientStop Color="LightBlue" Offset="0.5"/>
            <GradientStop Color="Navy" Offset="1"/>
          </LinearGradientBrush>
        </Setter.Value>
      </Setter>
    </Style>
  </StackPanel.Resources>

  <!--Apply the TextBlockStyle and TextBoxStyle to each 
      TextBlock and TextBox, respectively.-->
  <StackPanel Orientation="Horizontal">
    <TextBlock Text="First Name:" Style="{StaticResource TextBlockStyle}"/>
    <TextBox Style="{StaticResource TextBoxStyle}"/>
  </StackPanel>
  <StackPanel Orientation="Horizontal">
    <TextBlock Text="Last Name:" Style="{StaticResource TextBlockStyle}"/>
    <TextBox Style="{StaticResource TextBoxStyle}"
             Margin="6,4,4,4"/>
  </StackPanel>
  <StackPanel x:Name="emailAddressPanel" Orientation="Horizontal"/>
</StackPanel>

Comentários

Um TargetType valor é necessário para todos os casos em que você usa ou declara um Estilo. Não há nenhum valor padrão. Mesmo um Style que é usado como um valor embutido da propriedade FrameworkElement.Style requer um valor explícito TargetType .

A maneira típica de especificar um TargetType valor é por meio de um atributo XAML no elemento Style . Quando definido em XAML, o significado e TargetType os valores que você fornece assumem alguns aspectos de como os tipos são representados no XAML.

Para XAML, todos os prefixos necessários para se referir a um tipo por meio de um uso de elemento XAML devem ser incluídos no valor do TargetType atributo. Por exemplo, se um estilo for direcionado a um tipo personalizado, que é definido em um namespace de código mapeado para o prefixo "local:", o TargetType valor do atributo para o estilo desse tipo deve incluir o mesmo prefixo anterior ao nome do tipo. Esse comportamento é habilitado pelo comportamento de conversão de tipo de cadeia de caracteres interno no analisador XAML Windows Runtime.

Ao definir estilos para tipos personalizados, depois de incluir um prefixo de mapeamento para um TargetType , você não inclui nenhum prefixo no valor de Propriedade de qualquer Setter dentro desse Estilo.

O valor que você fornece modifica TargetType o comportamento de pesquisa para qualquer valor Setter.Property especificado dentro do estilo. Especificamente, as propriedades de dependência que você referencia por nome para um Setter.Property valor de atributo XAML devem existir no TargetType tipo ou em qualquer classe ancestral. Por exemplo, se você TargetType especificar for Button, e um dos valores de Setter.Property atributo XAML no Estilo for "Background", que será resolvido para a propriedade Control.Background (Control está três níveis acima de Button em sua herança de classe e Button herda todas as propriedades de Control). É comum especificar o TargetType valor como os mesmos nomes de elementos de interface do usuário que você usaria na marcação típica da interface do usuário, normalmente você não nomearia uma classe ancestral (embora isso seja tecnicamente permitido).

Se o Estilo incluir um Setter que declara um modelo de controle (um valor para a propriedade Template ), o TargetType valor do estilo pai deverá corresponder ao valor TargetType do elemento ControlTemplate contido.

Estilos implícitos

Os estilos são quase sempre declarados como recursos XAML compartilhados e aplicados a cada elemento de interface do usuário no aplicativo que faz referência a esse estilo. Para ser declarado como um recurso, todos os elementos XAML, incluindo os elementos Style , devem ter uma chave dentro da coleção de recursos que distingue cada recurso para pesquisa em tempo de execução. O elemento Style (e também os vários elementos de modelo, como ControlTemplate) dá suporte a um recurso chamado estilos implícitos. Para um estilo implícito, o valor que você fornece para o TargetType valor também serve como a chave para esse estilo em seu escopo de coleção de recursos, e você não é obrigado a especificar o valor do atributo x:Key . (Por outro lado, a maioria dos outros elementos que você declara em uma coleção de recursos precisa de um valor de atributo x:Key explícito e você obteria erros de tempo de design ou analisador que impõem isso.)

Um estilo declarado usando o estilo implícito é usado como o valor Style para qualquer instância de elemento de interface do usuário que seja especificamente do tipo que corresponde ao TargetType estilo implícito. Os controles não precisam referenciar um estilo com um valor de atributo Style e uma referência de extensão de marcação {StaticResource} a uma chave para obter esse comportamento, será um comportamento implícito se esses controles corresponderem ao tipo de um estilo implícito existente.

Estilos implícitos não se aplicam a elementos que são subtipos do tipo referenciado como o TargetType valor. Por exemplo, se você declarar um estilo implícito para controles ToggleButton e seu aplicativo tiver controles CheckBox (CheckBox derivados de ToggleButton), o estilo se aplicará especificamente aos ToggleButton controles, mas não aos CheckBox controles.

O Windows Runtime define estilos implícitos padrão para cada elemento prático da interface do usuário que faz parte da API Windows Runtime. Ele precisa fazer isso porque esses estilos definem os visuais para elementos (particularmente os modelos) e um elemento sem visuais nem aparece na interface do usuário nem participa do layout. Todos esses estilos implícitos podem ser vistos no arquivo XAML do auxiliar de design chamado generic.xaml. As ferramentas usadas para editar XAML podem copiar partes discretas desse arquivo no XAML do aplicativo como ponto de partida quando você edita cópias de estilos, conforme habilitado pelas ferramentas. Dentro dos estilos implícitos padrão, há muitas camadas de referência de recurso, bem como suporte ao tema usando a extensão de marcação {ThemeResource} e pincéis específicos do tema ou outros recursos. Você pode substituir qualquer estilo implícito proveniente do Windows Runtime define estilos implícitos padrão. Para obter mais informações, consulte estilos XAML e modelos de controle XAML.

Usando TargetType no código

A configuração TargetType no código é incomum. O sistema de estilo XAML destina-se a ser usado carregando XAML como um recurso e fazendo com que todos os aspectos de um estilo estejam prontos com antecedência. Deve haver pouquíssimos cenários em que você não saberia informações sobre como estilizar um controle ou aplicar um estilo até o runtime, em que haveria a necessidade de definir um TargetType em um Estilo criado ou referenciado no código.

Obter um TargetType código também é incomum, mas talvez haja mais alguns cenários em que você possa estar fazendo isso. Por exemplo, pode haver um conjunto de recursos de estilo nomeados já definidos em seu XAML. Mas talvez você queira verificar se um estilo que você está prestes a aplicar a um controle tem um TargetType valor que funciona para o tipo de controle ao qual você está aplicando. Portanto, você pode ter um código como este:

private bool VerifyStyle(FrameworkElement scope, String styleKey, Control applyTo)
{
    Style styleToCheck = scope.Resources[styleKey] as Style;
    if (styleToCheck != null)
    {
        if (styleToCheck.TargetType == applyTo.GetType())
        {
            // applyTo.Style = styleToCheck;
            return true;
        }
    }
    return false;
}

Notas de migração

• Se você usou XAML para Windows Presentation Foundation (WPF), talvez tenha usado uma extensão de marcação x:Type para preencher quaisquer valores XAML que levem um System.Type. O analisador XAML Windows Runtime não dá suporte a x:Type. Em vez disso, você deve se referir ao tipo por nome sem usar nenhuma extensão de marcação e qualquer conversão de tipo XAML para backup necessária já é tratada pelo comportamento de conversão interno no analisador XAML.