Style.TargetType Propriété

Référence

Définition

Espace de noms:: Windows.UI.Xaml

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Modifier

Obtient ou définit le type pour lequel le style est destiné. TargetType peut être utilisé pour déclarer une ressource de style implicite si aucune clé de ressource n’est spécifiée.

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é

TypeName Type

Type d’objet auquel le style est appliqué. Cette valeur est généralement définie en XAML, et non en code. Consultez la section Notes.

Exemples

Cet exemple crée deux styles : l’un pour un TextBlock et l’autre 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 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>

Remarques

Une valeur TargetType est requise pour tous les cas où vous utilisez ou déclarez un style. Il n'y a pas de valeur par défaut. Même un style utilisé comme valeur inline de la propriété FrameworkElement.Style nécessite une valeur TargetType explicite.

La méthode classique pour spécifier une valeur TargetType consiste à utiliser un attribut XAML sur l’élément Style . Lorsqu’elle est définie en XAML, la signification de TargetType et 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 par le biais d’une utilisation d’élément XAML doivent être inclus dans la valeur de l’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 valeur de l’attribut TargetType pour le style de ce type doit inclure le même préfixe qui précède le nom de 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, vous n’incluez aucun préfixe dans la valeur Property d’un élément Setter dans ce style.

La valeur que vous fournissez pour TargetType modifie 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 XAML Setter.Property sont censées exister sur le type TargetType ou sur toute classe ancêtre. Par exemple, si le TargetType que vous spécifiez est Button et que l’une des valeurs d’attribut XAML Setter.Property dans Style est « Background », qui est résolue en propriété Control.Background (Control se trouve 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 valeur TargetType comme étant les mêmes noms d’éléments d’interface utilisateur que ceux que vous utiliseriez dans le balisage d’interface utilisateur classique, vous ne nommeriez généralement pas une classe ancêtre (bien que cela soit techniquement autorisé).

Si style inclut un setter qui déclare un modèle de contrôle (valeur pour la propriété Template ), la valeur TargetType 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 dans l’application qui fait référence à ce style. Pour être déclarés 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 valeur TargetType sert également de clé pour ce style dans l’étendue de sa collection de ressources, et vous n’êtes pas obligé de spécifier la valeur de l’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 d’analyse ou de conception qui l’appliquent.)

Un style qui est déclaré à l’aide du style implicite est ensuite utilisé comme valeur Style pour tout élément d’interface utilisateur instance qui est spécifiquement du type qui correspond au TargetType du 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 au type d’un style implicite existant.

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

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. Il doit le faire, car 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 ne participe pas à la disposition. Tous ces styles implicites sont visibles dans le fichier XAML d’assistance à la conception appelé generic.xaml. Les outils que vous utilisez pour modifier 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} , de pinceaux spécifiques au thème ou d’autres ressources. Vous pouvez remplacer n’importe quel style implicite qui proviendrait autrement de la Windows Runtime définit les styles implicites par défaut. Pour plus d’informations, consultez Démarrage rapide : Contrôles de style et Démarrage rapide : Modèles de contrôle.

Utilisation de TargetType dans le code

La définition de TargetType dans le code est rare. Le système de style XAML est destiné à être utilisé en chargeant XAML en tant que ressource et en faisant en sorte que tous les aspects d’un style soient prêts à l’avance. Il doit y avoir très peu de scénarios dans lesquels vous ne connaissez pas d’informations sur la façon de mettre en forme un contrôle ou d’appliquer un style jusqu’à l’exécution, où il serait nécessaire de définir un TargetType sur un style créé ou référencé dans le code.

L’obtention d’un TargetType dans le code est également rare, mais il existe peut-être quelques autres scénarios où vous pouvez le faire. Par exemple, il peut y avoir un ensemble de ressources style nommées déjà définies dans votre code XAML. Toutefois, vous pouvez doublement case activée qu’un style que vous êtes sur le point d’appliquer à un contrôle a une valeur TargetType qui fonctionne pour le type du contrôle auquel vous l’appliquez. Ainsi, vous avez peut-être du code comme ceci :

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

Conseil

Si vous programmez à l’aide d’un langage Microsoft .NET (C# ou Microsoft Visual Basic), le type TypeName est projeté comme System.Type. Lors de la programmation à l’aide de C#C#, vous utilisez généralement l’opérateur typeof pour obtenir des références à System.Type d’un type basé sur un nom de type sous forme de chaîne. Dans Microsoft Visual Basic, utilisez GetType.

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 renseigner toutes les valeurs XAML qui utilisent 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 vers type de stockage nécessaire est déjà gérée par le comportement de conversion intégré dans l’analyseur XAML.

S’applique à

Partager via