Style Classe

Definizione

public ref class Style sealed : DependencyObject

/// [Windows.Foundation.Metadata.Activatable(Windows.UI.Xaml.IStyleFactory, 65536, Windows.Foundation.UniversalApiContract)]
/// [Windows.Foundation.Metadata.Activatable(65536, Windows.Foundation.UniversalApiContract)]
/// [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")]
class Style final : 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.Activatable(typeof(Windows.UI.Xaml.IStyleFactory), 65536, typeof(Windows.Foundation.UniversalApiContract))]
[Windows.Foundation.Metadata.Activatable(65536, typeof(Windows.Foundation.UniversalApiContract))]
[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")]
public sealed class Style : 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>

Ereditarietà

Object Platform::Object IInspectable DependencyObject Style

Attributi

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute ContentPropertyAttribute

Requisiti Windows

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 ogni controllo TextBlock e TextBox. Nell'esempio viene impostata la proprietà FrameworkElement.Style di ogni controllo facendo riferimento all'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 textBox ha un margine di 4 su tutti i lati. Per compensare la lunghezza del secondo TextBlock, che è più breve del primo TextBlock perché Last Name accetta meno spazio rispetto a First Name, il valore "6,4,4,4" viene assegnato alla proprietà Margin nella seconda casella di testo. In questo modo, il secondo controllo TextBox ha un margine diverso da quello specificato dallo stile, in modo che sia allineato orizzontalmente con il primo controllo 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);
}

In questo esempio vengono creati due elementi di stile. TargetType per il primo elemento di stile è impostato su TextBox e TargetType per il secondo elemento di stile è impostato su Button. Questi vengono quindi applicati come stile implicito per un controllo TextBox e un controllo 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>

In questo esempio viene creato uno stile denominato InheritedStyle basato su uno stile denominato BaseStyle. InheritedStyle eredita il valore Background di Yellow da BaseStyle e aggiunge un valore Foreground 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 oggetto Style è fondamentalmente una raccolta di impostazioni delle proprietà applicate a una o più istanze di un particolare tipo con tali proprietà. Un oggetto Style contiene un insieme di uno o più oggetti Setter . Ogni 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 uno Style, l'oggetto di destinazione deve essere 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 imposti un valore per la stessa proprietà in uno Style 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

Uno stile è quasi sempre definito in XAML come risorsa in un ResourceDictionary.

• Per uno stile usato solo da altri elementi dell'interfaccia utente definiti nella stessa pagina XAML, in genere definisci lo stile nell'insieme FrameworkElement.Resources (Page.Resources se l'elemento radice è page).
• Per uno stile usato da più pagine dell'app, in genere definisci lo stile nell'insieme 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 della tua 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 dell'impostazione predefinita viene incluso come parte dell'app.

Windows 8 Se stai ricreando un controllo esistente in XAML di Windows 8, a volte modifichi gli elementi Style presenti nel file XAML StandardStyles.xaml incluso nella maggior parte dei modelli di app iniziali. StandardStyles.xaml fa riferimento ai file app.xaml del modello come file di origine MergedDictionaries . I modelli per le app a partire da Windows 8.1 non usano più StandardStyles.xaml.

Un elemento definito da Style in un oggetto ResourceDictionary non deve avere un attributo x:Key o x:Name, che in genere è un requisito di essere una risorsa XAML. Uno stile 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 uno stile per applicare valori a qualsiasi proprietà di dipendenza. Ma è il Setter per la proprietà Template di una classe derivata da Control che costituisce la maggior parte del markup XAML in un tipico stile. Il valore per un setter con Property="Template" è quasi sempre specificato come elemento di proprietà che contiene un elemento dell'oggetto ControlTemplate .

Quando un oggetto Style viene utilizzato per definire un modello di controllo, il TargetType dell'elemento Style e l'elemento TargetType dell'elemento ControlTemplate per il relativo setter Control.Template devono 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 sullo stato, ad esempio transizioni di tema predefinite. Per un controllo complesso, ad esempio ListBox, lo stile del modello predefinito e controlTemplate all'interno può avere centinaia di righe di XAML. Per altre info sul ruolo di Style negli scenari di 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 di 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 Animazioni con storyboard per stati di visualizzazione e 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 Setters . 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 uno Stile 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 Setter per uno stile esistente in Resources con un attributo x:Key ma non ha alcun valore di estensione di markup {StaticResource} altrove in XAML che fa riferimento a tale stile. Tuttavia, non appena viene fatto riferimento a style e usato per i valori da un oggetto caricato, lo Stile deve essere considerato sealed. È possibile rilevare lo stato sealed controllando il valore della proprietà IsSealed per Style. Se è vero, lo stile è sealed e non è possibile modificare le proprietà di esso o i sottovalore Setter all'interno. Il punto nel tempo in cui uno stile è stato messo in uso e sealed può essere rilevato anche quando l'oggetto a cui si fa riferimento a Style 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, è possibile utilizzare la proprietà BasedOn . Ciò riduce la duplicazione nel codice XAML e semplifica la gestione delle risorse. Ogni stile supporta un solo stile BasedOn . Per altre info, vedi Controlli BasedOn o Stili.

Stili impliciti

È possibile definire stili in modo che uno Style venga utilizzato in modo implicito da tutti gli oggetti dello stesso TargetType, senza richiedere a ogni istanza di tale oggetto di fare riferimento in modo specifico 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 proprietà TargetType . Se si imposta lo stile in modo implicito, lo stile viene applicato solo ai tipi che corrispondono esattamente a TargetType e non agli elementi derivati dal valore TargetType . Ad esempio, se si crea uno stile in modo implicito per tutti i controlli ToggleButton nell'applicazione e l'applicazione dispone di controlli ToggleButton e CheckBox (CheckBox deriva da ToggleButton), lo stile implicito "ToggleButton" viene applicato solo ai controlli ToggleButton .

Note sulla sintassi XAML

Setter è la proprietà del contenuto XAML per Style, quindi puoi usare una sintassi di raccolta implicita, <Style><Setter .../><Setter .../></Style>ad esempio .

L'uso della classe Style nel codice (ad esempio, la chiamata di un costruttore e la creazione 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 stile creato nel codice è in genere disponibile troppo tardi per essere applicato ai controlli in un'interfaccia utente.

Costruttori

Proprietà

Metodi

Si applica a

Vedi anche

• DependencyObject
• ControlTemplate
• Setter
• Panoramica delle proprietà di dipendenza
• Riferimenti a ResourceDictionary e risorse XAML
• Applicazione di stili ai controlli
• Guida introduttiva: Modelli di controllo