Style Classe

Riferimento

Definizione

Spazio dei nomi:: Microsoft.UI.Xaml

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Modifica

Contiene setter di proprietà che possono essere condivisi tra istanze di un tipo. Un Style oggetto viene in genere dichiarato in una raccolta di risorse in modo che possa essere condiviso e usato per l'applicazione di modelli di controllo e altri stili.

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 all'oggetto Style come estensione di markup {StaticResource}. L'esempio illustra anche come recuperare uno stile da un dizionario di 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à contenuto XAML per uno Stile. Per altre informazioni sulla sintassi XAML e sul modo in cui la sintassi del contenuto XAML consente di implicare e omettere determinati elementi XAML, vedere La 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 perché cognome accetta meno spazio rispetto al primo TextBlock nome, un valore di "6,4,4,4" viene assegnato alla proprietà sul Margin secondo TextBox. Ciò comporta che il secondo TextBox abbia un margine diverso rispetto a quello specificato dallo stile, in modo che si allinea orizzontalmente con il primo 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. Per TargetType il primo elemento di stile è impostato su TextBox e il TargetType per il secondo elemento di stile è 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 Styleoggetto EreditatStyle denominato basato su base StylebaseStyle. 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 delle proprietà applicate a una o più istanze di un determinato tipo con tali proprietà. Un Style oggetto contiene una raccolta di uno o più oggetti Setter . Ogni Setter oggetto 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 Styleoggetto , l'oggetto di destinazione deve essere un DependencyObject. La proprietà a cui ogni Setter fa riferimento come valore Property deve essere una proprietà di dipendenza.

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

Se si imposta un valore per la stessa proprietà in un Style elemento e anche su un elemento direttamente, il valore impostato sull'elemento assume direttamente la precedenza. Per altre informazioni, vedere 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 ResourceDictionary.

Per un Style oggetto utilizzato solo da altri elementi dell'interfaccia utente definiti nella stessa pagina XAML, in genere si definisce lo stile nell'insieme FrameworkElement.Resources (Page.Resources se l'elemento radice è una pagina).
Per un Style oggetto utilizzato da più pagine dell'app, in genere si definisce lo stile nell'insieme Application.Resources . In alternativa, potrebbe essere presente un file XAML separato per l'app inclusa in Application.Resources come valore MergeDictionary .
La maggior parte degli elementi dell'interfaccia utente ha uno stile predefinito definito dalla Windows Runtime. Le copie degli stili predefiniti possono essere visualizzate nel file XAML di progettazione-helper denominato generic.xaml, che non è tecnicamente un file di risorse per le app anche se è strutturato come uno. È possibile copiare parti discrete di questo file nel codice XAML dell'app come punto di partenza quando si modificano copie di stili come abilitati dagli strumenti, ma dopo aver eseguito una copia di questo tipo, è necessario includere in una delle raccolte Risorse o accedere indirettamente tramite MergeDictionary. In tutti questi casi il codice XAML modificato che esegue l'override del valore predefinito è incluso come parte dell'app.

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

Per altre informazioni sull'uso dei dizionari delle risorse XAML, vedere Riferimenti alle risorse ResourceDictionary e XAML.

Stili e modelli

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

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

Il setter modello definisce la definizione dell'interfaccia utente del modello di base per un'istanza di controllo in cui viene applicato tale modello. Contiene anche gli stati visivi 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, lo stile predefinito del modello e il controlloTemplate all'interno possono avere centinaia di righe di XAML. Per altre informazioni sul ruolo di negli scenari di templating del controllo, vedere Modelli di Stylecontrollo XAML.

Il modello per un controllo include spesso stati visivi 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 visivo dal modello e tutte le modifiche di aspetto possono derivare da CODICE XAML. Per altre informazioni sul funzionamento degli stati visivi e su come modificarli o definire gli stati per i controlli personalizzati, vedere Modelli di controllo XAML.

Stili e comportamento di runtime

È possibile modificare i valori delle singole proprietà impostate da un Style oggetto 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 in base a uno stile.

È possibile modificare le proprietà di un oggetto Style in fase di esecuzione, ma solo se tale stile non è stato applicato a nulla e esiste solo come risorsa che non viene usata in modo implicito. Ad esempio, è possibile aggiungere setters all'insieme in Setters per uno stile presente 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, è Style necessario considerare sealed. È possibile rilevare lo stato bloccato controllando il valore della proprietà IsSealed per .Style Se è true, lo stile è bloccato e non è possibile modificare le proprietà di esso o i sottovalore Setter all'interno. Il momento in cui uno stile è stato messo in uso e bloccato può essere rilevato anche quando l'oggetto a cui Style fa riferimento genera l'evento Caricato .

Stili BasedOn

È possibile creare un nuovo stile in base a uno stile esistente definito dall'app o per impostazione predefinita per i controlli di Windows Runtime. È possibile eseguire questa operazione usando la proprietà BasedOn . Ciò riduce la duplicazione nel codice XAML e semplifica la gestione delle risorse. Ogni stile supporta solo uno BasedOn stile. Per altre informazioni, vedere Controlli BasedOn o Styling.

Stili impliciti

È possibile definire stili in modo che un Style oggetto venga usato in modo implicito da tutti gli oggetti dello stesso TargetType, senza richiedere a ogni istanza di tale oggetto di fare riferimento in modo specifico allo stile 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 CheckBox (CheckBox deriva da ToggleButton), lo stile implicito "ToggleButton" viene applicato solo ai ToggleButton controlli.

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 Style classe 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 Style creato nel codice è in genere disponibile troppo tardi per essere applicato ai controlli in un'interfaccia utente.

Costruttori

Style()	Inizializza una nuova istanza della classe Style , senza TargetType iniziale e un insieme Setters vuoto.
Style(TypeName)	Inizializza una nuova istanza della classe Style , con un oggetto TargetType iniziale specificato e un insieme Setters vuoto.

Proprietà

BasedOn	Ottiene o imposta uno stile definito che è la base dello stile corrente.
Dispatcher	Restituisce `null` sempre in un'app SDK per app di Windows. Usare invece DispatcherQueue . (Ereditato da DependencyObject)
DispatcherQueue	Ottiene l'oggetto `DispatcherQueue` associato. Rappresenta `DispatcherQueue` una struttura che può accedere al thread dell'interfaccia utente anche se il codice viene avviato da un thread non dell'interfaccia `DependencyObject` utente. (Ereditato da DependencyObject)
IsSealed	Ottiene un valore che indica se questo stile è di sola lettura e non può essere modificato.
Setters	Ottiene una raccolta di oggetti Setter .
TargetType	Ottiene o imposta il tipo per il quale è previsto lo stile. `TargetType` può essere usato per dichiarare una risorsa di stile implicita se non è specificata alcuna chiave di risorsa.

Metodi

ClearValue(DependencyProperty)	Cancella il valore locale di una proprietà di dipendenza. (Ereditato da DependencyObject)
GetAnimationBaseValue(DependencyProperty)	Restituisce qualsiasi valore di base stabilito per una proprietà di dipendenza, che si applica nei casi in cui un'animazione non è attiva. (Ereditato da DependencyObject)
GetValue(DependencyProperty)	Restituisce il valore effettivo corrente di una proprietà di dipendenza da un oggetto DependencyObject. (Ereditato da DependencyObject)
ReadLocalValue(DependencyProperty)	Restituisce il valore locale di una proprietà di dipendenza, se viene impostato un valore locale. (Ereditato da DependencyObject)
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)	Registra una funzione di notifica per l'ascolto delle modifiche a un'istanza di DependencyObject specifica. (Ereditato da DependencyObject)
Seal()	Blocca lo stile in modo che la proprietà TargetType o qualsiasi Setter nell'insieme Setters non possa essere modificata.
SetValue(DependencyProperty, Object)	Imposta il valore locale di una proprietà di dipendenza in un oggetto DependencyObject. (Ereditato da DependencyObject)
UnregisterPropertyChangedCallback(DependencyProperty, Int64)	Annulla una notifica di modifica registrata in precedenza chiamando RegisterPropertyChangedCallback. (Ereditato da DependencyObject)

Si applica a

Condividi tramite