Style Classe

Définition

Espace de noms:

Windows.UI.Xaml

Contient des setters de propriétés qui peuvent être partagés entre des instances d’un type. Un style est généralement déclaré dans une collection de ressources afin qu’il puisse être partagé et utilisé pour appliquer des modèles de contrôle et d’autres styles.

public ref class Style sealed : DependencyObject

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.UI.Xaml.Markup.ContentProperty(Name="Setters")]
/// [Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
/// [Windows.Foundation.Metadata.Activatable(Windows.UI.Xaml.IStyleFactory, 65536, "Windows.Foundation.UniversalApiContract")]
class Style final : DependencyObject

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.UI.Xaml.Markup.ContentProperty(Name="Setters")]
[Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
[Windows.Foundation.Metadata.Activatable(typeof(Windows.UI.Xaml.IStyleFactory), 65536, "Windows.Foundation.UniversalApiContract")]
public sealed class Style : DependencyObject

Public NotInheritable Class Style
Inherits DependencyObject

<Style .../>
-or-
<Style ...>
  oneOrMoreSetters
</Style>

Héritage

Object Platform::Object IInspectable DependencyObject Style

Attributs

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute ContentPropertyAttribute

Configuration requise pour Windows

Famille d’appareils	Windows 10 (introduit dans 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduit dans v1.0)

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}. L’exemple montre également comment récupérer un style à partir d’un dictionnaire de ressources et l’appliquer à un contrôle dans le code.

Chaque style a plusieurs parties Setter . Dans ce XAML, aucun élément de propriété XAML n’apparaît Style.Setters . Il s’agit de l’utilisation classique en XAML pour cette propriété. La Style.Setters valeur est implicite, car Setters est la propriété de contenu XAML d’un Style. Pour plus d’informations sur la syntaxe XAML et sur la façon dont la syntaxe de contenu XAML permet d’impliquer et d’omettre certains éléments XAML, consultez guide de syntaxe XAML.

Notez que dans le style du TextBox, la propriété Margin est définie sur 4, ce qui signifie que la Zone de texte a une marge de 4 sur tous les côtés. Pour compenser la longueur du deuxième TextBlock, qui est plus court que le premier TextBlock , car le nom prend moins de place que le prénom, une valeur de « 6,4,4,4 » est attribuée à la propriété Margin sur le deuxième TextBox. Cela fait que la deuxième Zone de texte a une marge différente de ce que le style spécifie, de sorte qu’elle s’aligne horizontalement sur la première Zone de texte.

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

private void ShowEmailAddressBox()
{
    TextBlock emailAddressLabel = new TextBlock();
    emailAddressLabel.Text = "Email:";
    emailAddressLabel.Style = (Style)rootPanel.Resources["TextBlockStyle"];

    TextBox emailAddressBox = new TextBox();
    emailAddressBox.Style = (Style)rootPanel.Resources["TextBoxStyle"];
    emailAddressBox.Margin = new Thickness(38, 4, 4, 4);

    emailAddressPanel.Children.Add(emailAddressLabel);
    emailAddressPanel.Children.Add(emailAddressBox);
}

Cet exemple crée deux éléments de style. Le TargetType du premier élément de style est défini sur TextBox et le TargetType pour le deuxième élément de style est défini sur Button. Ils sont ensuite appliqués en tant que style implicite pour un contrôle TextBox et un contrôle Button.

<StackPanel>
    <StackPanel.Resources>
        <Style TargetType="TextBox">
            <Setter Property="Foreground" Value="Pink" />
            <Setter Property="FontSize" Value="15" />                
        </Style>
        
        <Style TargetType="Button">
            <Setter Property="Foreground" Value="Black" />
            <Setter Property="Background" Value="Yellow" />
        </Style>
    </StackPanel.Resources>
    
    <TextBox Height="30" Width="120" Margin="2" Text="TextBoxStyle" />
    <Button Height="30" Width="100" Margin="2" Content="ButtonStyle" />
</StackPanel>

Cet exemple crée un style nommé InheritedStyle basé sur un style nommé BaseStyle. InheritedStyle hérite de la valeur d’arrière-plan Jaune de BaseStyle et ajoute une valeur de premier plan rouge.

<StackPanel>
    <StackPanel.Resources>
        <Style x:Key="BaseStyle" TargetType="Button">
            <Setter Property="Background" Value="Yellow" />
        </Style>
        <!--Create a Style based on BaseStyle-->
        <Style x:Key="InheritedStyle" TargetType="Button" BasedOn="{StaticResource BaseStyle}">
            <Setter Property="Foreground" Value="Red" />
        </Style>
    </StackPanel.Resources>
    <!--A button with default style-->
    <Button Content="HelloWorld" />
    <!--A button with base style-->
    <Button Content="HelloWorld" Style="{StaticResource BaseStyle}" />
    <!--A button with a style that is inherited from the BaseStyle-->
    <Button Content="HelloWorld" Style="{StaticResource InheritedStyle}" />
</StackPanel>

Remarques

Un style est essentiellement une collection de paramètres de propriété appliqués à une ou plusieurs instances d’un type particulier qui possède de telles propriétés. Un style contient une collection d’un ou plusieurs objets Setter . Chaque setter a une propriété et une valeur. La propriété est le nom de la propriété de l’élément auquel le style est appliqué. La valeur est la valeur appliquée à la propriété .

Pour appliquer un Style, l’objet cible doit être un DependencyObject. La propriété que chaque Setter référence en tant que valeur Property doit être une propriété de dépendance.

Vous devez définir la propriété TargetType lorsque vous créez un style. Sinon, une exception est levée.

Si vous définissez une valeur pour la même propriété dans un style et sur un élément directement, la valeur définie sur l’élément est directement prioritaire. Pour plus d’informations, consultez Vue d’ensemble des propriétés de dépendance, plus précisément la section « Priorité de la valeur de propriété de dépendance ».

Définition d’un style en tant que ressource XAML

Un style est presque toujours défini en XAML en tant que ressource dans un ResourceDictionary.

• Pour un Style utilisé uniquement par d’autres éléments d’interface utilisateur définis dans la même page XAML, vous définissez généralement le Style dans la collection FrameworkElement.Resources (Page.Resources si votre élément racine est une page).
• Pour un Style utilisé par plusieurs pages de votre application, vous définissez généralement le Style dans la collection Application.Resources . Vous pouvez également avoir un fichier XAML distinct pour l’application que vous incluez dans Application.Resources en tant que valeur MergedDictionaries .
• La plupart des éléments d’interface utilisateur ont un style par défaut défini par le Windows Runtime. Des copies des styles par défaut sont visibles dans le fichier XAML d’aide à la conception appelé generic.xaml, qui n’est pas techniquement un fichier de ressources pour les applications, bien qu’il soit structuré comme un. Vous pouvez 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 comme activé par les outils, mais une fois cette copie effectuée, elle doit être incluse dans l’une des collections Resources ou indirectement accessible via MergedDictionaries. Dans tous ces cas, le code XAML modifié qui remplace la valeur par défaut est inclus dans votre application.

Windows 8 Si vous remodifiez un contrôle existant dans Windows 8 XAML, vous modifiez parfois les éléments Style qui existent dans le fichier XAML StandardStyles.xaml inclus dans la plupart des modèles d’application de démarrage. StandardStyles.xaml est référencé par les fichiers app.xaml du modèle en tant que fichier source MergedDictionaries . Les modèles pour les applications commençant par Windows 8.1 n’utilisent plus StandardStyles.xaml.

Un élément Style défini dans un ResourceDictionary n’est pas obligatoire pour avoir un attribut x:Key ou un attribut x:Name, qui est normalement une exigence d’être une ressource XAML. Un style défini de cette façon utilise sa valeur de propriété TargetType comme clé implicite et est appelé style implicite.

Pour plus d’informations sur l’utilisation des dictionnaires de ressources XAML, consultez ResourceDictionary et références de ressources XAML.

Styles et modèles

Vous pouvez utiliser un setter dans un style pour appliquer des valeurs à n’importe quelle propriété de dépendance. Mais c’est le Setter de la propriété Template d’une classe dérivée du contrôle qui constitue la majorité du balisage XAML dans un style classique. La valeur d’un setter avec Property="Template" est presque toujours spécifiée en tant qu’élément de propriété qui contient un élément objet ControlTemplate .

Lorsqu’un Style est utilisé pour définir un modèle de contrôle, le TargetType de l’élément Style et le TargetType de l’élément ControlTemplate pour son setter Control.Template doivent toujours utiliser la même valeur.

Le setter de modèles définit la définition d’interface utilisateur de modèle de base pour un instance de contrôle où ce modèle est appliqué. Il contient également les états visuels d’un contrôle et d’autres définitions d’interface utilisateur basées sur l’état, telles que les transitions de thème par défaut. Pour un contrôle complexe tel que ListBox, le modèle par défaut Style et le ControlTemplate dans peuvent avoir des centaines de lignes de XAML. Pour plus d’informations sur le rôle de Style dans les scénarios de création de modèles de contrôle, consultez Modèles de contrôle XAML.

Le modèle d’un contrôle inclut souvent des états visuels qui modifient l’apparence du contrôle en réponse à des états logiques. Par exemple, un bouton peut avoir une apparence visuelle différente lorsqu’il est appuyé en appliquant un nouvel état visuel à partir de son modèle, et toutes les modifications d’apparence peuvent provenir de XAML et non de code. Pour plus d’informations sur le fonctionnement des états visuels et la façon de les modifier ou de définir des états pour des contrôles personnalisés, consultez Animations de storyboard pour les états visuels et modèles de contrôle XAML.

Styles et comportement d’exécution

Vous pouvez modifier les valeurs de propriétés individuelles qui ont été définies par un style au moment de l’exécution et remplacer les valeurs Setters . Par exemple, vous pouvez définir la propriété Template au moment de l’exécution, même si cette propriété a été définie par un style.

Vous pouvez ajuster les propriétés d’un style au moment de l’exécution, mais uniquement si ce style n’a pas été appliqué à quoi que ce soit et qu’il existe uniquement en tant que ressource qui n’est pas utilisée implicitement. Par exemple, vous pouvez ajouter des setters à la collection dans Setters pour un style qui existe dans Resources avec un attribut x:Key mais qui n’a pas de valeur d’extension de balisage {StaticResource} ailleurs dans XAML qui fait référence à ce style. Toutefois, dès qu’un Style est référencé et utilisé pour les valeurs par un objet chargé, le Style doit être considéré comme scellé. Vous pouvez détecter l’état scellé en vérifiant la valeur de la propriété IsSealed pour style. S’il est vrai, le style est scellé et vous ne pouvez pas modifier les propriétés de celui-ci ou les sous-valeurs Setter dans. Le point dans le temps où un style a été utilisé et scellé peut également être détecté lorsque l’objet où le style est référencé déclenche son événement Loaded .

Styles BasedOn

Vous pouvez créer un nouveau style en fonction d’un style existant défini par votre application ou des styles par défaut pour les contrôles Windows Runtime. Pour ce faire, utilisez la propriété BasedOn . Cela réduit la duplication dans votre code XAML et facilite la gestion des ressources. Chaque style ne prend en charge qu’un seul style BasedOn . Pour plus d’informations, consultez Contrôles BasedOn ou Style.

Styles implicites

Vous pouvez définir des styles de sorte qu’un style soit utilisé implicitement par tous les objets du même Objet TargetType, sans exiger que chaque instance d’un tel objet référence spécifiquement le Style en tant que valeur FrameworkElement.Style. Lorsqu’une <Style> ressource est déclarée dans un ResourceDictionary sans attribut x:Key, la valeur x:Key utilise la valeur de la propriété TargetType . Si vous définissez le style implicitement, le style est appliqué uniquement aux types qui correspondent exactement au TargetType et non aux éléments dérivés de la valeur TargetType . Par exemple, si vous créez un style implicitement pour tous les contrôles ToggleButton de votre application et que votre application a des contrôles ToggleButton et CheckBox (CheckBox dérive de ToggleButton), le style implicite « ToggleButton » est appliqué uniquement aux contrôles ToggleButton .

Remarques sur la syntaxe XAML

Setters étant la propriété de contenu XAML pour Style, vous pouvez utiliser une syntaxe de collection implicite telle que <Style><Setter .../><Setter .../></Style>.

L’utilisation de la classe Style dans le code (par exemple, l’appel d’un constructeur et la génération des valeurs Setter une par une) est très rare. Les styles sont utilisés pour les modèles, et les modèles doivent être disponibles au moment du chargement XAML, de sorte que tout style créé dans le code est généralement disponible trop tard pour être appliqué aux contrôles dans une interface utilisateur.

Constructeurs

Style()	Initialise une nouvelle instance de la classe Style, sans TargetType initial et une collection Setters vide.
Style(TypeName)	Initialise une nouvelle instance de la classe Style, avec un TargetType initial spécifié et une collection Setters vide.

Propriétés

BasedOn	Obtient ou définit un style défini qui est la base du style actuel.
Dispatcher	Obtient le CoreDispatcher auquel cet objet est associé. CoreDispatcher représente une installation qui peut accéder à DependencyObject sur le thread d’interface utilisateur, même si le code est initié par un thread autre que l’interface utilisateur. (Hérité de DependencyObject)
IsSealed	Obtient une valeur qui indique si le style est en lecture seule et ne peut pas être modifié.
Setters	Obtient une collection d’objets Setter .
TargetType	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.

Méthodes

ClearValue(DependencyProperty)	Efface la valeur locale d’une propriété de dépendance. (Hérité de DependencyObject)
GetAnimationBaseValue(DependencyProperty)	Retourne toute valeur de base établie pour une propriété de dépendance, qui s’applique dans les cas où une animation n’est pas active. (Hérité de DependencyObject)
GetValue(DependencyProperty)	Retourne la valeur effective actuelle d’une propriété de dépendance à partir d’un objet DependencyObject. (Hérité de DependencyObject)
ReadLocalValue(DependencyProperty)	Retourne la valeur locale d’une propriété de dépendance, si une valeur locale est définie. (Hérité de DependencyObject)
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)	Inscrit une fonction de notification pour écouter les modifications apportées à un DependencyProperty spécifique sur ce instance DependencyObject. (Hérité de DependencyObject)
Seal()	Verrouille le style afin que la propriété TargetType ou n’importe quel Setter de la collection Setters ne puisse pas être modifiée.
SetValue(DependencyProperty, Object)	Définit la valeur locale d’une propriété de dépendance sur un DependencyObject. (Hérité de DependencyObject)
UnregisterPropertyChangedCallback(DependencyProperty, Int64)	Annule une notification de modification précédemment inscrite en appelant RegisterPropertyChangedCallback. (Hérité de DependencyObject)

Voir aussi

• DependencyObject
• ControlTemplate
• Setter
• Vue d’ensemble des propriétés de dépendance
• Références aux ressources ResourceDictionary et XAML
• Application de styles aux contrôles
• Démarrage rapide : Modèles de contrôle