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 Observações.

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 e TextBox. O exemplo define a propriedade FrameworkElement.Style de cada controle referenciando o Style 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 Botton.-->
    <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 valor TargetType é necessário para todos os casos em que você usa ou declara um Style. Nenhum valor padrão. Até mesmo um Style usado como um valor embutido da propriedade FrameworkElement.Style requer um valor TargetType explícito.

A maneira típica de especificar um valor TargetType é por meio de um atributo XAML no elemento Style . Quando definido em XAML, o significado de TargetType e os valores fornecidos 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 atributo TargetType. 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 valor do atributo TargetType para o estilo desse tipo deverá incluir esse mesmo prefixo antes do nome do tipo. Esse comportamento é habilitado pelo comportamento interno de conversão de tipo de cadeia de caracteres 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 Property de qualquer Setter dentro desse Estilo.

O valor que você fornece para TargetType modifica o comportamento de pesquisa para qualquer valor Setter.Property especificado dentro do estilo. Especificamente, espera-se que as propriedades de dependência referenciadas por nome para um valor de atributo XAML Setter.Property existam no tipo TargetType ou em qualquer classe ancestral. Por exemplo, se o TargetType especificado for Button e um dos valores de atributo XAML Setter.Property no Style for "Background", isso será resolvido para a propriedade Control.Background (Control está três níveis acima de Button em sua herança de classe e Button herdará todas as propriedades de Control). É comum especificar o valor TargetType 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 Style incluir um Setter que declara um modelo de controle (um valor para a propriedade Template ), o valor TargetType do style pai deverá corresponder ao valor TargetType do elemento ControlTemplate contido.

Estilos implícitos

Os estilos são quase sempre declarados como recursos XAML que são 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ão suporte a um recurso chamado estilos implícitos. Para um estilo implícito, o valor que você fornece para o valor TargetType também serve como a chave para esse estilo em seu escopo de coleção de recursos, e você não precisa 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 do 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 referenciados como o valor TargetType. Por exemplo, se você declarar um estilo implícito para controles ToggleButton e seu aplicativo tiver controles CheckBox (CheckBox deriva de ToggleButton), o estilo se aplicará especificamente aos controles ToggleButton , mas não aos controles CheckBox .

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 sequer aparecerá na interface do usuário nem participará do layout. Todos esses estilos implícitos podem ser vistos no arquivo XAML auxiliar de design chamado generic.xaml. As ferramentas que você usa para editar XAML podem copiar partes discretas desse arquivo para o 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 recursos, bem como suporte a temas 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 que, de outra forma, seria proveniente da Windows Runtime define estilos implícitos padrão. Para obter mais informações, consulte Início Rápido: Estilo de controles e Início Rápido: Modelos de controle.

Usando TargetType no código

A configuração de 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 muito poucos cenários em que você não saberia informações sobre como definir o estilo de 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 no 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 marcar que um estilo que você está prestes a aplicar a um controle tenha um valor TargetType que funcione para o tipo do 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.

Aplica-se a