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 : 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 l’extension Style 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 code 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 le guide de syntaxe XAML.

Notez que dans le style de la zone de texte, la propriété Margin est définie sur 4, ce qui signifie que la TextBox marge est de 4 sur tous les côtés. Pour compenser la longueur du deuxième TextBlock, qui est plus courte que la première TextBlock , car le nom prend moins de place que le prénom, la valeur « 6,4,4,4 » est affectée à la propriété sur la Margin seconde TextBox. Cela entraîne la seconde TextBox d’avoir une marge différente de ce que le style spécifie, afin qu’il s’aligne horizontalement avec 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. Le TargetType premier élément de style est défini TextBox sur et le TargetType deuxième élément de style est défini sur Button. Elles sont ensuite appliquées 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 StyleinheritedStyle nommé basé sur un StyleBaseStyle nommé. InheritedStyle hérite de la Background valeur de Yellow et BaseStyle 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

Il Style s’agit essentiellement d’une collection de paramètres de propriété appliqué à une ou plusieurs instances d’un type particulier qui possède de telles propriétés. A Style contient une collection d’un ou plusieurs objets Setter . Chacun Setter a une propriété et une valeur. Il Property s’agit du nom de la propriété de l’élément auquel le style est appliqué. Il Value s’agit de la valeur appliquée à la propriété.

Pour appliquer un Styleobjet cible, il doit s’agir d’un DependencyObject. La propriété que chaque Setter référence en tant que valeur de propriété 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 prioritaire. Pour plus d’informations, consultez la vue d’ensemble des propriétés de dépendance, en particulier la section « Priorité des valeurs de propriété de dépendance ».

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

A Style est presque toujours défini en XAML comme ressource dans un ResourceDictionary.

• Pour un Style élément 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 une Style page utilisée 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. Les copies des styles par défaut sont visibles dans le fichier XAML d’assistance de conception appelé generic.xaml, qui n’est pas techniquement un fichier de ressources pour les applications, même s’il est 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 activées par les outils, mais une fois que vous effectuez une telle copie, 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 le cadre de votre application.

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

Pour plus d’informations sur l’utilisation des dictionnaires de ressources XAML, consultez les références de ressources ResourceDictionary et 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 il s’agit Setter de la propriété Template d’une classe dérivée de Contrôle qui constitue la majorité du balisage XAML dans une classe classique Style. La valeur d’un Setter avec est Property="Template" presque toujours spécifiée en tant qu’élément de propriété qui contient un élément d’objet ControlTemplate .

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

Le jeu de modèles définit la définition de l’interface utilisateur de modèle de base pour une 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 style de modèle par défaut et le ControlTemplate au sein peuvent avoir des centaines de lignes de XAML. Pour plus d’informations sur le rôle des scénarios de création de modèles de Style contrôle, consultez les 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 du code. Pour plus d’informations sur le fonctionnement des états visuels et leur modification ou leur définition d’états pour les contrôles personnalisés, consultez les modèles de contrôle XAML.

Styles et comportement d’exécution

Vous pouvez modifier les valeurs des propriétés individuelles qui ont été définies par une Style 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 élément 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 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 d’un objet chargé, il 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. Si c’est truele cas, 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 auquel l’objet Style est référencé déclenche son événement Loaded .

Styles BasedOn

Vous pouvez créer un nouveau style basé sur un style existant défini par votre application ou 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 BasedOn style. Pour plus d’informations, consultez Contrôles BasedOn ou Style.

Styles implicites

Vous pouvez définir des styles de sorte qu’un Style objet 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 implicitement le style, 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 un style implicitement pour tous les contrôles ToggleButton dans votre application et que votre application possède ToggleButton et contrôle CheckBox (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, de sorte que vous pouvez utiliser une syntaxe de collection implicite telle que <Style><Setter .../><Setter .../></Style>.

L’utilisation de la classe dans le Style code (par exemple, l’appel d’un constructeur et la création des valeurs Setter un par un) 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. Par conséquent, tout élément Style créé dans le code est généralement trop tard pour être appliqué aux contrôles d’une interface utilisateur.

Voir aussi

• DependencyObject
• ControlTemplate
• Setter
• Vue d’ensemble des propriétés de dépendance
• Références aux ressources ResourceDictionary et XAML
• Contrôles de style
• Modèles de contrôle XAML