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 e TextBox. O exemplo define a propriedade FrameworkElement.Style de cada controle referenciando o Style como uma extensã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 de 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 Guia de sintaxe XAML.

Observe que, no estilo do TextBox, a propriedade Margin é definida como 4, o que significa que o TextBox tem uma margem de 4 em todos os lados. Para compensar o comprimento do segundo TextBlock, que é menor que o primeiro TextBlock porque Sobrenome ocupa menos espaço que 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, para 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 para o primeiro elemento de estilo é definido TextBox como e o TargetType para o segundo elemento de 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 Stylenome InheritedStyle baseado em um StyleBaseStyle nomeado. InheritedStyle herda o Background valor de de BaseStyleYellow 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

Um 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 é o valor aplicado à propriedade .

Para aplicar um Style, o objeto de destino deve ser um 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. Do contrário, uma exceção será acionada.

Se você definir um valor para a mesma propriedade em um e também em um Style elemento diretamente, o valor definido no elemento terá precedência diretamente. Para obter mais informações, consulte Visão geral das propriedades de dependência, especificamente a seção "Precedência do 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 Style na coleção FrameworkElement.Resources (Page.Resources se o elemento raiz for uma Página).
• Para um Style usado por mais de uma página em seu aplicativo, você normalmente define o Style na coleção Application.Resources . Como alternativa, você pode ter um arquivo XAML separado para o aplicativo no Application.Resources qual você inclui como um valor MergedDictionaries .
• A maioria dos elementos da 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 aplicativo como o ponto de partida ao editar cópias de estilos como habilitadas pelas ferramentas, mas uma vez que você faz essa cópia, ela precisa ser incluída em uma das coleções Resources ou acessada indiretamente por meio de MergedDictionaries. Em todos esses casos, o XAML modificado que substitui o padrão é incluído como parte do aplicativo.

Um Style elemento definido em um ResourceDictionary não é necessário para ter um atributo x:Key ou 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 Control que constitui a maioria da marcação XAML em um típico Style. O Valor de 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 modelo padrão Style e o ControlTemplate dentro podem ter centenas de linhas de XAML. Para obter mais informações sobre a função de em cenários de Style modelagem de controle, consulte Modelos de controle XAML.

O modelo para 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 em 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 que essa propriedade tenha 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 Style é referenciado e usado para valores por um objeto carregado, o Style deve ser considerado selado. Você pode detectar o estado selado verificando o valor da propriedade IsSealed para o Style. Se for true, o estilo será selado 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 selado também pode ser detectado quando o objeto em que o 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 desse objeto referencie especificamente o valor Style as a 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 os 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 em código (por exemplo, chamar um construtor e compilar os valores setter um por 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 criado no código geralmente está disponível tarde demais para ser aplicado aos controles em uma interface do usuário.

Construtores

Propriedades

Métodos

Aplica-se a

Confira também

• DependencyObject
• ControlTemplate
• Setter
• Visão geral das propriedades de dependência
• Referências de ResourceDictionary e recursos XAML
• Aplicando estilos a controles
• Modelos de controle XAML