Style Classe

Definizione

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>

Ereditarietà

Object Platform::Object IInspectable DependencyObject Style

Attributi

ContentPropertyAttribute ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Esempio

In questo esempio vengono creati due stili: uno per textBlock e uno per un controllo TextBox. Ogni stile viene applicato a due istanze di un controllo per creare un aspetto uniforme per ognuno TextBlock e TextBox. Nell'esempio viene impostata la proprietà FrameworkElement.Style di ogni controllo facendo riferimento a Style come estensione di markup {StaticResource}. L'esempio mostra anche come recuperare uno stile da un dizionario risorse e applicarlo a un controllo nel codice.

Ogni stile ha più parti setter . In questo codice XAML non viene visualizzato alcun Style.Setters elemento della proprietà XAML. Questo è l'utilizzo tipico in XAML per questa proprietà. Il Style.Setters valore è implicito, perché Setters è la proprietà del contenuto XAML per uno Style. Per altre info sulla sintassi XAML e sul modo in cui la sintassi del contenuto XAML consente di implicare e omettere determinati elementi XAML, vedi guida alla sintassi XAML.

Si noti che nello stile per TextBox la proprietà Margin è impostata su 4, il che significa che ha TextBox un margine pari a 4 su tutti i lati. Per compensare la lunghezza del secondo TextBlock, che è più breve del primo TextBlock perché cognome prende meno spazio rispetto a First Name, il valore "6,4,4,4" viene assegnato alla proprietà sul Margin secondo TextBox. In questo modo, il secondo TextBox ha un margine diverso da quello specificato dallo stile, in modo che sia allineato orizzontalmente con il primo TextBoxoggetto .

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

In questo esempio vengono creati due elementi di stile. L'oggetto TargetType per il primo elemento di stile è impostato su TextBox e per TargetType il secondo elemento di stile viene impostato su Button. Questi vengono quindi applicati come stile implicito per un TextBox controllo e un Button controllo .

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

In questo esempio viene creato un Style oggetto InheritedStyle denominato basato su un Style oggetto BaseStyle denominato. InheritedStyle eredita il Background valore di Yellow da BaseStyle e aggiunge un Foreground valore di 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>

Commenti

Un Style oggetto è fondamentalmente una raccolta di impostazioni di proprietà applicate a una o più istanze di un particolare tipo con tali proprietà. Contiene Style una raccolta di uno o più oggetti Setter . Ognuno Setter ha una proprietà e un valore. Property è il nome della proprietà dell'elemento a cui viene applicato lo stile. Value è il valore applicato alla proprietà .

Per applicare un oggetto Style, l'oggetto di destinazione deve essere un DependencyObject. La proprietà a cui fa riferimento ogni Setter come valore Property deve essere una proprietà di dipendenza.

È necessario impostare la proprietà TargetType quando si crea un oggetto Style. In caso contrario, viene generata un'eccezione.

Se si imposta un valore per la stessa proprietà in un Style oggetto e anche su un elemento direttamente, il valore impostato sull'elemento ha la precedenza direttamente. Per altre info, vedi Panoramica delle proprietà di dipendenza, in particolare la sezione "Precedenza del valore della proprietà di dipendenza".

Definizione di uno stile come risorsa XAML

Un Style oggetto è quasi sempre definito in XAML come risorsa in un Oggetto ResourceDictionary.

• Per un Style oggetto usato solo da altri elementi dell'interfaccia utente definiti nella stessa pagina XAML, in genere definisci style nell'insieme FrameworkElement.Resources (Page.Resources se l'elemento radice è page).
• Per un Style oggetto usato da più pagine nell'app, in genere definisci lo stile nella raccolta Application.Resources . In alternativa, potresti avere un file XAML separato per l'app che includi in Application.Resources come valore MergedDictionaries .
• La maggior parte degli elementi dell'interfaccia utente ha uno stile predefinito definito dal Windows Runtime. Le copie degli stili predefiniti possono essere visualizzate nel file XAML dell'helper di progettazione denominato generic.xaml, che non è tecnicamente un file di risorse per le app, anche se è strutturato come uno. Puoi copiare parti discrete di questo file nel codice XAML dell'app come punto di partenza quando modifichi copie di stili come abilitati dagli strumenti, ma dopo aver creato una copia di questo tipo deve essere inclusa in una delle raccolte Resources o accessibile indirettamente tramite MergedDictionaries. In tutti questi casi il codice XAML modificato che esegue l'override del valore predefinito viene incluso nell'ambito dell'app.

Un Style elemento definito in un oggetto ResourceDictionary non deve avere un attributo x:Key o un attributo x:Name, che in genere è un requisito di essere una risorsa XAML. Oggetto Style definito in questo modo usa il valore della proprietà TargetType come chiave implicita ed è noto come stile implicito.

Per altre info su come usare i dizionari risorse XAML, vedi Riferimenti alle risorse ResourceDictionary e XAML.

Stili e modelli

È possibile usare un setter in un Style per applicare valori a qualsiasi proprietà di dipendenza. Ma è per Setter la proprietà Template di una classe derivata da Control che costituisce la maggior parte del markup XAML in un tipico Styleoggetto . Il valore di un Setter oggetto con Property="Template" è quasi sempre specificato come elemento di proprietà che contiene un elemento oggetto ControlTemplate .

Quando un Style oggetto viene utilizzato per definire un modello di controllo, targetType dell'elemento Style e targetType dell'elemento ControlTemplate per il setter Control.Template deve usare sempre lo stesso valore.

Il setter modello definisce la definizione dell'interfaccia utente del modello di base per un'istanza del controllo in cui viene applicato il modello. Contiene anche gli stati di visualizzazione per un controllo e altre definizioni dell'interfaccia utente basate su stato, ad esempio transizioni di tema predefinite. Per un controllo complesso, ad esempio ListBox, il modello predefinito Style e ControlTemplate all'interno può avere centinaia di righe di XAML. Per altre info sul ruolo di negli scenari di Style creazione di modelli di controllo, vedi Modelli di controllo XAML.

Il modello per un controllo include spesso stati di visualizzazione che modificano l'aspetto del controllo in risposta agli stati logici. Ad esempio, un pulsante può avere un aspetto visivo diverso quando viene premuto applicando un nuovo stato di visualizzazione dal modello e tutte le modifiche dell'aspetto possono provenire da XAML non dal codice. Per altre info sul funzionamento degli stati di visualizzazione e su come modificarli o definire gli stati per i controlli personalizzati, vedi Modelli di controllo XAML.

Stili e comportamento di runtime

È possibile modificare i valori delle singole proprietà impostate da un oggetto Style in fase di esecuzione e i nuovi valori sovrascrivono i valori setter . Ad esempio, è possibile impostare la proprietà Template in fase di esecuzione anche se questa proprietà è stata impostata da uno stile.

È possibile modificare le proprietà di un oggetto Style in fase di esecuzione, ma solo se tale stile non è stato applicato ad alcun elemento e esiste solo come risorsa che non viene usata in modo implicito. Ad esempio, puoi aggiungere setter alla raccolta in Setters per uno stile esistente in Resources con un attributo x:Key , ma non ha un valore di estensione di markup {StaticResource} altrove in XAML che fa riferimento a tale stile. Tuttavia, non appena viene fatto riferimento a style e utilizzato per i valori da un oggetto caricato, l'oggetto Style deve essere considerato sealed. È possibile rilevare lo stato sealed controllando il valore della proprietà IsSealed per .Style Se è true, lo stile è sealed e non è possibile modificare le proprietà di esso o i sottovalori Setter all'interno. Il momento in cui uno stile è stato messo in uso e sealed può anche essere rilevato quando l'oggetto a cui Style viene fatto riferimento genera l'evento Loaded .

Stili BasedOn

Puoi creare un nuovo stile basato su uno stile esistente definito dall'app o dagli stili predefiniti per i controlli Windows Runtime. A tale scopo, usare la proprietà BasedOn . Ciò riduce la duplicazione nel codice XAML e semplifica la gestione delle risorse. Ogni stile supporta un BasedOn solo stile. Per altre info, vedi Controlli BasedOn o Stili.

Stili impliciti

È possibile definire stili in modo che un oggetto Style venga utilizzato in modo implicito da tutti gli oggetti dello stesso TargetType, senza richiedere a ogni istanza di tale oggetto di fare riferimento specificamente a Style come valore FrameworkElement.Style . Quando una <Style> risorsa viene dichiarata in un oggetto ResourceDictionary senza un attributo x:Key, il valore x:Key usa il valore della TargetType proprietà . Se si imposta lo stile in modo implicito, lo stile viene applicato solo ai tipi che corrispondono TargetType esattamente e non agli elementi derivati dal TargetType valore. Ad esempio, se si crea uno stile in modo implicito per tutti i controlli ToggleButton nell'applicazione e l'applicazione dispone ToggleButton di controlli e CheckBox (CheckBox deriva da ToggleButton), lo stile implicito "ToggleButton" viene applicato solo ai ToggleButton controlli.

Note sulla sintassi XAML

I setter sono la proprietà del contenuto XAML per Style, in modo da poter usare una sintassi di raccolta implicita, <Style><Setter .../><Setter .../></Style>ad esempio .

L'uso della Style classe nel codice ,ad esempio la chiamata di un costruttore e la compilazione dei valori Setter uno per uno, è molto raro. Gli stili vengono usati per i modelli e i modelli devono essere disponibili in fase di caricamento XAML, quindi qualsiasi Style creato nel codice è in genere disponibile troppo tardi per essere applicato ai controlli in un'interfaccia utente.

Vedi anche

• DependencyObject
• ControlTemplate
• Setter
• Panoramica delle proprietà di dipendenza
• Riferimenti a ResourceDictionary e risorse XAML
• Controlli di stile
• Modelli di controllo XAML