Style Classe

Definição

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>

Herança

Object Platform::Object IInspectable DependencyObject Style

Atributos

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute ContentPropertyAttribute

Requisitos do Windows

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 da TextBox, a propriedade Margin é definida como 4, o que significa que 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 tem menos espaço que Nome, um valor de "6,4,4,4" é atribuído à propriedade Margin na segunda 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 como TextBox e o TargetType para o segundo elemento de estilo é definido como Button. Em seguida, eles são aplicados como o estilo implícito para um controle TextBox e um controle 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>

Este exemplo cria um Estilo chamado InheritedStyle baseado em um Estilo chamado BaseStyle. InheritedStyle herda o valor Background de Yellow de BaseStyle e adiciona um valor Foreground 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 tem uma Propriedade e um Valor. A Propriedade é o nome da propriedade do elemento ao qual o estilo é aplicado. O Valor é 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 property 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 Style e também em um 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 de valor da propriedade de dependência".

Definindo um estilo como um recurso XAML

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

• Para um Style 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 Page).
• 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 que você inclui em 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 ao editar cópias de estilos conforme habilitado pelas ferramentas, mas depois de fazer essa cópia, ele precisa ser incluído em uma das coleções Resources ou acessado indiretamente por meio de MergedDictionaries. Em todos esses casos, o XAML modificado que substitui o padrão é incluído como parte do seu aplicativo.

Windows 8 Se você estiver modelando novamente um controle existente no XAML do Windows 8, às vezes modificará os elementos Style existentes no arquivo XAML StandardStyles.xaml que está incluído na maioria dos modelos de aplicativo iniciais. StandardStyles.xaml é referenciado pelos arquivos app.xaml de modelo como um arquivo de origem MergedDictionaries . Modelos para aplicativos que começam com Windows 8.1 não usam mais StandardStyles.xaml.

Um elemento definido por Style em um ResourceDictionary não precisa ter um atributo x:Key ou um atributo x:Name, que normalmente é um requisito de ser um recurso XAML. Um Style 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 é o Setter para a propriedade Template de uma classe derivada de Control que constitui a maioria da marcação XAML em um Estilo típico. 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 elemento Style 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 Estilo em cenários de 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 Animações com storyboard para estados visuais e 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 Resources 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 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 dele. O ponto no tempo em que um estilo foi colocado em uso e lacrado 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 seu 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 estilo BasedOn . 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 faça referência especificamente ao Style 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 propriedade TargetType . Se você definir o estilo implicitamente, o estilo será aplicado somente aos tipos que correspondem exatamente ao TargetType e não aos elementos derivados do valor TargetType . Por exemplo, se você criar um estilo implicitamente para todos os controles ToggleButton em seu aplicativo e seu aplicativo tiver controles ToggleButton e CheckBox (CheckBox deriva de ToggleButton), o estilo implícito "ToggleButton" será aplicado somente aos controles ToggleButton .

Observações sobre a sintaxe XAML

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

Usar a classe Style no 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 Estilo 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
• Início rápido: modelos de controle