Style Classe

Définition

public ref class Style sealed : DependencyObject

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

[Microsoft.UI.Xaml.Markup.ContentProperty(Name="Setters")]
[Windows.Foundation.Metadata.Activatable(65536, "Microsoft.UI.Xaml.WinUIContract")]
[Windows.Foundation.Metadata.Activatable(typeof(Microsoft.UI.Xaml.IStyleFactory), 65536, "Microsoft.UI.Xaml.WinUIContract")]
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
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

ContentPropertyAttribute ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

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 chacune TextBlock et TextBox. L’exemple définit la propriété FrameworkElement.Style de chaque contrôle en référençant le en tant qu’extension de Stylebalisage {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 de textBox, la propriété Margin a la valeur 4, ce qui signifie que le TextBox 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 affectée à la Margin propriété sur le second TextBox. Cela fait que le second TextBox a une marge différente de ce que le style spécifie, de sorte qu’il s’aligne horizontalement sur le premier TextBox.

<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. pour TargetType le 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 TextBox contrôle et un Button contrôle.

<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 StylebaseStyle nommé. InheritedStyle hérite de la Background valeur de YellowBaseStyle et ajoute une Foreground valeur de Red.

<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 . Chacune Setter a une propriété et une valeur. Property est le nom de la propriété de l’élément auquel le style est appliqué. Value 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 élément 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 qui est 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 qui est 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 en Application.Resources 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.

Un Style élément 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. Qui Style est 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 pour appliquer des Style valeurs à n’importe quelle propriété de dépendance. Mais il s’agit de la Setter propriété Template d’une classe dérivée du contrôle qui constitue la majorité du balisage XAML dans un objet classique Style. 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 dans les scénarios de création de modèles de Style 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 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 vos nouvelles valeurs remplacent 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 le Style. S’il s’agit truede , 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é mis en service 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 BasedOn seul style. 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 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 TargetType propriété . Si vous définissez le style implicitement, le style est appliqué uniquement aux types qui correspondent TargetType exactement et non aux éléments dérivés de la TargetType valeur. Par exemple, si vous créez implicitement un style pour tous les contrôles ToggleButton de votre application, et que votre application a ToggleButton des contrôles CheckBox et (CheckBox dérive de ToggleButton), le style implicite « ToggleButton » est appliqué uniquement aux ToggleButton contrôles.

Remarques sur la syntaxe XAML

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

L’utilisation de la Style classe 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 tous les Style éléments créés dans le code sont généralement disponibles trop tard pour être appliqués aux contrôles dans une interface utilisateur.

Constructeurs

Propriétés

Méthodes

S’applique à

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
• Modèles de contrôles XAML