Style.TargetType Propriété

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"/>

Valeur de propriété

Type d’objet auquel le style est appliqué. Cette valeur est généralement définie en XAML, et non dans le code. Voir les remarques.

Exemples

Cet exemple crée deux styles : un pour un TextBlock et un pour un TextBox. Chaque style est appliqué à deux instances d’un contrôle pour créer une apparence uniforme pour chaque TextBlock et TextBox. L’exemple définit la propriété FrameworkElement.Style de chaque contrôle en référençant le style en tant qu’extension de balisage {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>

Remarques

Une TargetType valeur est requise pour tous les cas où vous utilisez ou déclarez un style. Il n’existe aucune valeur par défaut. Même une Style valeur incorporée de la propriété FrameworkElement.Style nécessite une valeur explicite TargetType .

La façon classique de spécifier une TargetType valeur consiste à utiliser un attribut XAML sur l’élément Style . Lorsque vous définissez en XAML, la signification et TargetType les valeurs que vous fournissez prennent en compte certains aspects de la façon dont les types sont représentés en XAML.

Pour XAML, tous les préfixes qui seraient nécessaires pour faire référence à un type via une utilisation d’élément XAML doivent être inclus dans la valeur d’attribut TargetType . Par exemple, si un style cible un type personnalisé, qui est défini dans un espace de noms de code mappé au préfixe « local : », la TargetType valeur d’attribut du style de ce type doit inclure ce même préfixe précédant le nom du type. Ce comportement est activé par le comportement de conversion de type chaîne intégré dans l’analyseur XAML Windows Runtime.

Lorsque vous définissez des styles pour des types personnalisés, une fois que vous avez inclus un préfixe de mappage pour un TargetType préfixe que vous n’incluez pas dans la valeur De propriété d’un Setter dans ce style.

La valeur que vous fournissez modifie TargetType le comportement de recherche pour toute valeur Setter.Property que vous spécifiez dans le style. Plus précisément, les propriétés de dépendance que vous référencez par nom pour une valeur d’attribut Setter.Property XAML sont censées exister sur le TargetType type ou sur n’importe quelle classe ancêtre. Par exemple, si le TargetType paramètre Button est spécifié, et que l’une Setter.Property des valeurs d’attribut XAML du style est « Background », qui se résout en propriété Control.Background (Control est trois niveaux au-dessus de Button dans son héritage de classe et Button hérite de toutes les propriétés de Control). Il est courant de spécifier la TargetType valeur pour être les mêmes noms d’éléments d’interface utilisateur que vous utiliseriez dans le balisage d’interface utilisateur classique, mais vous ne nommez généralement pas une classe ancêtre (bien que cela soit techniquement autorisé).

Si le style inclut un Setter qui déclare un modèle de contrôle (valeur pour la propriété Template ), la TargetType valeur du style parent doit correspondre à la valeur TargetType de l’élément ControlTemplate contenu.

Styles implicites

Les styles sont presque toujours déclarés en tant que ressources XAML partagées et appliquées à chaque élément d’interface utilisateur de l’application qui fait référence à ce style. Pour être déclaré en tant que ressource, tous les éléments XAML, y compris les éléments Style , doivent avoir une clé dans la collection de ressources qui distingue chaque ressource pour la recherche au moment de l’exécution. L’élément Style (ainsi que les différents éléments de modèle tels que ControlTemplate) prennent en charge une fonctionnalité appelée styles implicites. Pour un style implicite, la valeur que vous fournissez pour la TargetType valeur sert également de clé pour ce style dans son étendue de collection de ressources et vous n’êtes pas obligé de spécifier la valeur d’attribut x :Key . (En revanche, la plupart des autres éléments que vous déclarez dans une collection de ressources ont besoin d’une valeur d’attribut x :Key explicite et vous obtiendrez des erreurs de conception ou d’analyseur qui appliquent cela.)

Un style déclaré à l’aide du style implicite est ensuite utilisé comme valeur style pour n’importe quelle instance d’élément d’interface utilisateur qui correspond spécifiquement au type qui correspond au TargetType style implicite. Les contrôles n’ont pas besoin de référencer un style avec une valeur d’attribut style et une référence d’extension de balisage {StaticResource} à une clé pour obtenir ce comportement, il s’agit d’un comportement implicite si ces contrôles correspondent à un type de style implicite existant.

Les styles implicites ne s’appliquent pas aux éléments qui sont des sous-types du type référencé comme TargetType valeur. Par exemple, si vous déclarez un style implicite pour les contrôles ToggleButton et que votre application possède des contrôles CheckBox (CheckBox dérive de ToggleButton), le style s’applique spécifiquement aux ToggleButton contrôles, mais pas aux CheckBox contrôles.

Le Windows Runtime définit des styles implicites par défaut pour chaque élément d'interface utilisateur pratique qui fait partie de l'API Windows Runtime. Cela doit être dû au fait que ces styles définissent les visuels pour les éléments (en particulier les modèles), et un élément sans visuels n’apparaît même pas dans l’interface utilisateur ou participe à la disposition. Tous ces styles implicites peuvent être vus dans le fichier XAML d’assistance de conception appelé generic.xaml. Les outils que vous utilisez pour modifier le code XAML peuvent copier des parties discrètes de ce fichier dans le code XAML de votre application comme point de départ lorsque vous modifiez des copies de styles activées par les outils. Dans les styles implicites par défaut, il existe de nombreuses couches de référence de ressources, ainsi que la prise en charge du thème à l’aide de l’extension de balisage {ThemeResource} et des pinceaux spécifiques au thème ou à d’autres ressources. Vous pouvez remplacer n’importe quel style implicite qui proviendrait autrement de l’Windows Runtime définit les styles implicites par défaut. Pour plus d’informations, consultez les styles XAML et les modèles de contrôle XAML.

Utilisation de TargetType dans le code

La définition TargetType du code est rare. Le système de style XAML est destiné à être utilisé en chargeant XAML en tant que ressource et en ayant tous les aspects d’un style à l’avance prêts. Il doit y avoir très peu de scénarios où vous ne savez pas comment styler un contrôle ou appliquer un style jusqu’à l’exécution, où il faudrait définir un TargetType sur un style créé ou référencé dans le code.

L’obtention d’un TargetType code est également rare, mais il existe peut-être quelques scénarios supplémentaires dans lesquels vous pouvez le faire. Par exemple, il peut y avoir un ensemble de ressources de style nommées déjà définies dans votre code XAML. Toutefois, vous souhaiterez peut-être vérifier qu’un style que vous êtes sur le point d’appliquer à un contrôle a une TargetType valeur qui fonctionne pour le type du contrôle auquel vous l’appliquez. Par conséquent, vous pouvez avoir du code comme suit :

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;
}

Notes de migration

• Si vous avez utilisé XAML pour Windows Presentation Foundation (WPF), vous avez peut-être utilisé une extension de balisage x :Type pour remplir les valeurs XAML qui prennent un System.Type. L’analyseur XAML Windows Runtime ne prend pas en charge x :Type. Au lieu de cela, vous devez faire référence au type par nom sans utiliser d’extension de balisage, et toute conversion de type XAML-à-stockage nécessaire est déjà gérée par le comportement de conversion intégré dans l’analyseur XAML.