Style Classe

Definição

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>

Herança

Object Platform::Object IInspectable DependencyObject Style

Atributos

ContentPropertyAttribute ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Exemplos

Este exemplo cria dois estilos: um para um TextBlock e outro para um TextBox. Cada estilo é aplicado a duas instâncias de um controle para criar uma aparência uniforme para cada TextBlock um e TextBox. O exemplo define a propriedade FrameworkElement.Style de cada controle fazendo referência à Styleextensão de marcação {StaticResource}. O exemplo também mostra como recuperar um estilo de um dicionário de recursos e aplicá-lo a um controle no código.

Cada estilo tem várias partes setter . Neste XAML, nenhum Style.Setters elemento de propriedade XAML é exibido. Esse é o uso típico em XAML para essa propriedade. O Style.Setters valor é implícito, pois Setters é a propriedade de conteúdo XAML para um Style. Para obter mais informações sobre a sintaxe XAML e como a sintaxe de conteúdo XAML possibilita implicar e omitir determinados elementos XAML, consulte o guia de sintaxe XAML.

Observe que, no estilo do TextBox, a propriedade Margin é definida como 4, o que significa que ela TextBox tem uma margem de 4 em todos os lados. Para compensar o comprimento do segundo TextBlock, que é menor que o primeiro TextBlockporque Sobrenome tem menos espaço que o Nome, um valor de "6,4,4,4" é atribuído à Margin propriedade no segundo TextBox. Isso faz com que o segundo TextBox tenha uma margem diferente do que o estilo especifica, de modo que ele se alinhe horizontalmente com o primeiro 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);
}

Este exemplo cria dois elementos de estilo. O TargetType elemento de primeiro estilo é definido TextBox como e o TargetType elemento de segundo estilo é definido Buttoncomo . Em seguida, elas são aplicadas como o estilo implícito para um TextBox controle e um Button controle.

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

Este exemplo cria um StyleInheritedStyle nomeado que se baseia em um StyleBaseStyle nomeado. InheritedStyle herda o Background valor de YellowBaseStyle e adiciona um Foreground valor 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>

Comentários

Uma Style é basicamente uma coleção de configurações de propriedade aplicadas a uma ou mais instâncias de um tipo específico que tem essas propriedades. Um Style contém uma coleção de um ou mais objetos Setter . Cada Setter um tem uma propriedade e um valor. O Property é o nome da propriedade do elemento ao qual o estilo é aplicado. O Value valor é aplicado à propriedade.

Para aplicar um Style, o objeto de destino deve ser dependencyObject. A propriedade que cada Setter faz referência como um valor de propriedade deve ser uma propriedade de dependência.

Você deve definir a propriedade TargetType ao criar um Style. Caso contrário, uma exceção será gerada.

Se você definir um valor para a mesma propriedade em um Style elemento e também diretamente em um elemento, o valor definido no elemento terá precedência diretamente. Para obter mais informações, consulte a visão geral das propriedades de dependência, especificamente a seção "Precedência de valor da propriedade de dependência".

Definindo um estilo como um recurso XAML

Um Style é quase sempre definido em XAML como um recurso em um ResourceDictionary.

• Para um Style que é usado apenas por outros itens de interface do usuário definidos na mesma página XAML, você normalmente define o Estilo na coleção FrameworkElement.Resources (Page.Resources se o elemento raiz for uma página).
• Para um Style que é usado por mais de uma página em seu aplicativo, você normalmente define o Estilo na coleção Application.Resources . Como alternativa, você pode ter um arquivo XAML separado para o aplicativo que você inclui Application.Resources como um valor MergedDictionaries .
• A maioria dos elementos de interface do usuário tem um estilo padrão definido pelo Windows Runtime. Cópias dos estilos padrão podem ser vistas no arquivo XAML auxiliar de design chamado generic.xaml, que tecnicamente não é um arquivo de recurso para aplicativos, embora seja estruturado como um. Você pode copiar partes discretas desse arquivo no XAML do seu aplicativo como o ponto de partida quando editar cópias de estilos como habilitados pelas ferramentas, mas depois de fazer essa cópia, ela precisará ser incluída em uma das coleções de recursos ou acessada indiretamente por meio de MergedDictionaries. Em todos esses casos, o XAML modificado que substitui o padrão é incluído como parte do seu aplicativo.

Um Style elemento definido em um ResourceDictionary não é necessário para ter um atributo x:Key ou atributo x:Name, que normalmente é um requisito de ser um recurso XAML. Um Style que é definido dessa forma usa seu valor de propriedade TargetType como a chave implícita e é conhecido como um estilo implícito.

Para obter mais informações sobre como usar dicionários de recursos XAML, consulte referências de recursos ResourceDictionary e XAML.

Estilos e modelos

Você pode usar um Setter em um Style para aplicar valores a qualquer propriedade de dependência. Mas é para a Setter propriedade Template de uma classe derivada de controle que constitui a maior parte da marcação XAML em um típico Style. O Valor para um Setter com Property="Template" é quase sempre especificado como um elemento de propriedade que contém um elemento de objeto ControlTemplate .

Quando um Style é usado para definir um modelo de controle, o TargetType do Style elemento e o TargetType do elemento ControlTemplate para seu setter Control.Template sempre devem usar o mesmo valor.

O setter de modelo define a definição básica da interface do usuário do modelo para uma instância de controle em que esse modelo é aplicado. Ele também contém os estados visuais de um controle e outras definições de interface do usuário baseadas em estado, como transições de tema padrão. Para um controle complexo, como ListBox, o estilo de modelo padrão e o ControlTemplate dentro podem ter centenas de linhas de XAML. Para obter mais informações sobre a função de cenários de Style modelagem de controle, consulte modelos de controle XAML.

O modelo de um controle geralmente inclui estados visuais que alteram a aparência do controle em resposta a estados lógicos. Por exemplo, um Botão pode ter uma aparência visual diferente quando pressionado aplicando um novo estado visual de seu modelo, e todas as alterações de aparência podem vir de XAML e não de código. Para obter mais informações sobre como os estados visuais funcionam e como modificá-los ou definir estados para controles personalizados, consulte modelos de controle XAML.

Estilos e comportamento de runtime

Você pode alterar os valores de propriedades individuais que foram definidas por um Style tempo de execução e seus novos valores substituem os valores setters . Por exemplo, você pode definir a propriedade Template em tempo de execução mesmo se essa propriedade tiver sido definida por um estilo.

Você pode ajustar as propriedades de um Style em tempo de execução, mas somente se esse estilo não tiver sido aplicado a nada e existir apenas como um recurso que não está sendo usado implicitamente. Por exemplo, você pode adicionar setters à coleção em Setters para um estilo que existe em Recursos com um atributo x:Key , mas não tem nenhum valor de extensão de marcação {StaticResource} em outro lugar no XAML que se refere a esse estilo. No entanto, assim que um Estilo for referenciado e usado para valores por um objeto carregado, ele Style deverá ser considerado lacrado. Você pode detectar o estado lacrado verificando o valor da propriedade IsSealed para o Style. Se for true, o estilo será lacrado e você não poderá modificar nenhuma propriedade dele ou os subvalores setter dentro. O ponto no tempo em que um estilo foi colocado em uso e lacrado também pode ser detectado quando o objeto em que ele Style é referenciado gera seu evento Loaded .

Estilos BasedOn

Você pode criar um novo estilo com base em um estilo existente definido pelo aplicativo ou por estilos padrão para controles Windows Runtime. Você pode fazer isso usando a propriedade BasedOn . Isso reduz a duplicação em seu XAML e facilita o gerenciamento de recursos. Cada estilo dá suporte a apenas um BasedOn estilo. Para obter mais informações, consulte controles BasedOn ou Styling.

Estilos implícitos

Você pode definir estilos de modo que um Style seja usado implicitamente por todos os objetos do mesmo TargetType, sem exigir que cada instância de um objeto faça referência especificamente ao estilo como um valor FrameworkElement.Style . Quando um <Style> recurso é declarado em um ResourceDictionary sem um atributo x:Key, o valor x:Key usa o valor da TargetType propriedade. Se você definir o estilo implicitamente, o estilo será aplicado somente aos tipos que correspondem TargetType exatamente aos elementos derivados do TargetType valor. Por exemplo, se você criar um estilo implicitamente para todos os controles ToggleButton em seu aplicativo, e seu aplicativo tiver ToggleButton e controles CheckBox (CheckBox derivados de ToggleButton), o estilo implícito "ToggleButton" será aplicado somente aos ToggleButton controles.

Anotações sobre a sintaxe XAML

Setters é a propriedade de conteúdo XAML para, portanto Style, você pode usar uma sintaxe de coleção implícita, como <Style><Setter .../><Setter .../></Style>.

Usar a Style classe no código (por exemplo, chamar um construtor e compilar os valores setter um a um) é muito raro. Os estilos são usados para modelos e os modelos devem estar disponíveis no tempo de carregamento XAML, portanto, qualquer Style um criado no código geralmente está disponível tarde demais para ser aplicado a controles em uma interface do usuário.

Confira também

• DependencyObject
• ControlTemplate
• Setter
• Visão geral das propriedades de dependência
• ResourceDictionary e referências de recursos XAML
• Controles de estilo
• Modelos de controle XAML