Introduzione a WPF

Windows Presentation Foundation (WPF) è un sistema di presentazione di ultima generazione per la compilazione di applicazioni client Windows in grado di offrire all'utente un'esperienza visiva sorprendente. Con WPF è possibile creare una vasta gamma di applicazioni autonome e ospitate da browser. Una di queste e l'applicazione di esempio Contoso Healthcare illustrata nella figura seguente.

L'elemento principale di WPF è un motore di rendering vettoriale e indipendente dalla risoluzione compilato per sfruttare i vantaggi dei moderni componenti hardware grafici. Oltre a questo elemento principale, WPF offre un set completo di funzionalità di sviluppo applicazioni che includono Extensible Application Markup Language (XAML), controlli, associazione dati, layout, grafica 2-D e 3-D, animazione, stili, modelli, documenti, elementi multimediali, testo e tipografia. WPF è incluso in Microsoft .NET Framework, per consentire la compilazione di applicazioni che incorporano altri elementi della libreria di classi .NET Framework.

Questi cenni preliminari, destinati ai principianti, offrono una panoramica delle funzionalità e dei concetti chiave di WPF. Possono anche essere utili agli sviluppatori di WPF esperti che desiderano avere una visione d'insieme di WPF.

Nota
Per informazioni sulle funzionalità WPF nuove e aggiornate disponibili in .NET Framework 4, vedere Novità di WPF versione 4.

Nel presente argomento sono contenute le seguenti sezioni.

• Programmazione con WPF
• Markup e code-behind
• Applicazioni
• Controlli
• Input e comandi
• Layout
• Associazione dati
• Grafica
• Animazione
• Supporti multimediali
• Testo e tipografia
• Documenti
• Personalizzazione di applicazioni WPF
• Procedure consigliate di WPF
• Riepilogo
• Cenni preliminari ed esempi consigliati
• Argomenti correlati

Programmazione con WPF

WPF è un sottoinsieme di tipi di .NET Framework in gran parte contenuti nello spazio dei nomi System.Windows. Se in precedenza si sono già compilate applicazioni con .NET Framework utilizzando tecnologie gestite come ASP.NET e Windows Forms, si è già acquisita familiarità con le operazioni fondamentali di programmazione WPF. Sarà quindi possibile creare istanze di classi, impostare proprietà, chiamare metodi e gestire eventi, tutto con il linguaggio di programmazione .NET Framework preferito, ad esempio C# o Visual Basic.

Per supportare alcune delle funzionalità di WPF più efficaci e per semplificare le operazioni di programmazione, in WPF sono inclusi costrutti di programmazione aggiuntivi che migliorano proprietà ed eventi: proprietà di dipendenza ed eventi indirizzati. Per ulteriori informazioni sulle proprietà di dipendenza, vedere Cenni preliminari sulle proprietà di dipendenza. Per ulteriori informazioni sugli eventi indirizzati, vedere Cenni preliminari sugli eventi indirizzati.

Markup e code-behind

WPF offre miglioramenti di programmazione aggiuntivi per lo sviluppo di applicazioni client Windows. Uno dei miglioramenti più evidenti consiste nella possibilità di sviluppare un'applicazione utilizzando sia markup, sia code-behind, un'esperienza nota agli sviluppatori ASP.NET. In genere, si utilizza il markup Extensible Application Markup Language (XAML) per implementare l'aspetto di un'applicazione, mentre si utilizzano i linguaggi di programmazione gestiti (code-behind) per implementarne il comportamento. La separazione di aspetto e comportamento offre alcuni vantaggi:

• I costi di sviluppo e gestione risultano ridotti poiché il markup specifico per l'aspetto non è associato strettamente a codice specifico per il comportamento.

• Lo sviluppo è più efficiente perché i progettisti possono implementare l'aspetto di un'applicazione mentre, contemporaneamente, gli sviluppatori ne implementano il comportamento.

• È possibile utilizzare vari strumenti di progettazione per implementare e condividere il markup XAML, per rispondere ai requisiti degli sviluppatori delle applicazioni. Microsoft Expression Blend offre funzionalità adatte ai progettisti, mentre Visual Studio 2005 è indirizzato agli sviluppatori.

• Le operazioni di globalizzazione e localizzazione delle applicazioni WPF sono state notevolmente semplificate (vedere Cenni preliminari sulla globalizzazione e localizzazione WPF).

Di seguito viene fornita una breve introduzione al markup e al code-behind di WPF. Per ulteriori informazioni su questo modello di programmazione, vedere Cenni preliminari su XAML (WPF) e Code-behind e XAML in WPF.

Markup

XAML è un linguaggio di markup basato su XML utilizzato per implementare l'aspetto di un'applicazione in modo dichiarativo. Viene in genere utilizzato per creare finestre, finestre di dialogo, pagine e controlli utente e per riempire questi elementi con controlli, forme e grafica.

Nell'esempio riportato di seguito viene utilizzato XAML per implementare l'aspetto di una finestra che contiene un solo pulsante.

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

In particolare, XAML definisce qui una finestra e un pulsante utilizzando gli elementi Window e Button, rispettivamente. Ogni elemento viene configurato con attributi, ad esempio l'attributo Window dell'elemento Title per specificare il testo della barra del titolo della finestra. In fase di esecuzione, WPF converte gli elementi e gli attributi definiti nel markup in istanze di classi WPF. Ad esempio, l'elemento Window viene convertito in un'istanza della classe Window la cui proprietà Title è il valore dell'attributo Title.

Nella figura seguente viene illustrata l'user interface (UI) definita da XAML nell'esempio precedente.

Per ulteriori informazioni, vedere Cenni preliminari su XAML (WPF).

Poiché XAML è basato su XML, l'UI composta con tale linguaggio viene assemblata in una gerarchia di elementi annidati nota come struttura ad albero di elementi. Questa struttura ad albero costituisce un modo logico e intuitivo per creare e gestire le UIs. Per ulteriori informazioni, vedere Strutture ad albero in WPF.

Code-behind

Il comportamento principale di un'applicazione consiste nell'implementare la funzionalità che risponde alle interazioni dell'utente, inclusa la gestione di eventi (ad esempio la scelta di un menu, una barra degli strumenti o un pulsante) e la chiamata alla logica di business e alla logica di accesso ai dati in risposta a tali eventi. In WPF, questo comportamento viene in genere implementato in codice associato a markup. Questo tipo di codice è noto come code-behind. Nell'esempio riportato di seguito vengono riportati code-behind e markup aggiornato dell'esempio precedente.

<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!");
        }
    }
}

In questo esempio il code-behind implementa una classe che deriva dalla classe Window. L'attributo x:Class viene utilizzato per associare il markup alla classe code-behind. InitializeComponent viene chiamato dal costruttore della classe code-behind per unire l'interfaccia utente definita nel markup con la classe code-behind. InitializeComponent viene generato durante la compilazione dell'applicazione, per questo motivo non occorre implementarlo manualmente. La combinazione di x:Class e InitializeComponent assicura che l'implementazione venga inizializzata correttamente quando viene creata. La classe code-behind implementa anche un gestore dell'evento Click del pulsante. Quando si fa clic sul pulsante, il gestore dell'evento mostra una finestra di messaggio chiamando il metodo MessageBox.Show.

Nella figura riportata di seguito viene illustrato il risultato della scelta del pulsante.

Per ulteriori informazioni, vedere Code-behind e XAML in WPF.

Applicazioni

.NET Framework, System.Windows, markup e code-behind costituiscono la base per lo sviluppo di applicazioni WPF. Inoltre, WPF include funzionalità complete per la creazione di applicazioni con contenuto dettagliato. Per fornire questo contenuto agli utenti sotto forma di applicazioni, in WPF sono disponibili tipi e servizi noti con il nome di modello di applicazione. Il modello di applicazione supporta lo sviluppo di applicazioni autonome e ospitate da browser.

Applicazioni autonome

Per le applicazioni autonome, è possibile utilizzare la classe Window per creare finestre e finestre di dialogo a cui si accede da barre dei menu e barre degli strumenti. Nella figura riportata di seguito viene illustrata un'applicazione autonoma con una finestra principale e una finestra di dialogo.

Inoltre, è possibile utilizzare le finestre di dialogo di WPF seguenti: MessageBox, OpenFileDialog, SaveFileDialog e PrintDialog.

Per ulteriori informazioni, vedere Cenni preliminari sulle finestre WPF.

Applicazioni ospitate da browser

Per le applicazioni ospitate da browser, note come XAML browser applications (XBAPs), è possibile creare pagine (Page) e funzioni di pagina (PageFunction<T>) in cui è possibile spostarsi utilizzando i collegamenti ipertestuali (classiHyperlink). Nella figura riportata di seguito viene illustrata una pagina in un'XBAP ospitata in Internet Explorer 7.

Le applicazioni WPF possono essere ospitate in Microsoft Internet Explorer 6 e Internet Explorer 7. In WPF sono disponibili le due opzioni seguenti per host di esplorazione alternativi:

• Frame per ospitare contenuto esplorabile in pagine o finestre.

• NavigationWindow per ospitare contenuto esplorabile in un'intera finestra.

Per ulteriori informazioni, vedere Cenni preliminari sulla navigazione.

Classe Application

Sia le applicazioni XBAPs sia le applicazioni autonome sono spesso sufficientemente complesse da richiedere servizi aggiuntivi con ambito di applicazione, inclusa la gestione di avvio e durata, proprietà e risorse condivise. La classe Application incapsula questi ed altri servizi e può essere implementata utilizzando semplicemente il linguaggio XAML, come illustrato nell'esempio seguente.

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

Il markup è la definizione di applicazione per un'applicazione autonoma e fornisce a WPF istruzioni per creare un oggetto Application che apre automaticamente la proprietà MainWindow all'avvio dell'applicazione.

Uno dei concetti chiave relativi all'oggetto Application è il fatto di costituire una piattaforma comune di supporto per le applicazioni autonome e per quelle ospitate da browser. Il codice XAML precedente, ad esempio, può essere utilizzato da un'applicazione ospitata da browser per esplorare automaticamente una pagina all'avvio di un'XBAP, come illustrato nell'esempio seguente.

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

Per ulteriori informazioni, vedere Cenni preliminari sulla gestione di applicazioni.

Sicurezza

Poiché le XBAPs sono ospitate da browser, la sicurezza è fondamentale. In particolare, un sandbox di sicurezza ad attendibilità parziale viene utilizzato dalle XBAPs per applicare restrizioni uguali o inferiori a quelle imposte alle applicazioni basate su HTML. Inoltre, ogni funzionalità HTML la cui esecuzione dalle XBAPs è sicura in attendibilità parziale è stata testata tramite un processo di sicurezza completo, descritto dettagliatamente in Strategia di sicurezza WPF - Progettazione di sicurezza.

La maggior parte delle funzionalità di WPF può essere eseguita in modo sicuro dalle XBAPs, come descritto in Sicurezza con attendibilità parziale in WPF.

Controlli

Le esperienze utente fornite dal modello di applicazione sono controlli costruiti. In WPF, con il termine controllo si intende una categoria di classi WPF ospitate in una finestra o in una pagina, con un'user interface (UI) e che implementano un comportamento.

Per ulteriori informazioni, vedere Controlli.

Controlli WPF per funzione

I controlli di WPF incorporati sono elencati di seguito.

• Pulsanti: Button e RepeatButton.

• Visualizzazione di dati: DataGrid, ListView e TreeView.

• Visualizzazione e selezione di date: Calendar e DatePicker.

• Finestre di dialogo: OpenFileDialog, PrintDialog e SaveFileDialog.

• Input penna: InkCanvas e InkPresenter.

• Documenti: DocumentViewer, FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollViewer e StickyNoteControl.

• Input: TextBox, RichTextBox e PasswordBox.

• Layout: Border, BulletDecorator, Canvas, DockPanel, Expander, Grid, GridView, GridSplitter, GroupBox, Panel, ResizeGrip, Separator, ScrollBar, ScrollViewer, StackPanel, Thumb, Viewbox, VirtualizingStackPanel, Window e WrapPanel.

• Supporti: Image, MediaElement e SoundPlayerAction.

• Menu: ContextMenu, Menu e ToolBar.

• Esplorazione: Frame, Hyperlink, Page, NavigationWindow e TabControl.

• Selezione: CheckBox, ComboBox, ListBox, RadioButton e Slider.

• Informazioni utente: AccessText, Label, Popup, ProgressBar, StatusBar, TextBlock e ToolTip.

Input e comandi

I controlli nella maggior parte dei casi rilevano e rispondono all'input dell'utente. Il sistema di input di WPF utilizza eventi sia diretti sia indirizzati per supportare l'input di testo, la gestione dello stato attivo e il posizionamento del mouse. Per ulteriori informazioni, vedere Cenni preliminari sull’input.

I requisiti di input delle applicazioni sono spesso complessi. In WPF è disponibile un sistema di comandi che separa le azioni di input utente dal codice che risponde a tali azioni. Per ulteriori informazioni, vedere Cenni preliminari sull'esecuzione di comandi.

Layout

Quando si crea un'UI, si dispongono i controlli per percorso e dimensione per creare un layout. Il requisito principale di qualsiasi layout è quello di adattarsi alle modifiche nella dimensione delle finestre e nelle impostazioni di visualizzazione. Anziché richiedere la scrittura di codice per adattare un layout in tali circostanze, WPF offre un efficiente sistema di layout estensibile.

Tale sistema si fonda sul posizionamento relativo che aumenta la capacità di adattamento a condizioni di finestre e visualizzazione mutevoli. Con il sistema di layout, inoltre, viene gestita la negoziazione tra i controlli per definire il layout. La negoziazione è un processo a due passaggi, in cui innanzitutto un controllo indica il percorso e le dimensioni richieste al relativo padre, quindi il padre indica lo spazio disponibile al controllo.

Il sistema di layout viene esposto ai controlli figlio tramite le classi base di WPF. Per layout comuni, quali griglie, sovrapposizioni e ancoraggio, in WPF sono inclusi vari controlli di layout:

• Canvas: i controlli figlio forniscono il proprio layout.

• DockPanel: i controlli figlio sono allineati ai bordi del riquadro.

• Grid: i controlli figlio sono posizionati tramite righe e colonne.

• StackPanel: i controlli figlio sono sovrapposti in verticale o in orizzontale.

• VirtualizingStackPanel: i controlli figlio sono virtualizzate e disposti su una sola riga orientata in senso orizzontale o verticale.

• WrapPanel: i controlli figlio vengono posizionati in ordine da sinistra a destra e mandati a capo quando sulla riga corrente sono presenti troppi controlli rispetto allo spazio disponibile.

Nell'esempio riportato di seguito viene utilizzato un oggetto DockPanel per applicare il layout a più controlli TextBox.

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

L'oggetto DockPanel consente ai controlli TextBox figlio di indicare la modalità di disposizione. A tale scopo, l'oggetto DockPanel implementa una proprietà Dock esposta ai controlli figlio per consentire a ognuno di essi di specificare uno stile di ancoraggio.

Nota
Una proprietà implementata da un controllo padre per essere utilizzata dai controlli figlio è un costrutto di WPF denominato proprietà associata (vedere Cenni preliminari sulle proprietà associate).

Nella figura riportata di seguito viene illustrato il risultato del markup XAML dell'esempio precedente.

Per ulteriori informazioni, vedere Sistema di layout. Per un esempio introduttivo, vedere Esempio di raccolte di layout WPF.

Associazione dati

La maggior parte delle applicazioni vengono create per consentire agli utenti di visualizzare e modificare i dati. Per le applicazioni WPF, le operazioni di archiviazione e accesso ai dati sono fornite da tecnologie quali Microsoft SQL Server e ADO.NET. Dopo l'accesso e il caricamento dei dati negli oggetti gestiti di un'applicazione, ha inizio la fase più complessa delle applicazioni WPF. Questa fase comporta essenzialmente due punti:

1. Copia dei dati dagli oggetti gestiti nei controlli, per consentirne la visualizzazione e la modifica.

2. Verifica che le modifiche apportate ai dati utilizzando i controlli vengano copiate negli oggetti gestiti.

Per semplificare lo sviluppo delle applicazioni, in WPF è disponibile un motore di associazione dati per eseguire automaticamente queste operazioni. L'unità principale di questo motore è la classe Binding, il cui scopo è associare un controllo (destinazione) a un oggetto dati (origine). Questa relazione viene illustrata nella figura seguente.

Nell'esempio riportato di seguito viene illustrato come associare un oggetto TextBox a un'istanza di un oggetto Person personalizzato. Nell'esempio di codice riportato di seguito viene visualizzata l'implementazione di Person.

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

Nel markup riportato di seguito l'oggetto TextBox viene associato a un'istanza di un oggetto Person personalizzato.

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

In questo esempio, viene creata un'istanza della classe Person in code-behind, che viene impostata come contesto di dati per l'oggetto DataBindingWindow. In markup, la proprietà Text dell'oggetto TextBox è associata alla proprietà Person.Name (tramite la sintassi "{Binding ... }" in XAML). Con questo codice XAML viene comunicato a WPF di associare il controllo TextBox all'oggetto Person archiviato nella proprietà DataContext della finestra.

Il motore di associazione dati di WPF fornisce supporto aggiuntivo che include convalida, ordinamento, applicazione di filtri e raggruppamento. Inoltre, l'associazione dati supporta l'utilizzo di modelli di dati per creare l'UI personalizzata per i dati associati quando l'UI visualizzata dai controlli WPF standard non è adatta.

Per ulteriori informazioni, vedere Cenni preliminari sull'associazione dati. Per un esempio introduttivo, vedere Demo Data Binding.

Grafica

In WPF è disponibile un insieme completo, scalabile e flessibile di funzionalità grafiche che offrono i vantaggi seguenti:

• Grafica indipendente dalla risoluzione e dal dispositivo. L'unità di misura di base nel sistema grafico di WPF è il Device Independent Pixel, pari a 1/96 di pollice, indipendentemente dall'effettiva risoluzione dello schermo, che costituisce la base per il rendering indipendente dalla risoluzione e dal dispositivo. Ogni Device Independent Pixel viene ridimensionato automaticamente in modo da corrispondere all'impostazione in dpi del sistema in cui viene eseguito il rendering.

• Maggiore precisione. Il sistema di coordinate di WPF viene misurato con i numeri a virgola mobile a precisione doppia anziché a precisione singola. Anche i valori di opacità e delle trasformazioni vengono espressi come precisione doppia. In WPF è inoltre supportata un'ampia gamma di colori (scRGB) ed è disponibile il supporto integrato per la gestione degli input da spazi colore diversi.

• Grafica e supporto dell'animazione avanzati. WPF semplifica la programmazione grafica. Grazie alla gestione automatica delle scene di animazione, infatti, non occorre preoccuparsi dell'elaborazione delle scene, dei cicli di rendering e dell'interpolazione bilineare. Inoltre, in WPF viene fornito il supporto per hit test e composizione alfa completa.

• Accelerazione hardware. Il sistema grafico di WPF sfrutta i vantaggi dei componenti hardware grafici per ridurre al minimo l'utilizzo della CPU.

Forme 2D

WPF fornisce una libreria di forme 2-D comuni disegnate da vettore, ad esempio i rettangoli e le ellissi visualizzati nella figura seguente.

La caratteristica interessante delle forme è che non vengono utilizzate solo per la visualizzazione. Le forme, infatti, implementano molte delle funzionalità fornite dai controlli, incluso l'input della tastiera e del mouse. Nell'esempio riportato di seguito viene illustrato l'evento MouseUp di un oggetto Ellipse gestito.

<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!");
        }
    }
}

Nella figura riportata di seguito viene illustrato il risultato del codice precedente.

Per ulteriori informazioni, vedere Cenni preliminari sugli oggetti Shape e sulle funzionalità di disegno di base di WPF. Per un esempio introduttivo, vedere Esempio di elementi forma.

Geometrie 2D

Le forme 2-D fornite da WPF coprono il set standard di forme di base. Può tuttavia essere necessario creare forme personalizzate per semplificare la progettazione di un'UI personalizzato. A tale scopo, in WPF vengono fornite le geometrie. Nella figura riportata di seguito viene illustrato l'utilizzo delle geometrie per creare una forma personalizzata che può essere disegnata direttamente, utilizzata come pennello o per tagliare altre forme e controlli.

È possibile utilizzare gli oggetti Path per disegnare forme chiuse o aperte, più forme e anche forme curve.

È possibile utilizzare gli oggetti Geometry per ritagliare ed eseguire hit test e rendering di dati grafici 2D.

Per ulteriori informazioni, vedere Cenni preliminari sulle classi Geometry. Per un esempio introduttivo, vedere Esempio di geometrie.

Effetti 2D

Un sottoinsieme di funzionalità 2-D di WPF include effetti visivi, quali sfumature, bitmap, disegni, disegni con video, rotazione, ridimensionamento e inclinazione. Questi effetti vengono realizzati con pennelli. Nella figura riportata di seguito vengono illustrati alcuni esempi.

Per ulteriori informazioni, vedere Cenni preliminari sui pennelli di WPF. Per un esempio introduttivo, vedere Esempio Brush.

Rendering 3D

In WPF sono inoltre incluse funzionalità di rendering 3-D integrate con la grafica 2-D per consentire la creazione di UIs più accattivanti ed efficaci. Nella figura riportata di seguito, ad esempio, sono illustrate immagini 2-D di cui è stato eseguito il rendering in forme 3-D.

Per ulteriori informazioni, vedere Cenni preliminari sulla grafica tridimensionale. Per un esempio introduttivo, vedere Esempio di solidi 3D.

Animazione

Il supporto di animazione di WPF consente di fare crescere, muovere, ruotare e dissolvere i controlli per creare transizioni di pagina interessanti e altro ancora. È possibile animare la maggior parte delle classi di WPF, anche quelle personalizzate. Nella figura riportata di seguito viene illustrata una semplice animazione in azione.

Per ulteriori informazioni, vedere Cenni preliminari sull'animazione. Per un esempio introduttivo, vedere Raccolta di esempi di animazioni.

Supporti multimediali

L'utilizzo di supporti audiovisivi è un modo per inserire contenuto dettagliato. In WPF è disponibile un supporto speciale per immagini, video e audio.

Immagini

Le immagini sono comuni alla maggior parte delle applicazioni e WPF offre varie modalità di utilizzo. Nella figura riportata di seguito viene illustrata un'UI con una casella di riepilogo che contiene immagini di anteprima. Quando si seleziona un'anteprima, l'immagine viene visualizzata ingrandita.

Per ulteriori informazioni, vedere Cenni preliminari sulla creazione dell'immagine.

Video e audio

Il controllo MediaElement consente di riprodurre video e audio e, grazie alle caratteristiche di flessibilità, può essere utilizzato come base per un lettore multimediale personalizzato. Nel markup XAML riportato di seguito viene implementato un lettore multimediale.

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

La finestra riportata nella figura seguente illustra il funzionamento del controllo MediaElement.

Per ulteriori informazioni, vedere Grafica e funzionalità multimediali.

Testo e tipografia

Per semplificare il rendering di testo ad alta qualità, in WPF sono disponibili le funzionalità seguenti:

• Supporto dei tipi di carattere OpenType.

• Miglioramenti di ClearType.

• Prestazioni elevate in grado di sfruttare i vantaggi dell'accelerazione hardware.

• Integrazione del testo con supporti multimediali, grafica e animazione.

• Supporto dei tipi di carattere internazionali e meccanismi di fallback.

Nella figura riportata di seguito viene illustrata l'applicazione di decorazioni di testo per dimostrare l'integrazione di testo e grafica.

Per ulteriori informazioni, vedere Funzionalità tipografiche di WPF.

Documenti

In WPF è disponibile il supporto nativo per l'utilizzo di tre tipi di documenti: documenti dinamici, documenti statici e documenti XML Paper Specification (XPS). In WPF sono inoltre disponibili i servizi per creare, visualizzare, gestire, annotare, comprimere e stampare documenti.

Documenti dinamici

I documenti dinamici sono progettati per ottimizzare la visualizzazione e la leggibilità regolando e facendo scorrere il contenuto in modo dinamico quando cambiano le impostazioni di dimensione della finestra e di visualizzazione. Nel markup XAML riportato di seguito viene illustrata la definizione di un oggetto 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>

Nell'esempio riportato di seguito viene illustrato come caricare un documento dinamico in un oggetto FlowDocumentReader per la visualizzazione, la ricerca e la stampa.

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

Nell'esempio riportato di seguito viene illustrato il risultato.

Per ulteriori informazioni, vedere Cenni preliminari sui documenti dinamici.

Documenti statici

I documenti statici sono destinati ad applicazioni che richiedono una presentazione precisa di tipo WYSIWYG, in particolare in relazione alla stampa. Tra gli utilizzi tipici dei documenti statici sono incluse le attività di desktop publishing, elaborazione di testi e layout di moduli, nelle quali la corrispondenza alla progettazione della pagina originale è essenziale.

I documenti statici mantengono la disposizione precisa del contenuto in modo indipendente dal dispositivo. Un documento statico visualizzato con un'impostazione di 96 dpi, ad esempio, non viene modificato indipendentemente dal fatto che venga stampato con una stampante laser a 600 dpi o con un compositore di foto a 4800 dpi. Il layout rimane invariato in ogni caso, benché la qualità del documento dipenda dalle capacità del dispositivo utilizzato.

Per ulteriori informazioni, vedere Documenti in WPF.

Documenti XPS

I documenti XML Paper Specification (XPS) sono basati sui documenti statici di WPF. I documenti XPS vengono descritti con uno schema basato su XML, essenzialmente una rappresentazione impaginata in formato elettronico. XPS è un formato di documento aperto e multipiattaforma progettato per semplificare la creazione, la condivisione, la stampa e l'archiviazione di documenti impaginati. Tra le funzionalità importanti della tecnologia XPS sono incluse:

• Assemblaggio di documenti XPS come file ZipPackage conformi alla specifica Open Packaging Conventions (OPC) (la pagina potrebbe essere in inglese).

• Hosting in applicazioni autonome e basate su browser.

• Generazione manuale e modifica di documenti XPS da applicazioni WPF.

• Rendering ad alta fedeltà con la qualità massima del dispositivo di output.

• Spooling di stampa di Windows Vista.

• Indirizzamento diretto di documenti a stampanti compatibili con XPS.

• Integrazione dell'UI con DocumentViewer.

Nella figura riportata di seguito viene illustrato un documento XPS visualizzato da un oggetto DocumentViewer.

DocumentViewer consente inoltre agli utenti di modificare la visualizzazione, di cercare e di stampare documenti XPS.

Per ulteriori informazioni, vedere Documenti in WPF.

Annotazioni

Le annotazioni sono note o commenti aggiunti ai documenti per contrassegnare informazioni o evidenziare elementi di interesse cui fare riferimento in un secondo momento. Benché sia semplice scrivere note sui documenti stampati, non sempre è possibile inserire note nei documenti elettronici. In WPF, tuttavia, è disponibile un sistema di annotazioni che supporta l'aggiunta di note e le evidenziazioni. Inoltre, è possibile applicare le annotazioni a documenti ospitati nel controllo DocumentViewer, come illustrato nella figura seguente.

Per ulteriori informazioni, vedere Cenni preliminari sulle annotazioni.

Creazione del package

Le APIs System.IO.Packaging di WPF consentono alle applicazioni di organizzare dati, contenuto e risorse in singoli documenti con estensione zip portabili, di facile accesso e distribuzione. È possibile includere firme digitali per autenticare gli elementi contenuti in un pacchetto e verificare che l'elemento firmato non sia stato alterato. È inoltre possibile crittografare i package utilizzando Rights Management per limitare l'accesso alle informazioni protette.

Per ulteriori informazioni, vedere Documenti in WPF.

Stampa

.NET Framework include un sottosistema di stampa ulteriormente potenziato in WPF dal supporto per il controllo del sistema di stampa avanzato. Di seguito sono elencati alcuni miglioramenti delle funzionalità di stampa:

• Installazione in tempo reale di code e server di stampa remoti.

• Individuazione dinamica delle funzionalità della stampante.

• Impostazione dinamica delle opzioni della stampante.

• Reindirizzamento e reimpostazione della priorità dei processi di stampa.

I documenti XPS presentano inoltre un miglioramento fondamentale delle prestazioni. Il percorso di stampa Microsoft Windows Graphics Device Interface (GDI) esistente richiede in genere due conversioni:

• Una prima conversione del documento in un formato del processore di stampa, ad esempio Enhanced Metafile (EMF).

• Una seconda conversione nel linguaggio di descrizione della pagina della stampante, ad esempio PCL (Printer Control Language) o PostScript.

I documenti XPS, tuttavia, consentono di evitare queste conversioni in quanto un componente del formato di file XPS è un linguaggio del processore di stampa e un linguaggio di descrizione della pagina. Grazie a questo supporto è possibile ridurre sia la dimensione del file di spooling sia il carico delle stampanti in rete.

Per ulteriori informazioni, vedere Cenni preliminari sulla stampa.

Personalizzazione di applicazioni WPF

Finora, sono stati presentati i blocchi di compilazione principali di WPF per lo sviluppo di applicazioni. Il modello di applicazione viene utilizzato per ospitare e fornire contenuto di applicazione, costituito principalmente da controlli. Per semplificare la disposizione dei controlli in un'UI e assicurare che tale disposizione venga mantenuta anche a seguito di modifiche della dimensione della finestra e delle impostazioni di visualizzazione, viene utilizzato il sistema di layout di WPF. Poiché la maggior parte delle applicazioni consente agli utenti di interagire con i dati, si utilizza l'associazione dati per ridurre le operazioni di integrazione dell'UI con i dati. Per migliorare l'aspetto visivo dell'applicazione, si utilizza una gamma completa di grafica, animazioni e supporti multimediali disponibili in WPF. Infine, se l'applicazione utilizza testo e documenti, è possibile utilizzare le funzionalità di testo, tipografia, documento, annotazione, compressione e stampa di WPF.

Spesso, tuttavia, non è sufficiente utilizzare le funzionalità di base per creare e gestire applicazioni davvero uniche e visivamente sorprendenti per gli utenti. È possibile che i controlli standard di WPF non si integrino con l'aspetto desiderato dell'applicazione. È possibile che i dati non vengano visualizzati nel modo più efficace. L'esperienza utente complessiva di un'applicazione può non essere adeguata all'aspetto dei temi di Windows. Per una tecnologia di presentazione è necessaria l'estensibilità visiva, tanto quanto altri tipo di estensibilità.

Per questo motivo, in WPF è disponibile una varietà di meccanismi per la creazione di esperienze utente univoche, incluso un modello di contenuto dettagliato per controlli, trigger, modelli di controllo e di dati, stili, risorse dell'UI, temi e interfacce.

Modello di contenuto

Lo scopo principale di gran parte dei controlli di WPF è quello di visualizzare il contenuto. In WPF, il tipo e il numero di elementi che possono costituire il contenuto di un controllo è indicato come modello di contenuto del controllo. Alcuni controlli possono contenere un solo elemento e tipo di contenuto. Ad esempio, il contenuto di un oggetto TextBox è un valore di stringa assegnato alla proprietà Text. Nell'esempio riportato di seguito viene impostato il contenuto di un oggetto 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>

Nella figura riportata di seguito viene illustrato il risultato.

Gli altri controlli, tuttavia, possono contenere più elementi di tipi diversi di contenuto. Il contenuto di un oggetto Button, specificato dalla proprietà Content può contenere vari elementi, inclusi controlli di layout, testo, immagini e forme. Nell'esempio riportato di seguito viene illustrato un oggetto Button con contenuto che include un oggetto DockPanel, un oggetto Label, un oggetto Border e un oggetto 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>

Nella figura riportata di seguito viene illustrato il contenuto di questo pulsante.

Per ulteriori informazioni sui tipi di contenuto supportati da vari controlli, vedere Modello di contenuto WPF.

Trigger

Benché lo scopo principale del markup XAML consista nell'implementare l'aspetto di un'applicazione, è anche possibile utilizzare XAML per implementare alcuni aspetti del comportamento di un'applicazione. Un esempio è dato dall'utilizzo dei trigger per modificare l'aspetto di un'applicazione in base alle interazioni dell'utente. Per ulteriori informazioni, vedere "Trigger" in Applicazione di stili e modelli.

Modelli di controllo

Le UIs predefinite per i controlli di WPF sono in genere costruite da altri controlli e forme. Ad esempio, un oggetto Buttonè composto da entrambi i controlli ButtonChromee ContentPresenter. L'oggetto ButtonChrome fornisce l'aspetto del pulsante standard, mentre ContentPresenter visualizza il contenuto del pulsante, come specificato dalla proprietà Content.

Talvolta, l'aspetto predefinito di un controllo può non essere coerente con l'aspetto complessivo di un'applicazione. In tal caso, è possibile utilizzare un oggetto ControlTemplate per modificare l'aspetto dell'UI del controllo senza modificare il contenuto e il comportamento.

Nell'esempio seguente viene illustrato come modificare l'aspetto di un oggetto Button utilizzando un oggetto 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!");
        }
    }
}

In questo esempio, il pulsante predefinito dell'UI è stato sostituito da un oggetto Ellipse che presenta un bordo blu scuro e viene riempito tramite un oggetto RadialGradientBrush. Il contenuto dell'oggetto Button, "Click Me!", viene visualizzato nel controllo ContentPresenter. Facendo clic su Button, viene comunque generato l'evento Click come parte del comportamento predefinito del controllo Button. Nella figura riportata di seguito viene illustrato il risultato.

Per ulteriori informazioni, vedere ControlTemplate. Per un esempio introduttivo, vedere Esempio di applicazione di stili con ControlTemplate.

Modelli di dati

Mentre un modello di controllo consente di specificare l'aspetto di un controllo, un modello di dati consente di specificare l'aspetto del contenuto di un controllo. I modelli di dati vengono spesso utilizzati per migliorare la modalità di visualizzazione dei dati associati. Nella figura riportata di seguito viene illustrato l'aspetto predefinito di un oggetto ListBox associato a un insieme di oggetti Task, dove ogni attività ha un nome, una descrizione e una priorità.

L'aspetto predefinito è quello previsto per un oggetto ListBox. L'aspetto predefinito di ogni attività, tuttavia, contiene solo il nome dell'attività. Per visualizzare il nome, la descrizione e la priorità di un'attività, è necessario modificare l'aspetto predefinito degli elementi elenco associati del controllo ListBox utilizzando un oggetto DataTemplate. Il codice XAML riportato di seguito definisce un oggetto DataTemplate, applicato a ogni attività utilizzando l'attributo 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">


...


<Window.Resources>
  <!-- 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>
</Window.Resources>


...


<!-- UI -->
<DockPanel>
  <!-- Title -->
  <Label DockPanel.Dock="Top" FontSize="18" Margin="5" Content="My Task List:"/>

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

</DockPanel>


...


</Window>

Nella figura riportata di seguito viene mostrato l'effetto di tale codice.

Si noti che l'oggetto ListBox mantiene il proprio comportamento e l'aspetto globale, mentre solo l'aspetto del contenuto visualizzato dalla casella di riepilogo viene modificato.

Per ulteriori informazioni vedere Cenni preliminari sui modelli di dati. Per un esempio introduttivo, vedere Esempio di introduzione ai modelli di dati.

Stili

Gli stili consentono agli sviluppatori e ai progettisti di standardizzare un determinato aspetto del prodotto. In WPF è disponibile un modello di stile avanzato, che si basa sull'elemento Style. Nell'esempio riportato di seguito viene creato uno stile che imposta il colore di sfondo per ogni oggetto Button di una finestra su 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 label 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>

Poiché lo stile ha come destinazione tutti i controlli Button, viene applicato automaticamente a tutti i pulsanti della finestra, come illustrato nella figura seguente.

Per ulteriori informazioni, vedere Applicazione di stili e modelli. Per un esempio introduttivo, vedere Esempio di introduzione agli stili e ai modelli.

Risorse

I controlli di un'applicazione devono condividere lo stesso aspetto, che può includere qualsiasi elemento dai tipi di carattere e i colori di sfondo ai modelli di controllo e di dati, agli stili. È possibile utilizzare il supporto di WPF per le risorse dell'user interface (UI) per incapsulare queste risorse in una sola posizione, consentendo di riutilizzarle.

Nell'esempio riportato di seguito viene definito un colore di sfondo comune condiviso da un oggetto Button e un oggetto 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>

In questo esempio viene implementata una risorsa di colore di sfondo utilizzando l'elemento della proprietà Window.Resources. Questa risorsa è disponibile per tutti i figli dell'oggetto Window. Sono presenti vari ambiti di risorsa, inclusi quelli riportati di seguito, elencati nell'ordine in cui vengono risolti:

1. Un singolo controllo (che utilizza la proprietà FrameworkElement.Resources ereditata).

2. Un oggetto Window o Page (che utilizza la proprietà FrameworkElement.Resources ereditata).

3. Un oggetto Application (che utilizza la proprietà Application.Resources).

La varietà degli ambiti offre flessibilità relativamente alla modalità di definizione e condivisione delle risorse.

In alternativa all'associazione diretta delle risorse a un determinato ambito, è possibile comprimere una o più risorse utilizzando un oggetto ResourceDictionary separato a cui è possibile fare riferimento in altre parti di un'applicazione. Nell'esempio riportato di seguito viene definito un colore di sfondo predefinito in un dizionario risorse.

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

Nell'esempio riportato di seguito viene fatto riferimento al dizionario risorse definito nell'esempio precedente per consentirne la condivisione in un'applicazione.

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

Risorse e dizionari risorse sono la base del supporto di WPF per temi e interfacce.

Per ulteriori informazioni, vedere Cenni preliminari sulle risorse.

Temi e interfacce

Da una prospettiva visiva, un tema definisce l'aspetto globale di Windows e delle applicazioni in esecuzione in tale sistema operativo. Windows viene fornito con diversi temi. Ad esempio, Microsoft Windows XP viene fornito con i temi di Windows XP e i temi classici di Windows, mentre Windows Vista viene fornito con i temi di Windows Vista e i temi classici di Windows. L'aspetto definito da un tema stabilisce l'aspetto predefinito per un'applicazione di WPF. WPF, tuttavia, non è integrato direttamente nei temi di Windows. Poiché l'aspetto di WPF è definito dai modelli, in WPF è incluso un modello per ogni tema di Windows noto, inclusi Aero (Windows Vista), Classico (Microsoft Windows 2000), Luna (Microsoft Windows XP) e Royale (Microsoft Windows XP Media Center Edition 2005). I temi vengono assemblati come dizionari risorse, che vengono risolti se le risorse non vengono trovate in un'applicazione. Molte applicazioni si basano su questi temi per la definizione dell'aspetto visivo. Grazie alla coerenza con l'aspetto di Windows, per gli utenti è più semplice acquisire familiarità con più applicazioni.

D'altra parte, l'esperienza utente per alcune applicazioni non deriva necessariamente dai temi standard. Microsoft Windows Media Player, ad esempio, utilizza dati audio e video e sfrutta uno stile diverso di esperienza utente. Queste UIs tendono a fornire temi personalizzati, specifici dell'applicazione noti come interfacce. Le applicazioni dotate di interfaccia offrono spesso la possibilità agli utenti di personalizzarne vari aspetti. In Microsoft Windows Media Player sono disponibili molte interfacce predefinite, oltre a numerose interfacce di terze parti.

I temi e le interfacce di WPF vengono definiti più facilmente utilizzando i dizionari risorse. Nell'esempio riportato di seguito vengono illustrate alcune definizioni di interfaccia di esempio.

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

Per ulteriori informazioni, vedere "Risorse e temi condivisi" in Applicazione di stili e modelli.

Controlli personalizzati

Benché in WPF sia disponibile un ampio supporto per la personalizzazione, in alcune situazioni i controlli di WPF esistenti potrebbero non soddisfare le necessità di un'applicazione o degli utenti. Questo può verificarsi nei seguenti casi:

• Non è possibile creare l'UI richiesta personalizzando l'aspetto delle implementazioni di WPF esistenti.

• Il comportamento richiesto non è supportato (o non è supportato facilmente) dalle implementazioni di WPF esistenti.

A questo punto, è tuttavia possibile sfruttare uno dei tre modelli di WPF per creare un nuovo controllo. Ogni modello ha come destinazione uno scenario specifico e richiede che il controllo personalizzato derivi da una determinata classe base di WPF. I tre modelli sono elencati di seguito:

• Modello di controllo utente. Un controllo personalizzato deriva da UserControl ed è composto da uno o più controlli.

• Modello di controllo. Un controllo personalizzato deriva da Control e viene utilizzato per compilare implementazioni che separano il comportamento dall'aspetto tramite modelli, come la maggior parte dei controlli di WPF. La derivazione da Control consente una maggiore libertà nella creazione di un'UI personalizzata rispetto ai controlli utente, ma può risultare più complessa.

• Modello di elemento framework. Un controllo personalizzato deriva da FrameworkElement quando il relativo aspetto è definito da logica di rendering personalizzata (non dai modelli).

Nell'esempio riportato di seguito viene illustrato un controllo su/giù numerico personalizzato che deriva da 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


...


    }
}

Nell'esempio che segue viene illustrato il codice XAML necessario per incorporare il controllo utente in un oggetto 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>

Nella figura riportata di seguito viene illustrato il controllo NumericUpDown ospitato in un oggetto Window.

Per ulteriori informazioni sui controlli personalizzati, vedere Cenni preliminari sulla modifica di controlli.

Procedure consigliate di WPF

Come per qualsiasi piattaforma di sviluppo, è possibile utilizzare WPF in vari modi per raggiungere il risultato desiderato. Per creare applicazioni WPF in grado di fornire l'esperienza utente richiesta e soddisfare le esigenze generali dei destinatari, vi sono procedure consigliate per l'accessibilità, la globalizzazione e la localizzazione e le prestazioni. Per ulteriori informazioni, vedere i seguenti argomenti:

• Procedure consigliate per l'accesso facilitato

• Cenni preliminari sulla globalizzazione e localizzazione WPF

• Ottimizzazione delle prestazioni di applicazioni WPF

• Sicurezza (WPF)

Riepilogo

WPF è una tecnologia di presentazione completa per la compilazione di un'ampia varietà di applicazioni client visivamente sorprendenti. In questa introduzione sono state trattate le funzionalità chiave di WPF.

La fase successiva prevede la compilazione di applicazioni WPF.

Durante la compilazione, potrà essere utile consultare questa introduzione per rivedere le funzionalità chiave e trovare riferimenti più dettagliati sulle funzionalità analizzate.

Cenni preliminari ed esempi consigliati

I cenni preliminari e gli esempi riportati di seguito sono citati in questa introduzione.

Panoramiche

Procedure consigliate per l'accesso facilitato Cenni preliminari sulla gestione di applicazioni Cenni preliminari sull'esecuzione di comandi Controlli Cenni preliminari sull'associazione dati Cenni preliminari sulle proprietà di dipendenza Documenti in WPF

Cenni preliminari sull’input Sistema di layout Cenni preliminari sulla navigazione Cenni preliminari sulla stampa Cenni preliminari sulle risorse Cenni preliminari sugli eventi indirizzati Applicazione di stili e modelli Funzionalità tipografiche di WPF Sicurezza (WPF) Cenni preliminari sulle finestre WPF Modello di contenuto WPF Cenni preliminari sulla globalizzazione e localizzazione WPF Grafica e funzionalità multimediali

Esempi

Esempio di solidi 3D Raccolta di esempi di animazioni Esempio Brush Demo di associazione dati Esempio di geometrie

Esempio di introduzione ai modelli di dati Esempio di introduzione agli stili e ai modelli Esempio di elementi forma Esempio di applicazione di stili con ControlTemplates Esempio di raccolte di layout WPF

Vedere anche

Concetti

Procedura dettagliata: introduzione a WPF

Commenti della community di WPF