Compartilhar via

Introdução ao Windows Presentation Foundation

  • Artigo

Windows Presentation Foundation (WPF) é um sistema de apresentação da próxima geração para criar Windows aplicativos cliente com experiências visuais de usuário. Com WPF, você pode criar uma ampla gama de autônomos e aplicativos hospedados por navegador. Alguns exemplos são: Yahoo! Do Messengerhttps://go.microsoft.com/fwlink/?LinkId=91192 e o Leitor de New York Timeshttps://go.microsoft.com/fwlink/?LinkId=91193, bem sistema autônomo a aplicativo de exemplo Contoso Healthcarehttps://go.microsoft.com/fwlink/?LinkId=91196 mostrado na figura a seguir.

Exemplo de interface do usuário da Contoso Healthcare

O núcleo do WPF é um mecanismo de resolução independente e renderização vetorial que é criado para tirar proveito dos modernos hardwares gráficos . WPF estende o núcleo com um conjunto abrangente de recursos de desenvolvimento de aplicativo que incluem Extensible Application Markup Language (XAML),controles, associação de dados, layout, 2-D e 3-D Elementos gráficos, animação, estilos, modelos, documentos, mídias, texto e tipografia. WPF está incluído no Microsoft .NET Framework,portanto, você pode criar aplicativos que incorporam outros elementos da .NET Framework biblioteca de classes.

Esta visão geral é destinada para principiantes e aborda os principais recursos e conceitos de WPF. Desenvolvedores experientes WPF buscam uma revisão das WPF também podem achar esta visão geral útil.

ObservaçãoObservação:

Para novos e atualizados WPF recursos das .NET Framework 3,5, consulte O que há de novo no Windows Presentation Foundation Versão 3.5.

Este tópico contém as seguintes seções.

  • Programação com o WPF
  • Marcação e código
  • Aplicativos
  • Controles
  • Entrada e Comando
  • Layout
  • Ligação de Dados
  • Elementos gráficos
  • Animation
  • Media
  • Texto e tipografia
  • Documentos
  • Personalizando aplicativos WPF
  • Práticas recomendadas de WPF
  • Resumo
  • Visão Geral e Exemplos Recomendados
  • Tópicos relacionados

Programação com o WPF

WPF existe sistema autônomo um subconjunto de .NET Framework tipos que estão localizados em grande parte do System.Windows espaço para nome. Se você criou anteriormente aplicativos com .NET Framework usando tecnologias gerenciadas sistema autônomo ASP.NET e Windows Forms, o fundamentais WPF experiência em programação deve estar familiarizada, instanciar classes, conjunto propriedades, métodos de telefonar e identificador de eventos, usando todos sistema autônomo seus Favoritos .NET Framework programação, sistema autônomo linguagem, C# ou Visual Basic.

Para oferecer suporte a alguns do mais poderoso WPF recursos e simplificar a experiência de programação, WPF inclui construções de programação adicionais que aprimoram as propriedades e eventos: Propriedades de dependência and eventos roteados. Para obter mais informações sobre propriedades de dependência, consulte Visão geral sobre propriedades de dependência. Para obter mais informações sobre eventos roteados, consulte Visão geral sobre eventos roteados.

Marcação e código

WPF oferece aprimoramentos de programação adicionais para Windows aplicativo cliente de desenvolvimento. Um aperfeiçoamento óbvio é a capacidade de desenvolver um aplicativo usando os dois marcação e código , uma experiência que os desenvolvedores de ASP.NET devem estar familiarizados com. Geralmente você usa Extensible Application Markup Language (XAML) marcação para implementar a aparência de um aplicativo enquanto estiver usando linguagens gerenciadas de programação (código) para implementar seu comportamento. Essa separação de aparência e comportamento apresenta os seguintes benefícios:

  • Os custos de desenvolvimento e manutenção são reduzidos pois a marcação específica da aparência não é rigidamente aliada ao comportamento específico do código.

  • Desenvolvimento é mais eficiente porque os designers podem implementar a aparência de um aplicativo simultaneamente com os desenvolvedores que estiverem implementando o comportamento do aplicativo.

  • Várias ferramentas de design podem ser usadas para implementar e compartilhar XAML marcação para atingir os requisitos do aplicativo colaboradores de desenvolvimento; Microsoft expressão Blend fornece uma experiência que atenda às designers, enquanto Visual Studio 2005 desenvolvedores de destinos.

  • Globalização e a localização para WPF aplicativos é bastante simplificada (consulte Visão geral de globalização e localização do WPF).

A seguir está uma breve introdução a WPF marcação e código. Para obter mais informações sobre este modelo de programação, consulte XAML Overview e Code-Behind e XAML.

A marcação

XAML é um XML-com base em linguagem de marcação que é usada para implementar a aparência do aplicativo declarativamente. Ele geralmente é usado para criar janelas, caixas de diálogo, páginas e controles de usuário e para preenchê-los com controles, formas e gráficos.

O exemplo a seguir usa XAML para implementar a aparência de uma janela que contém um único botão.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Window with Button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button">Click Me!</Button>

</Window>

Especificamente, este XAML Define uma janela e um botão, usando o Window e Button elementos, respectivamente. Cada elemento é configurado com atributos, sistema autônomo a Window elemento Title atributo para especificar o texto de BAR de título da janela. Em time de execução WPF Converte sistema autônomo elementos e atributos são definidos na marcação para instâncias de WPF classes. Por exemplo, o Windowelemento é convertido em uma instância da Window classe cuja Titlepropriedade é o valor do Titleatributo.

A figura a seguir mostra a interface do usuário (UI) que está definido por XAML no exemplo anterior.

Uma janela contendo um botão

Para obter mais informações, consulte XAML Overview.

Como XAML é baseado no XML, o UI que você escreve com ele é montado em uma hierarquia de elementos aninhados conhecida como um elemento árvore . A elemento árvore fornece uma maneira lógica e intuitiva para criar e gerenciar UIs. Para obter mais informações, consulte Árvores em WPF.

Código

O comportamento principal de um aplicativo é implementar a funcionalidade que responde às interações do usuário, incluindo a manipulação de eventos (por exemplo, clicar em um menu, barra de ferramentas ou botão) e a chamada lógica comercial e acesso lógico a dados na resposta. Em WPF,esse comportamento geralmente é implementado no código que está associado com a marcação. Esse tipo de código é conhecido como código reserva. O exemplo a seguir mostra o código reserva e a marcação atualizada do exemplo anterior.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.AWindow"
    Title="Window with Button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button" Click="button_Click">Click Me!</Button>

</Window>

Namespace SDKSample

    Partial Public Class AWindow
        Inherits System.Windows.Window

        Public Sub New()

            ' InitializeComponent call is required to merge the UI
            ' that is defined in markup with this class, including 
            ' setting properties and registering event handlers
            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

            ' Show message box when button is clicked
            MessageBox.Show("Hello, Windows Presentation Foundation!")

        End Sub

    End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, MessageBox

namespace SDKSample
{
    public partial class AWindow : Window
    {
        public AWindow()
        {
            // InitializeComponent call is required to merge the UI
            // that is defined in markup with this class, including 
            // setting properties and registering event handlers
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Nesse exemplo, o código reserva implementa uma classe que é derivada da Window classe. The x:Class atributo é usado para associar a marcação a classe code-behind. InitializeComponent é chamada a partir do construtor da classe code-behind mesclagem a interface do usuário é definida na marcação com a classe code-behind. (InitializeComponent é gerado para você quando seu aplicativo é criado, que é o motivo pelo qual você não precisa implementá-lo manualmente.) A combinação de x:Class e InitializeComponent garante que sua implementação é inicializada corretamente sempre que ela é criada. A classe do código reserva também implementa um manipulador de eventos para o botão do Click evento. Quando o botão é clicado, o manipulador de eventos mostra um caixa de mensagem chamando o MessageBox.Showmétodo.

A figura a seguir mostra o resultado quando o botão é clicado.

Uma caixa de mensagem

Para obter mais informações, consulte Code-Behind e XAML.

Aplicativos

.NET Framework, System.Windows, e a marcação e o código reserva constituem a base da experiência de desenvolvimento do aplicativo WPF. Além disso, WPF possui recursos abrangentes para criar experiências de usuário com rico conteúdo. Para compactar esse conteúdo e entregá-lo aos usuários como "aplicativos", WPF fornece tipos e serviços que são conhecidos coletivamente como o modelo de aplicativo . O modelo de aplicativo suporta o desenvolvimento tanto de aplicativos autônomos como aplicativos online.

Aplicativos autônomos.

Para aplicativos autônomos, você pode usar Window a classe para criar janelas e caixas de diálogo que são acessadas através de barras de menus e barras ferramenta. A figura a seguir mostra um aplicativo autônomo com uma janela principal e um caixa de diálogo.

Uma janela principal e uma caixa de diálogo

Além disso, você pode usar o seguinte WPF caixas de diálogo: MessageBox, OpenFileDialog, SaveFileDialog, e PrintDialog.

Para obter mais informações, consulte Visão geral do WPF do Windows.

Aplicativos Online

Para aplicativos online, conhecido como aplicativos de navegador XAML (XBAPs),você pode criar páginas (Page) e funções da página (PageFunction<T>) que você pode navegar entre usando hiperlinks (Hyperlink Classes). A figura a seguir mostra uma página em um XBAP hospedada no Internet Explorer 7.

Duas páginas de um aplicativo hospedado

WPF Os aplicativos podem ser hospedados tanto em Microsoft Internet Explorer 6 como em Internet Explorer 7. WPF oferece as duas opções seguintes para alternativas de navegação:

  • FramePara hospedar ilhas de conteúdo navegável tanto em páginas ocomo em janelas.

  • NavigationWindowpara hospedar conteúdo navegável em uma janela inteira.

Para obter mais informações, consulte Visão geral de navegação.

A Classe do aplicativo

Ambos sistema autônomo XBAPs e sistema autônomo aplicativo autônomo geralmente complexa o suficiente para exigir adicionais aplicativo - serviços, incluindo gerenciamento de inicialização e a tempo de vida de escopo, propriedades compartilhadas e recursos compartilhados. O Application classe encapsula esses serviços e muito mais, e ele pode ser implementado usando apenas XAML, conforme mostrado no exemplo a seguir.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    StartupUri="MainWindow.xaml" />

Este marcação é a definição de aplicativo de um aplicativo autônomo e instrui WPF para criar um Application objeto que abre automaticamente MainWindow quando o aplicativo é iniciado.

Um conceito chave para compreender Application é que ele fornece uma plataforma comun de suporte para aplicativos de navegador hospedado e autônomo. Por exemplo, o anterior XAMLpode ser usado por um aplicativo online para navegar automaticamente para uma página quando um XBAP é iniciado, conforme mostrado no exemplo o seguir.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    StartupUri="HomePage.xaml" />

Para obter mais informações, consulte Visão Geral do Gerenciamento de Aplicativo.

Segurança

Como XBAPs são hospedados em um navegador, a segurança é importante. Em particular, uma proteção de segurança de confiança parcial é usada XBAPs para impor restrições que são menores que ou iguais às restrições impostas em HTML com base nos aplicativos. Além disso, cada HTML recurso que é seguro para executar a partir XBAPs na relação de confiança parcial foi testado usando um processo de segurança abrangente, detalhado no Estratégia de segurança do Windows Presentation Foundation - Engenharia de Segurança.

Ainda assim, a maioria dos WPF recursos pode ser executada com segurança a partir de XBAPs,conforme descrito em Windows Presentation Foundation Partial Trust Security.

Controles

As experiências de usuário que são entregues pelo modelo de aplicativo são controles construídos. No WPF,"Controle" é um termo do guarda-sol que se aplica a uma categoria de WPF classes que são hospedadas em uma janela ou uma página, tem uma interface do usuário (UI) e implementa algum comportamento.

Para obter mais informações, consulte Visão geral sobre controles. Para exemplos de introdução, consulte Exemplos de biblioteca de Controlarar

O WPF controle de rotação de chamada

Os controles WPF internos são listados aqui.

Entrada e Comando

Controles frequêntemente detectam e respondem a entrada do usuário. O WPF sistema de entrada usa tanto os eventos diretos como os roteados para dar suporte a entrada de texto, ao foco de gerenciamento e ao posicionamento do mouse. Para obter mais informações, consulte Input Overview.

Aplicativos geralmente possuem requisitos complexos de entrada. WPF Fornece um sistema de comando que separa as ações de entrada do usuário do código que responde a essas ações. Para obter mais informações, consulte Visão geral de Comando.

Layout

Quando você cria um UI, você organiza os controles por local e tamanho para formar um layout. Um requisito chave de qualquer layout é se adaptar a alterações no tamanho da janela e na exibição das configurações. Em vez de forçá-lo a escrever o código para adaptar um layout nessas circunstâncias, WPF fornece um sistema extensível de layout de primeira classe para você.

A base do sistema de layout é o posicionamento relativo, o que aumenta a capacidade de se adaptar às modificações da janela e das condicões de exibição. Além disso, o layout do sistema gerencia a negociação entre os controles para determinar o layout. A negociação é um processo de duas etapas: primeiro, um controle informa ao seu pai que local e dimensionar requer; segundo, o pai informa o controle que espaço pode ter.

O sistema de layout é exposto a controles filho por meio de base WPF classes. Para layouts comuns, sistema autônomo grades, empilhamento e encaixe, WPF inclui vários controles de layout:

  • Canvas: Controles filho fornecem seu próprio layout.

  • DockPanelControles filho: são alinhados com as bordas do painel.

  • ;Grid: Controles filho são posicionados por linhas e colunas.

  • StackPanel: Os controles filho são empilhados vertical ou horizontalmente.

  • VirtualizingStackPanel: Controles filho são virtualizados e organizados em uma única linha que é orientada tanto horizontal como verticalmente.

  • WrapPanel: Controles filho são posicionados em ordem da esquerda para a direita e quebradas para a próxima linha quando há mais controles na linha atual que o espaço permite.

O exemplo a seguir usa uma DockPanel para formatar vários TextBox controles.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.LayoutWindow"
    Title="Layout with the DockPanel" Height="143" Width="319">

  <!--DockPanel to layout four text boxes--> 
  <DockPanel>
    <TextBox DockPanel.Dock="Top">Dock = "Top"</TextBox>
    <TextBox DockPanel.Dock="Bottom">Dock = "Bottom"</TextBox>
    <TextBox DockPanel.Dock="Left">Dock = "Left"</TextBox>
    <TextBox Background="White">This TextBox "fills" the remaining space.</TextBox>
  </DockPanel>

</Window>

O DockPanel permite que o filho TextBox controles para informá-lo como organizá-los. Para fazer isso, o DockPanel implementa uma Dockpropriedade que é exposta aos controles filho para permitir que cada um deles especifique um estilo da plataforma.

ObservaçãoObservação:

Uma propriedade é implementada por um controle pai para uso por controles filho é um WPF construção chamada um propriedade anexada (see Attached Properties Overview).

A figura a seguir mostra o resultado da XAML marcação no exemplo anterior.

Página DockPanel

Para obter mais informações, consulte O sistema de layout. Para uma amostra da introdução, consulte Exemplo de Galeria de layout do WPF.

Ligação de Dados

A maioria dos aplicativos são criados para fornecer aos usuários os meios para exibir e editar dados. Para WPF aplicativos, o trabalho de armazenar e acessar dados já é fornecido por tecnologias, como Microsoft SQL Server e ADO.NET. Depois dos dados serem acessados e carregados em objetos de um aplicativo gerenciado, o trabalho de disco rígido para WPF aplicativos começa. Basicamente, isso envolve duas coisas:

  1. Copiar os dados dos objetos gerenciados para controles, onde os dados podem ser exibidos e editados.

  2. Garantindo que alterações feitas nos dados usando controles são copiadas de volta para os objetos gerenciados.

Para simplificar o desenvolvimento de aplicativos, WPF Fornece um mecanismo de vinculação de dados para executar essas etapas automaticamente. A unidade principal do mecanismo de vinculação de dados é o Binding classe, cuja função é BIND um controle (o destino de vinculação) para um objeto de dados (fonte da ligação). Esse relacionamento é ilustrado pela figura a seguir.

Diagrama de associação de dados básica

O exemplo a seguir demonstra como vincular um TextBox a uma instância de um objeto Person personalizado. A Person implementação é mostrada no código a seguir.

Namespace SDKSample

    Class Person

        Private _name As String = "No Name"

        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(ByVal value As String)
                _name = value
            End Set
        End Property

    End Class

End Namespace

namespace SDKSample
{
    class Person
    {
        string name = "No Name";

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

A marcação a seguir vincula a TextBox a uma instância de objeto Person personalizado.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.DataBindingWindow">


...


<!-- Bind the TextBox to the data source (TextBox.Text to Person.Name) -->
<TextBox Name="personNameTextBox" Text="{Binding Path=Name}" />


...


</Window>

Imports System.Windows ' Window

Namespace SDKSample

    Partial Public Class DataBindingWindow
        Inherits Window

        Public Sub New()
            InitializeComponent()

            ' Create Person data source
            Dim person As Person = New Person()

            ' Make data source available for binding
            Me.DataContext = person

        End Sub

    End Class

End Namespace

using System.Windows; // Window

namespace SDKSample
{
    public partial class DataBindingWindow : Window
    {
        public DataBindingWindow()
        {
            InitializeComponent();

            // Create Person data source
            Person person = new Person();

            // Make data source available for binding
            this.DataContext = person;
        }
    }
}

Nesse exemplo, a Person classe é instanciada no código reserva e é definida como o contexto de dados para o DataBindingWindow. Na marcação, a Text propriedade de TextBox está ligada à Person.Name propriedade (usando a "{Binding ... }"XAMLsintaxe). Este XAML informa WPF para vincular o TextBox controle ao Person objeto que é armazenado na DataContextpropriedade da janela.

O WPFmecanismo associação de dados oferece suporte adicional que inclui a validação, classificação, filtragem e agrupamento. Além disso, associação de dados suporta o uso de modelos de dados para criar UI personalização para os dados ligados quando o UI exibida por padrões WPF controles não é adequado.

Para obter mais informações, consulte Revisão de Associação de Dados. Para uma amostra da introdução, consulte Demonstração de ligação de dados.

Elementos gráficos

WPF Apresenta um conjunto amplo, escalonável e flexível de recursos gráficos que possuem os seguintes benefícios:

  • Elementos gráficos de resolução e dispositivos independentes . A unidade básica de medida no sistema de WPF elementos gráficos é o Dispositivo Independente pixel ,que é 1 / 96th de uma polegada, independentemente de resolução da tela e fornece a base para a renderização de resolução e dispositivo independentes. Cada pixel de dispositivo independente dimensiona automaticamente para corresponder à configuração do sistema que ele processa em pontos-por-polegada (dpi).

  • Precisão aprimorada O WPF sistema de coordenadas é medido com números de ponto flutuante de precisão dupla em vez de precisão única. Valores de opacidade e transformações também são expressos sistema autônomo precisão dupla. WPF também oferece suporte a uma gama de cores ampla (scRGB) e fornece suporte integrado para gerenciar entradas de diferentes espaços de cores.

  • Suporte avançado a elementos gráficos e animação. WPF simplifica a gráficos de programação por meio do gerenciamento de cenas de animação para você; não é necessário se preocupar sobre renderização de cena, loops de renderização e interpolação bilinear. Além disso, WPF fornece suporte sucessos-teste e suporte completo Alpha-compositing.

  • Aceleração de hardware. O WPF sistema de elementos gráficos aproveita Hardware de Gráficos Para Minimizar uso da CPU.

Formas 2D

WPF Fornece uma biblioteca de formas vetoriais comuns desenhadas 2-D , como retângulos e elipses que são mostrados na ilustração a seguir.

Elipses e retângulos

Um recurso interessante de formas é que elas não são apenas para exibição; formas implementam muitos dos recursos que você espera de controles, incluindo Teclado e entrada do mouse. O exemplo a seguir mostra o MouseUp evento de um Ellipse sendo tratado.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.EllipseEventHandlingWindow"
    Title="Click the Ellipse">
    <Ellipse Name="clickableEllipse" Fill="Blue" MouseUp="clickableEllipse_MouseUp" />
</Window>

Imports System.Windows ' Window, MessageBox
Imports System.Windows.Input ' MouseButtonEventArgs

Namespace SDKSample

    Public Class EllipseEventHandlingWindow
        Inherits Window

        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub clickableEllipse_MouseUp(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
            MessageBox.Show("You clicked the ellipse!")
        End Sub

    End Class

End Namespace

using System.Windows; // Window, MessageBox
using System.Windows.Input; // MouseButtonEventHandler

namespace SDKSample
{
    public partial class EllipseEventHandlingWindow : Window
    {
        public EllipseEventHandlingWindow()
        {
            InitializeComponent();
        }

        void clickableEllipse_MouseUp(object sender, MouseButtonEventArgs e)
        {
            // Display a message
            MessageBox.Show("You clicked the ellipse!");
        }
    }
}

A figura a seguir mostra o que é produzido pelo código anterior.

Uma janela com o texto "você clicou na elipse!"

Para obter mais informações, consulte Visão geral de Formas e Desenho básico no WPF. Para uma amostra da introdução, consulte Exemplo de elementos de forma.

Geometrias 2D

As 2-D formas fornecidas pelo WPF abrangem o conjunto padrão de formas básicas No entanto, você talvez precise criar formas personalizadas para facilitar o design de um UI personalizado. Para essa finalidade, WPF fornece geometrias. A figura a seguir demonstra o uso de geometrias para criar uma forma personalizada que pode ser desenhada diretamente, usada como um pincel ou para clipar outras formas e controles.

Path objetos podem ser usados para desenhar formas fechadas ou abertas, várias formas e até mesmo formas curvas.

Geometry objetos podem ser usados para recorte, sucessos-teste e renderização de dados de gráficos 2D.

Vários usos de Path

Para obter mais informações, consulte Visão Geral de Geometria. Para uma amostra da introdução, consulte Exemplo de geometrias.

Efeitos 2D

Um subconjunto de WPF 2-D recursos Inclui efeitos visuais, como gradientes, bitmaps, desenhos, pinturas com vídeos, rotação, escala e inclinação . Essas são todas obtidas com cursores; a figura a seguir mostra alguns exemplos.

Ilustração de diferentes pincéis

Para obter mais informações, consulte WPF Brushes Overview. Para uma amostra da introdução, consulte Exemplo de pincéis.

Renderização 3D

WPF Também inclui 3-D os recursos de renderização que se integram com 2-D elementos gráficos para permitir a criação de mais UIsinteressantes. Por exemplo, a figura a seguir mostra 2-D imagens processadas para 3-D Formas.

Captura de tela de exemplo Visual3D

Para obter mais informações, consulte Visão geral de elementos gráficos 3D. Para uma amostra da introdução, consulte Exemplo de Solids 3D.

Animation

WPF Suporte de animação permite que você faça os controles aumentarem, se misturarem, rodarem e terminarem, para criar páginas de transições interessantes e muito mais. Você pode animar a maioria WPFdas classes, mesmo as classes personalizadas. A figura a seguir mostra uma simples animação em ação.

Imagens de um cubo animado

Para obter mais informações, consulte Revisão de Animação. Para uma amostra da introdução, consulte Galeria de exemplo de animação.

Media

Uma maneira de transmitir conteúdo rico é através do uso de mídia audiovisual. O WPF oferece suporte especial para imagens, vídeo e áudio.

Imagens

Imagens são comuns à maioria dos aplicativos, e WPF fornece várias maneiras para usá-las. A figura a seguir mostra um UI com uma caixa de listagem que contém as imagens em miniatura. Quando uma miniatura é selecionada, a imagem é mostrada em tamanho normal.

Imagens de miniatura de uma imagem de tamanho completo

Para obter mais informações, consulte Visão geral sobre imagens. Para uma amostra da introdução, consulte Demonstração de Visualizador de fotos WPF.

Vídeo e áudio

O controle MediaElement é capaz de executar vídeo e áudio, e ele é flexível o suficiente para ser a base para um reprodutor de mídia personalizado. A seguinte XAML marcação implementa um mídia player.

<MediaElement 
  Name="myMediaElement" 
  Source="media/wpf.wmv" 
  LoadedBehavior="Manual" 
  Width="350" Height="250" />

A janela na figura a seguir mostra o controle MediaElementem ação.

Um controle MediaElement com áudio e vídeo

Para obter mais informações, consulte Visão Geral de elementos gráficos, animação e media do WPF. Para uma amostra da introdução, consulte Mídia Gallery.

Texto e tipografia

Para facilitar a renderização de texto de alta qualidade, WPF oferece os seguintes recursos:

  • Suporte de fonte OpenType.

  • Aprimoramentos ClearType.

  • Alto desempenho que tira vantagem da aceleração do hardware.

  • Integração do texto com mídia, elementos gráficos e animação.

  • Mecanismos de suporte e retorno fonte internacional.

Como uma demonstração de integração de texto com elementos gráficos, a figura a seguir mostra o aplicativo de decoração de texto.

Texto com várias decorações de texto

Para obter mais informações, consulte Tipografia em Windows Presentation Foundation. Para exemplos de introdução, consulte Exemplos de tipografia

Documentos

WPF tem suporte nativo para trabalhar com três tipos de documentos: fluxo de documentos, documentos fixos e XML Paper Specification (XPS) documentos. WPF também fornece serviços para criar, exibir, gerenciar, anotar, pacote e imprimir documentos.

Documentos de fluxo

Documentos de fluxo são projetados para otimizar a exibição e facilitar a leitura ajustando dinamicamente e refluxionando o conteúdo ao tamanho da janela e alterando as configurações de vídeo. A marcação a seguir XAML mostra a definição de um FlowDocument.

<FlowDocument xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation">

  <Paragraph FontSize="18" FontWeight="Bold">Flow Document</Paragraph>

  <Paragraph>
    Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy
    nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi
    enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis
    nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure.
  </Paragraph>


...


</FlowDocument>

O exemplo a seguir demonstra como carregar um documento de fluxo em um FlowDocumentReader para exibir, pesquisar e imprimir.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.FlowDocumentReaderWindow"
    Title="Flow Document Reader">
  <FlowDocumentReader Name="flowDocumentReader" />
</Window>

Imports System.Windows 'Window
Imports System.Windows.Documents 'FlowDocument
Imports System.IO 'FileStream, FileMode
Imports System.Windows.Markup 'XamlReader

Namespace SDKSample

    Public Class FlowDocumentReaderWindow
        Inherits Window

        Public Sub New()
            Me.InitializeComponent()
            Using stream1 As FileStream = New FileStream("AFlowDocument.xaml", _
                FileMode.Open, FileAccess.Read)
                Dim document1 As FlowDocument = _
                    TryCast(XamlReader.Load(stream1), FlowDocument)
                Me.flowDocumentReader.Document = document1
            End Using
        End Sub

    End Class

End Namespace

using System.Windows; // Window
using System.Windows.Documents; // FlowDocument
using System.IO; // FileStream, FileMode
using System.Windows.Markup; // XamlReader

namespace SDKSample
{
    public partial class FlowDocumentReaderWindow : System.Windows.Window
    {
        public FlowDocumentReaderWindow()
        {
            InitializeComponent();

            // Open the file that contains the FlowDocument
            using (FileStream xamlFile = new FileStream("AFlowDocument.xaml", 
                FileMode.Open, FileAccess.Read))
            {
                // Parse the file with the XamlReader.Load method
                FlowDocument content = XamlReader.Load(xamlFile) as FlowDocument;

                // Set the Document property to the parsed FlowDocument object
                this.flowDocumentReader.Document = content;
            }
        }
    }
}

O exemplo a seguir mostra o resultado.

Um FlowDocument em um controle FlowDocumentReader

Para obter mais informações, consulte Flow Document Overview. Para uma amostra da introdução, consulte Exemplo de propriedades de FlowDocument.

Documentos fixos

Documentos fixos são destinados para aplicativos que exigem uma apresentação precisa de "o que você vê é o que você obter" (WYSIWYG) , especialmente em relação à impressão. Usos típicos para documentos fixos incluem editoração eletrônica, edição de texto e layout de formulários, onde a aderência ao design original da página é essencial.

Documentos fixos mantêm uma organização precisa de seus conteúdos de maneira independente do dispositivo. Por exemplo, um documento fixo que é exibido em uma exibição 96 pontos-por-polegada (dpi) aparece o mesmo como quando ele é impresso em uma impressora laser 600 dpi ou um typesetter de foto 4800 PPP. O layout permanece o mesmo em todos os casos, embora a qualidade do documento varie dependendo dos recursos de cada dispositivo.

Para obter mais informações, consulte Documentos em Windows Presentation Foundation.

Documentos XPS

XML Paper Specification (XPS) criar documentos WPFdo fixo documentos. XPS documentos são descritos com um XML-com base no esquema é essencialmente uma representação paginada de papel Eletrônica. XPS é um formato de documentos abertos, plataformas é projetado para facilitar a criação, compartilhamento, impressão e arquivamento de documentos paginados. Recursos importantes da XPS tecnologia incluem o seguinte:

  • Empacotamento de XPS documentos sistema autônomo ZipPackage arquivos que estão de acordo com o em em aberto Packaging Conventions (OPC).

  • Hospedando tanto em aplicativos autônomos como em aplicativos baseados em um navegador.

  • Geração e manipulação manual de XPS documentos de WPF aplicativos.

  • Processamento de alta fidelidade pela definição do público-alvo sendo a saída máxima da qualidade de dispositivo.

  • Windows Vista Imprima o spool.

  • Direcionar circulação de documentos para XPS-impressoras compatíveis.

  • UI Integração com DocumentViewer.

A figura a seguir mostra um XPS documento que é exibido por um DocumentViewer.

Documento XPS com um controle DocumentViewer

DocumentViewer Também permite que os usuários alterem o modo de exibição, pesquisa e XPS imprimam documentos.

Para obter mais informações, consulte Documentos em Windows Presentation Foundation. Para uma amostra da introdução, consulte Criando um exemplo de documento XPS.

Anotações

As anotações são lembretes ou comentários que são adicionados aos documentos para sinalizar informações ou realçar itens de interesse para referência posterior. Embora seja fácil gravar anotações em documentos impressos, a capacidade para "gravar" anotações em documentos eletrônicos está geralmente limitado ou indisponível. Em WPF,no entanto, um sistema de anotações é fornecido para oferecer suporte às notas autoadesivas e notas iluminadas. Além disso, essas anotações podem ser aplicadas aos documentos hospedados no DocumentViewercontrole, conforme mostrado na figura a seguir.

Aplicação de estilo de anotação

Para obter mais informações, consulte Visão geral de Anotações. Para uma amostra da introdução, consulte Exemplo de serialização do documento.

Empacotamento

Os WPF System.IO.Packaging APIs permitem que os seus aplicativos organizem os dados, o conteúdo e os recursos em documentos simples, portáteis, de fácil distribuição e de fácil acesso ZIP. Assinaturas digitais podem ser incluídas para autenticar itens que estão contidos em um pacote e verificar se o item assinado não foi violado ou modificado. Você também pode criptografar os pacotes usando Gerenciamento de direitos para restringir o acesso às informações protegidas.

Para obter mais informações, consulte Documentos em Windows Presentation Foundation. Para exemplos, consulte Exemplos de embalagem.

Imprimindo

O .NET Framework inclui um subsistema de impressão que WPF aumenta com o suporte do controle do sistema de impressão aperfeiçoado. Aperfeiçoamentos de impressão incluem o seguinte:

  • Instalação em tempo real de servidores de impressão remotas e filas.

  • Descoberta dinâmica dos recursos da impressora.

  • Configuração dinâmica das opções de impressora.

  • Reencaminhamento e reprioritização do processo de impressão.

XPS Documentos também possuem um aperfeiçoamento específico de desempenho. O caminho de impressão existente Microsoft Windows Graphics Device Interface (GDI) geralmente requer duas conversões:

  • A primeira conversão de um documento em um formato do processador de impressão, como Metarquivo Avançado (EMF).

  • Uma segunda conversão para a linguagem de descrição da página da impressora, como PostScript ou PCL (linguagem de controle de impressora).

No entanto, os documentos XPS evitam essas conversões porque um componente de formato do arquivo XPS é um idiom do processador de impressão e uma linguagem de descrição de página. Esse suporte ajuda a reduzir tanto o tamanho do arquivo de spool como o carregamento das impressoras da rede.

Para obter mais informações, consulte Visão Geral de Impressão. Para uma amostra da introdução, consulte Impressão um documento XPS.

Personalizando aplicativos WPF

Até este ponto, você viu o núcleo WPF criando blocos para o desenvolvimento de aplicativos. Você usa o modelo de aplicativo para hospedar e entregar conteúdo do aplicativo, que consiste principalmente nos controles do mesmo. Para simplificar a organização dos controles em um UI e para garantir que a organização é mantida na face de alterações para o tamanho da janela e exibir as configurações, você usa o WPF sistema de layout. Como a maioria dos aplicativos permitem aos usuários interagir com dados, você usar vinculação de dados para reduzir o trabalho de integrar o seu UI com os dados. Para aprimorar a aparência visual do seu aplicativo, você use o intervalo abrangente de elementos gráficos, animação e mídia suporte fornecido pelo WPF. Finalmente, se seu aplicativo opera em texto e documentos, você pode usar o texto WPF,tipografia, documento, anotação, compactação e impressão dos recursos.

Frequentemente, entretanto, as noções básicas são insuficientes para criar e gerenciar uma experiência do usuário realmente distinta e visualmente impressionante. Os WPF controles padrão podem não se integrar com a aparência desejada do seu aplicativo. Dados podem não ser exibidos da maneira mais eficaz. Experiência de um usuário do seu aplicativo pode não ser adequada para a aparência e sensação padrão dos Windows Temas. De várias maneiras, uma tecnologia de apresentação precisa de extensibilidade visual assim como qualquer outro tipo de extensibilidade.

Por esse motivo, WPF fornece uma variedade de mecanismos para a criação de experiências únicas de usuário, incluindo um modelo rico de conteúdo para controles, disparadores, controles e modelos de dados, estilos, UI recursos, temas e capas.

Modelo de conteúdo

O objetivo principal da maioria dos WPF controles é exibir o conteúdo. Em WPF,o tipo e número de itens que podem constituir o conteúdo de um controle é como o controle da Conteúdo do modelo conhecido. Alguns controles podem conter um único item e um tipo de conteúdo; por exemplo, o conteúdo de um TextBox é um valor da sequência de caracteres que é atribuído à propriedade Text. O exemplo a seguir define o conteúdo de um TextBox.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.TextBoxContentWindow"
    Title="TextBox Content">


...


<TextBox Text="This is the content of a TextBox." />


...


</Window>

A figura a seguir mostra o resultado.

Um controle TextBox contendo texto

Outros controles, no entanto, podem conter vários itens de diferentes tipos de conteúdo; o conteúdo de um Button,especificado pela propriedade Content,pode conter uma variedade de itens, incluindo controles de layout, texto, imagens e formas. O exemplo a seguir mostra um Button com conteúdo que inclui um DockPanel, um Label, um Border e um MediaElement.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ButtonContentWindow"
    Title="Button Content">


...


<Button Margin="20">
  <!-- Button Content -->
  <DockPanel Width="200" Height="180">
    <Label DockPanel.Dock="Top" HorizontalAlignment="Center">Click Me!</Label>
    <Border Background="Black" BorderBrush="Yellow" BorderThickness="2" 
      CornerRadius="2" Margin="5">
      <MediaElement Source="media/wpf.wmv" Stretch="Fill" />
    </Border>
  </DockPanel>
</Button>


...


</Window>

A figura a seguir mostra o conteúdo desse botão.

Um botão contendo vários tipos de conteúdo

Para obter mais informações sobre os tipos de conteúdo que são suportados pelo vários controles, consulte Modelo de conteúdo WPF.

Disparadores

Embora o objetivo principal de XAML marcação é implementar a aparência de um aplicativo, você também pode usar XAML para implementar alguns aspectos do comportamento do aplicativo. Um exemplo é o uso de disparadores para alterar um aplicativo da aparência com base em interações do usuário. Para obter mais informações sobre disparadores, consulte Styling and Templating.

Modelos de Controle

O padrão UIs para WPF controles normalmente são construídos de outros controles e formas. Por exemplo, um Button é composto de dois ButtonChrome e ContentPresenter controles. O ButtonChrome fornece a aparência padrão botão, enquanto o ContentPresenter Exibe conteúdo do botão, conforme especificado pela propriedade Content.

Às vezes, a aparência de padrão de um controle pode ser incongruente com a aparência geral de um aplicativo. Nesse caso, você pode usar um ControlTemplate para alterar a aparência do controle do UI sem alterar seu conteúdo e comportamento.

Por exemplo, o exemplo a seguir mostra como alterar a aparência de um Button usando um ControlTemplate.

<Window 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.ControlTemplateButtonWindow"
  Title="Button with Control Template" Height="158" Width="290">

  <!-- Button using an ellipse -->
  <Button Content="Click Me!" Click="button_Click">
    <Button.Template>
      <ControlTemplate TargetType="{x:Type Button}">
        <Grid Margin="5">
          <Ellipse Stroke="DarkBlue" StrokeThickness="2">
            <Ellipse.Fill>
              <RadialGradientBrush Center="0.3,0.2" RadiusX="0.5" RadiusY="0.5">
                <GradientStop Color="Azure" Offset="0.1" />
                <GradientStop Color="CornflowerBlue" Offset="1.1" />
              </RadialGradientBrush>
            </Ellipse.Fill>
          </Ellipse>
          <ContentPresenter Name="content" HorizontalAlignment="Center" 
            VerticalAlignment="Center"/>
        </Grid>
      </ControlTemplate>
    </Button.Template>

  </Button>

</Window>

Imports System.Windows ' Window, RoutedEventArgs, MessageBox

Namespace SDKSample

    Public Class ControlTemplateButtonWindow
        Inherits Window

        Public Sub New()

            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            MessageBox.Show("Hello, Windows Presentation Foundation!")
        End Sub

    End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, MessageBox

namespace SDKSample
{
    public partial class ControlTemplateButtonWindow : Window
    {
        public ControlTemplateButtonWindow()
        {
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Nesse exemplo, o botão UI padrão foi substituído por um Ellipse que tem uma borda azul-escuro e é preenchida usando um RadialGradientBrush. O controle ContentPresenter exibe o conteúdo do Button, "Click Me!" Quando o Button é clicado, o evento Click ainda é gerado como parte do comportamento padrão do controle Button. O resultado é mostrado na figura a seguir.

Um botão elíptico e uma segunda janela

Para obter mais informações, consulte ControlTemplate. Para uma amostra da introdução, consulte Estilo com ControlTemplates exemplo.

Modelos de dados

Enquanto um modelo de controle permite que você especifique a aparência de um controle, um modelo de dados permite que você especifique a aparência do conteúdo de um controle. Modelos de dados são frequentemente usados para aprimorar como os dados vinculados são exibidos. A figura a seguir mostra a aparência padrão para um ListBox que é vinculada a uma coleção de objetos Task, onde cada tarefa tem um nome, descrição e prioridade.

Caixa de listagem com a aparência padrão

A aparência padrão é o que você esperaria de um ListBox. No entanto, a aparência padrão de cada tarefa contém somente o nome da tarefa. Para mostrar o nome da tarefa, descrição e a prioridade, a aparência padrão dos itens do controle ListBox de lista acoplada deve ser alterada usando um DataTemplate. O seguinte XAML define um DataTemplate, que é aplicado a cada tarefa usando o atributo ItemTemplate.

<Window
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.DataTemplateWindow"
  Title="With a Data Template">


...


<!-- Data Template (applied to each bound task item in the task collection) -->
<DataTemplate x:Key="myTaskTemplate">
  <Border Name="border" BorderBrush="DarkSlateBlue" BorderThickness="2" 
    CornerRadius="2" Padding="5" Margin="5">
    <Grid>
      <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition/>
        <RowDefinition/>
      </Grid.RowDefinitions>
      <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto" />
        <ColumnDefinition />
      </Grid.ColumnDefinitions>
      <TextBlock Grid.Row="0" Grid.Column="0" Padding="0,0,5,0" Text="Task Name:"/>
      <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Path=TaskName}"/>
      <TextBlock Grid.Row="1" Grid.Column="0" Padding="0,0,5,0" Text="Description:"/>
      <TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding Path=Description}"/>
      <TextBlock Grid.Row="2" Grid.Column="0" Padding="0,0,5,0" Text="Priority:"/>
      <TextBlock Grid.Row="2" Grid.Column="1" Text="{Binding Path=Priority}"/>
    </Grid>
  </Border>  
</DataTemplate>


...


<!-- Data template is specified by the ItemTemplate attribute -->
<ListBox 
  ItemsSource="{Binding}" 
  ItemTemplate="{StaticResource myTaskTemplate}" 
  HorizontalContentAlignment="Stretch" 
  IsSynchronizedWithCurrentItem="True" 
  Margin="5,0,5,5" />


...


</Window>

A figura a seguir mostra o efeito desse código.

Caixa de listagem que usa um modelo de dados

Observe que o ListBox manteve seu comportamento e a aparência geral; somente a aparência do conteúdo que está sendo exibido pela caixa de listagem foi alterado.

Para obter mais informações, consulte Visão geral sobre Templating de dados. Para uma amostra da introdução, consulte Introdução Parao DParados modelParagem exemplo.

Estilos

Estilos de permitem que desenvolvedores e designers padronizar em uma aparência específica para seu produto. WPF Fornece um modelo de estilo de alta segurança, a base da qual é o Style elemento. O exemplo a seguir cria um estilo que define a cor do plano de fundo para cada Button em uma janela para Orange.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.StyleWindow"
    Title="Styles">


...


<!-- Style that will be applied to all buttons -->
<Style TargetType="{x:Type Button}">
  <Setter Property="Background" Value="Orange" />
  <Setter Property="BorderBrush" Value="Crimson" />
  <Setter Property="FontSize" Value="20" />
  <Setter Property="FontWeight" Value="Bold" />
  <Setter Property="Margin" Value="5" />
</Style>


...


<!-- This button will have the style applied to it -->
<Button>Click Me!</Button>

<!-- This labe will not have the style applied to it -->
<Label>Don't Click Me!</Label>

<!-- This button will have the style applied to it -->
<Button>Click Me!</Button>


...


</Window>

Porque esse estilo atinge todos os controles Button, o estilo é aplicado automaticamente para todos os botões na janela, conforme mostrado na figura a seguir.

Dois botões laranjas

Para obter mais informações, consulte Styling and Templating. Para uma amostra da introdução, consulte Introdução Paraos estilos e exemplo de modelParagem.

Recursos

Controles em um aplicativo devem compartilhar a mesma aparência, que pode incluir qualquer coisa entre fontes e cores de plano de fundo para modelos de controles, modelos de dados e estilos. Você pode usar suporte de WPF para recursos de interface do usuário (UI) a fim de encapsular esses recursos em um único local para reutilização.

O exemplo a seguir define uma cor de plano de fundo comum que é compartilhada por um Button e um Label.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ResourcesWindow"
    Title="Resources Window">

  <!-- Define window-scoped background color resource -->
  <Window.Resources>
    <SolidColorBrush x:Key="defaultBackground" Color="Red" />
  </Window.Resources>


...


<!-- Button background is defined by window-scoped resource -->
<Button Background="{StaticResource defaultBackground}">One Button</Button>

<!-- Label background is defined by window-scoped resource -->
<Label Background="{StaticResource defaultBackground}">One Label</Label>


...


</Window>

Este exemplo implementa um recurso de cor de plano de fundo usando o elemento da propriedade Window.Resources. Este recurso está disponível para todos os filhos do Window. Há uma variedade de escopos de recursos, incluindo o seguinte, listados na ordem em que eles são resolvidos:

  1. Um controle individual (usando a propriedade FrameworkElement.Resources herdada).

  2. Um Window ou um Page (também usando a propriedade FrameworkElement.Resources herdada).

  3. Um Application (usando a propriedade Application.Resources).

A variedade de escopos oferece a você flexibilidade com relação à maneira como que você define e compartilha seus recursos.

Como uma alternativa a associar diretamente os seus recursos com um escopo específico, você pode compactar um ou mais recursos usando um ResourceDictionary separado que pode ser referenciado em outras partes de um aplicativo. Por exemplo, o exemplo a seguir define um padrão de cor do plano de fundo em um dicionário de recursos.

<ResourceDictionary 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml">

  <!-- Define background color resource -->
  <SolidColorBrush x:Key="defaultBackground" Color="Red" />

  <!-- Define other resources -->


...


</ResourceDictionary>

O exemplo a seguir faz referência ao dicionário de recursos definido no exemplo anterior para que ele seja compartilhado por um aplicativo.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App">

  <Application.Resources>
    <ResourceDictionary>
      <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="BackgroundColorResources.xaml"/>
      </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
  </Application.Resources>


...


</Application>

Recursos e dicionários de recurso são a base de suporte de WPF para temas e capas.

Para obter mais informações, consulte Visão geral sobre Recursos. Para uma amostra da introdução, consulte Exemplo de recursos de aplicativo.

Temas e Aparências

Da perspectiva do visual, um tema define a aparência global de Windows e os aplicativos executados nele. Windows vem com vários temas. Por exemplo, Microsoft Windows XP vem com temas do Windows XP e Windows Classic, enquanto Windows Vista vem com os temas do Windows Vista e Windows Classic. A aparência que é definida por um tema define a aparência padrão para um aplicativo de WPF. WPF, no entanto, não se integra diretamente Windows temas. Porque a aparência do WPF definidas pelos modelos, WPF inclui um modelo para cada um do conhecido Windows temas, incluindo o Aero)Windows Vista), () ClássicoMicrosoft Windows 2000), () LunaMicrosoft Windows XP) e (RoyaleMicrosoft Windows XP Media Center Edition 2005). Esses temas são empacotados sistema autônomo dicionários de recurso que serão resolvidos se sistema autônomo recursos não forem localizados em um aplicativo. Muitos aplicativos dependem desses temas para definir sua aparência visual; restantes consistente com Windows aparência ajuda sistema autônomo usuários a se familiarizar com mais aplicativos com mais com facilidade.

Por outro lado, a experiência do usuário para alguns aplicativos não necessariamente provêm de temas padrão. Por exemplo, Microsoft Windows Media Player opera em dados de áudio e vídeo e se beneficia de um estilo diferente da experiência do usuário. Tais UIs tendem a fornecer temas personalizados, específicos do aplicativo. Elas são conhecidas como capas, e os aplicativos que são encapados geralmente fornecem ganchos pelo qual os usuários podem personalizar vários aspectos da capa. Microsoft Windows Media Player possui várias capas pré-fabricadas, bem como um host de capas de terceiros.

Temas e capas em WPF são mais facilmente definidas usando dicionários de recursos. O exemplo a seguir mostra definições de capa de exemplo.

<!-- Blue Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Blue" />
  </Style>


...


</ResourceDictionary>

<!-- Blue Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Blue" />
  </Style>


...


</ResourceDictionary>

<!-- Yellow Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Yellow" />
  </Style>


...


</ResourceDictionary>

<!-- Yellow Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Yellow" />
  </Style>


...


</ResourceDictionary>

Para obter mais informações, consulte "Recursos e Temas Compartilhados" no Styling and Templating. Para uma amostra da introdução, consulte Exemplo de aplicativo skinned.

Controles personalizados.

Embora WPF forneça um host de suporte de personalização, você poderá encontrar situações onde os controles existentes de WPF não atendem às necessidades de seu aplicativo ou seus usuários. Isso pode ocorrer quando:

  • O UI que você precisa não pode ser criado ao personalizar a aparência de implementações WPF existentes.

  • O comportamento que você precisa é não suportado (ou não facilmente suportado) por implementações WPF existentes.

Neste ponto, no entanto, você pode tirar proveito de um dos três modelos WPF para criar um novo controle. Cada modelo tem como alvo um cenário específico e requer o controle personalizado para derivar de uma classe base WPF particular. Os três modelos são listados aqui:

  • User Control Model. Um controle personalizado é derivado de UserControl e é composto de um ou mais outros controles.

  • Control Model. Um controle personalizado é derivado de Control e é usado para criar implementações que separam o seu comportamento de sua aparência usando modelos, bem como a maioria dos controles WPF. A derivação de Control permite que você tenha mais liberdade para criar um UI personalizado do que controles de usuário, mas ele pode exigir mais esforço.

  • Framework Element Model. Um controle personalizado é derivado de FrameworkElement quando sua aparência é definida pela lógica de processamento personalizada (não modelos).

O exemplo a seguir mostra um controle personalizado numérico para cima/para baixo que é derivado de UserControl.

<UserControl
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.NumericUpDown">

  <Grid>

    <Grid.RowDefinitions>
      <RowDefinition/>
      <RowDefinition/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
      <ColumnDefinition/>
      <ColumnDefinition/>
    </Grid.ColumnDefinitions>

    <!-- Value text box -->
    <Border BorderThickness="1" BorderBrush="Gray" Margin="2" Grid.RowSpan="2" 
      VerticalAlignment="Center" HorizontalAlignment="Stretch">
      <TextBlock Name="valueText" Width="60" TextAlignment="Right" Padding="5"/>
    </Border>

    <!-- Up/Down buttons -->
    <RepeatButton Name="upButton" Click="upButton_Click" Grid.Column="1" 
      Grid.Row="0">Up</RepeatButton>
    <RepeatButton Name="downButton" Click="downButton_Click" Grid.Column="1" 
      Grid.Row="1">Down</RepeatButton>

  </Grid>

</UserControl>

imports System 'EventArgs
imports System.Windows 'DependencyObject, DependencyPropertyChangedEventArgs, 
                       ' FrameworkPropertyMetadata, PropertyChangedCallback, 
                       ' RoutedPropertyChangedEventArgs
imports System.Windows.Controls 'UserControl

Namespace SDKSample

    ' Interaction logic for NumericUpDown.xaml
    Partial Public Class NumericUpDown
        Inherits System.Windows.Controls.UserControl

        'NumericUpDown user control implementation


...



    End Class

End Namespace

using System; // EventArgs
using System.Windows; // DependencyObject, DependencyPropertyChangedEventArgs,
                      // FrameworkPropertyMetadata, PropertyChangedCallback, 
                      // RoutedPropertyChangedEventArgs
using System.Windows.Controls; // UserControl

namespace SDKSample
{
    public partial class NumericUpDown : UserControl
    {
        // NumericUpDown user control implementation


...


    }
}

O próximo exemplo ilustra o XAML que é necessário para incorporar um controle de usuário em um Window.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.UserControlWindow"
    xmlns:local="clr-namespace:SDKSample" 
    Title="User Control Window">


...


<!-- Numeric Up/Down user control -->
<local:NumericUpDown />


...


</Window>

A figura a seguir mostra o controle NumericUpDown hospedado em um Window.

Um UserControl personalizado

Para obter mais informações sobre controles personalizados, consulte Visão geral sobre criação de controles. Para exemplos de introdução, consulte Exemplos de personalização de Controlarar

Práticas recomendadas de WPF

Como com qualquer plataforma de desenvolvimento, WPF pode ser usado em uma variedade de maneiras para atingir o resultado desejado. Como uma maneira de garantir que seus aplicativos WPFforneçam as experiência do usuário requeridas e atender às demandas do público em geral, existem melhores práticas recomendadas para acessibilidade, globalização e localização, e desempenho. Consulte o seguinte para mais informações:

Resumo

WPF é uma tecnologia de apresentação abrangente para criar uma grande variedade de aplicativos do cliente visualmente atordoantes. Esta introdução forneceu um olhar aos principais recursos do WPF.

A próxima etapa é criar aplicativos WPF!

Ao criá-los, você pode voltar a esta introdução para uma atualização sobre os principais recursos e para localizar referências a cobertura mais detalhada dos recursos abordados nesta introdução.

Visão Geral e Exemplos Recomendados

Os seguintes exemplos e visões gerais são mencionados nessa Introdução.

Visão geral

Visão geral de elementos gráficos 3D

Práticas recomendadas de Acessibilidade

Revisão de Animação

Visão geral de Anotações

Visão Geral do Gerenciamento de Aplicativo

Visão geral de Comando

Visão geral sobre criação de controles

Visão geral sobre controles

Revisão de Associação de Dados

Visão geral sobre Templating de dados

Visão geral sobre propriedades de dependência

Documentos em Windows Presentation Foundation

Árvores em WPF

Flow Document Overview

Visão Geral de Geometria

Getting Started with Ink

Visão geral sobre imagens

Input Overview

O sistema de layout

Visão geral de navegação

Visão Geral de Impressão

Visão geral sobre Recursos

Visão geral sobre eventos roteados

Visão geral de Formas e Desenho básico no WPF

Tipografia em Windows Presentation Foundation

Windows Presentation Foundation Security

Visão geral do WPF do Windows

WPF Brushes Overview

Modelo de conteúdo WPF

Visão geral de globalização e localização do WPF

Visão Geral de elementos gráficos, animação e media do WPF

Exemplos

Exemplo de Solids 3D

Exemplos de acessibilidade

Galeria de exemplo de animação

Exemplo de recursos de aplicativo

Exemplo de pincéis

Exemplos de personalização de Controlarar

Exemplos de biblioteca de Controlarar

Criando um exemplo de documento XPS

Demonstração de ligação de dados

Exemplos de tinta digital

Exemplo de serialização do documento

Exemplo de propriedades de FlowDocument

Exemplo de geometrias

Introdução Parao DParados modelParagem exemplo

Introdução Paraos estilos e exemplo de modelParagem

Mídia Gallery

Exemplos de embalagem

Impressão um documento XPS

Exemplo de elementos de forma

Visão geral de Formas e Desenho básico no WPF

Exemplo de aplicativo skinned

Estilo com ControlTemplates exemplo

Exemplos de tipografia

Exemplo de Galeria de layout do WPF

Demonstração de Visualizador de fotos WPF

Consulte também

Conceitos

Getting Started with Windows Presentation Foundation

Comentários da comunidade do Windows Presentation Foundation