Panoramica di Windows Presentation Foundation

Benvenuti alla Guida per desktop di Windows Presentation Foundation (WPF), un framework dell'interfaccia utente indipendente dalla risoluzione e che usa un motore di rendering basato su vettori, progettato per sfruttare i vantaggi dell'hardware grafico moderno. WPF offre un set completo di funzionalità per lo sviluppo di applicazioni che includono Extensible Application Markup Language (XAML), controlli, data binding, layout, grafica 2D e 3D, animazioni, stili, modelli, documenti, supporti, testo e tipografia. WPF fa parte di .NET, quindi è possibile compilare applicazioni che incorporano altri elementi dell'API .NET.

Esistono due implementazioni di WPF:

1. Versione .NET (questa guida):

   Implementazione open source di WPF ospitata in GitHub, che viene eseguita in .NET. La finestra di progettazione XAML richiede almeno Visual Studio 2019 versione 16.8. Tuttavia, a seconda della versione di .NET, potrebbe essere necessario usare una versione più recente di Visual Studio.

   Anche se .NET è una tecnologia multipiattaforma, WPF viene eseguito solo in Windows.

2. Versione .NET Framework 4:

   implementazione di WPF per .NET Framework supportata da Visual Studio 2019 e Visual Studio 2017.

   .NET Framework 4 è una versione di .NET solo per Windows ed è considerato un componente del sistema operativo Windows. Questa versione di WPF viene distribuita con .NET Framework.

Questa panoramica è destinata ai nuovi arrivati e illustra le funzionalità e i concetti chiave di WPF. Per informazioni su come creare un'app WPF, vedere Esercitazione: Creare una nuova app WPF.

Perché eseguire l'aggiornamento da .NET Framework

Quando si aggiorna l'applicazione da .NET Framework a .NET, è possibile trarre vantaggio da:

• Prestazioni migliori
• Nuove API .NET
• Miglioramenti del linguaggio più recenti
• Accessibilità e affidabilità migliorate
• Strumenti aggiornati e altro ancora

Per informazioni su come aggiornare l'applicazione, vedere Come aggiornare un'app desktop WPF a .NET.

Programmare con WPF

WPF è un subset di tipi di .NET in gran parte contenuti nello spazio dei nomi System.Windows. Se in precedenza sono state compilate applicazioni con .NET con framework come ASP.NET e Windows Forms, l'esperienza di programmazione WPF di base dovrebbe essere già nota:

• Creare un'istanza di classi
• Impostare le proprietà
• Chiamare i metodi
• Gestire gli eventi

WPF include costrutti di programmazione aggiuntivi che migliorano proprietà ed eventi: proprietà di dipendenza ed eventi indirizzati.

Markup e codice sottostante

WPF consente di sviluppare un'applicazione usando sia markup che code-behind, un'esperienza con cui gli sviluppatori ASP.NET devono avere familiarità. In genere si usa il markup XAML per implementare l'aspetto di un'applicazione usando linguaggi di programmazione gestiti (code-behind) per implementarne il comportamento. Questa separazione dell'aspetto e del comportamento presenta i vantaggi seguenti:

• I costi di sviluppo e gestione risultano ridotti, perché 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 contemporaneamente agli sviluppatori che implementano il comportamento dell'applicazione.

• di globalizzazione e localizzazione per le applicazioni WPF è semplificata.

Marcatura

XAML è un linguaggio di markup basato su XML che implementa l'aspetto di un'applicazione in modo dichiarativo. Viene in genere usato per definire finestre, finestre di dialogo, pagine e controlli utente e per inserire in questi elementi controlli, forme e grafica.

L'esempio seguente usa XAML per implementare l'aspetto di una finestra che contiene un singolo pulsante:

<Window
    xmlns="http://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, questo codice XAML definisce una finestra e un pulsante con gli elementi Window e Button. 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.

La figura seguente mostra l'interfaccia utente definita dal codice XAML nell'esempio precedente:

Poiché XAML è basato su XML, l'interfaccia utente con cui si compone viene assemblata in una gerarchia di elementi annidati noti come albero degli elementi. L'albero degli elementi offre un modo logico e intuitivo per creare e gestire interfacce utente.

Codice dietro

Il comportamento principale di un'applicazione consiste nell'implementare la funzionalità che risponde alle interazioni dell'utente, ad esempio la scelta di un menu o di 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 implementato nel codice associato al markup. Questo tipo di codice è noto come code-behind. L'esempio seguente illustra il markup aggiornato dell'esempio precedente e il code-behind:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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>

Il markup aggiornato definisce lo spazio dei nomi xmlns:x e ne esegue il mapping allo schema che aggiunge il supporto per i tipi code-behind. L'attributo x:Class viene usato per associare una classe code-behind a questo markup XAML specifico. Considerando che questo attributo viene dichiarato nell'elemento <Window>, la classe code-behind deve ereditare dalla classe Window.

using System.Windows;

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

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

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 quando l'applicazione viene compilata, motivo per cui non è necessario implementarla manualmente. La combinazione di x:Class e InitializeComponent assicurarsi che l'implementazione venga inizializzata correttamente ogni volta che viene creata.

Si noti che nel markup l'elemento <Button> ha definito un valore di button_Click per l'attributo Click. Con il markup e il code-behind inizializzati e funzionanti insieme, viene eseguito automaticamente il mapping dell'evento Click per il pulsante al metodo button_Click. Quando si fa clic sul pulsante, viene richiamato il gestore eventi e viene visualizzata una finestra di messaggio chiamando il metodo System.Windows.MessageBox.Show.

La figura seguente mostra il risultato quando si fa clic sul pulsante:

Input e comandi

I controlli rilevano e rispondono più spesso all'input dell'utente. Il sistema di input di WPF usa eventi sia diretti sia indirizzati per supportare l'input di testo, la gestione dello stato attivo e il posizionamento del mouse.

Le applicazioni spesso hanno requisiti di input complessi. In WPF è disponibile un sistema di comandi che separa le azioni di input utente dal codice che risponde a tali azioni. Il sistema di comandi consente a più origini di richiamare la stessa logica di comando. Ad esempio, considerare le operazioni di modifica comuni usate da applicazioni diverse: Copia, Taglia e Incolla. Queste operazioni possono essere richiamate usando diverse azioni utente se vengono implementate usando i comandi.

Controlli

Le esperienze utente fornite dal modello di applicazione sono controlli costruiti. In WPF il controllo è un termine generico che si applica a una categoria di classi WPF con le caratteristiche seguenti:

• È ospitato in una finestra o in una pagina.
• È dotato di interfaccia utente.
• Implementa un certo comportamento.

Per altre informazioni, vedere Controlli.

Controlli WPF per funzione

I controlli WPF predefiniti sono elencati di seguito:

• pulsanti: Button e RepeatButton.

• Visualizzazione dati: DataGrid, ListViewe TreeView.

• visualizzazione e selezione della data: Calendar e DatePicker.

• finestre di dialogo: OpenFileDialog, PrintDialoge SaveFileDialog.

• Digital Ink: InkCanvas e InkPresenter.

• Documenti: DocumentViewer, FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollViewere StickyNoteControl.

• Input: TextBox, RichTextBoxe PasswordBox.

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

• Media: Image, MediaElemente SoundPlayerAction.

• Menu : ContextMenu, Menue ToolBar.

• navigazione: Frame, Hyperlink, Page, NavigationWindowe TabControl.

• selezione: CheckBox, ComboBox, ListBox, RadioButtone Slider.

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

Impaginazione

Quando si crea un'interfaccia utente, si dispone i controlli in base alla posizione e alle dimensioni per formare un layout. Un requisito fondamentale di qualsiasi layout consiste nell'adattarsi alle modifiche apportate alle dimensioni della finestra e alle impostazioni di visualizzazione. Anziché forzare la scrittura del codice per adattare un layout in queste circostanze, WPF offre automaticamente un sistema di layout estendibile di prima classe.

La pietra angolare del sistema di layout è il posizionamento relativo, che aumenta la capacità di adattarsi alla modifica della finestra e delle condizioni di visualizzazione. Il sistema di layout gestisce inoltre la negoziazione tra i controlli per determinare il layout. La negoziazione è un processo a due fasi in cui innanzitutto un controllo indica il percorso e le dimensioni richieste alla relativa entità principale, quindi l'entità principale indica lo spazio disponibile al controllo.

Il sistema di layout viene esposto ai controlli figlio tramite classi WPF di base. Per i layout comuni, come griglia, impilamento e ancoraggio, WPF include vari controlli di layout.

• Canvas: i controlli secondari forniscono il proprio layout.

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

• Grid: i controlli figlio vengono posizionati in base a righe e colonne.

• StackPanel: i controlli dei bambini vengono impilati verticalmente o orizzontalmente.

• VirtualizingStackPanel: i controlli figlio vengono virtualizzati e disposti su una singola riga orientata orizzontalmente o verticalmente.

• WrapPanel: i controlli figlio vengono posizionati nell'ordine da sinistra a destra e racchiusi nella riga successiva quando non c'è spazio sufficiente sulla riga corrente.

Nell'esempio seguente viene usato un DockPanel per posizionare diversi controlli TextBox:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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>

Il DockPanel permette ai controlli del componente figlio TextBox di indicare come disporli. A tale scopo, il DockPanel implementa una proprietà associata Dock che viene esposta ai controlli figlio per consentire a ciascuno di specificare uno stile di ancoraggio.

La figura seguente mostra il risultato del markup XAML nell'esempio precedente:

associazione dei dati

La maggior parte delle applicazioni viene creata per fornire agli utenti i mezzi per visualizzare e modificare i dati. Per le applicazioni WPF, le operazioni di archiviazione e accesso ai dati sono già disponibili per molte librerie di accesso ai dati .NET diverse, ad esempio SQL ed Entity Framework Core. Dopo l'accesso e il caricamento dei dati negli oggetti gestiti di un'applicazione, inizia il lavoro duro per le applicazioni WPF. In sostanza, questo comporta due aspetti:

1. Copia dei dati dagli oggetti gestiti in controlli, in cui è possibile visualizzare e modificare i dati.

2. Assicurarsi che le modifiche apportate ai dati usando i controlli vengano copiate nuovamente negli oggetti gestiti.

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

WPF supporta la dichiarazione di associazioni direttamente nel markup XAML. Ad esempio, il codice XAML seguente associa la proprietà Text dell'oggetto TextBox alla proprietà Name di un oggetto usando la sintassi XAML "{Binding ... }". Si presuppone che sia presente un oggetto dati impostato sulla proprietà DataContext di Window con una proprietà Name.

<Window
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://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>

Il motore di associazione dati WPF offre più della semplice associazione, in quanto include funzionalità di convalida, ordinamento, filtro e raggruppamento. Il data binding supporta anche l'uso di modelli di dati per creare un'interfaccia utente personalizzata per i dati associati.

Per altre informazioni, vedere panoramica del data binding .

Grafica e animazione

In WPF è disponibile un set completo 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, che costituisce la base per il rendering indipendente dalla risoluzione e dal dispositivo. Ogni pixel indipendente dal dispositivo viene ridimensionato automaticamente in modo che corrisponda all'impostazione punti per pollice (dpi) del sistema su cui viene eseguito il rendering.

• Precisione migliorata. Il sistema di coordinate WPF viene misurato con numeri a virgola mobile e precisione doppia anziché con precisione singola. Le trasformazioni e i valori di opacità sono espressi anche con doppia precisione. WPF supporta anche un'ampia gamma di colori (scRGB) e fornisce supporto integrato per la gestione degli input da spazi di colore diversi.

• Supporto per la grafica avanzata e l'animazione. 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. WPF offre inoltre supporto per hit testing e supporto per la composizione alfa completa.

• Accelerazione hardware. Il sistema grafico WPF sfrutta l'hardware grafico per ridurre al minimo l'utilizzo della CPU.

Grafica 2D

In WPF è disponibile una libreria di forme 2D comuni disegnate da vettori, ad esempio i rettangoli e le ellissi. Le forme non vengono usate solo per la visualizzazione, infatti implementano molte delle funzionalità fornite dai controlli, incluso l'input della tastiera e del mouse.

Le forme 2D fornite da WPF coprono il set standard di forme di base. Può tuttavia essere necessario creare forme personalizzate per semplificare la progettazione di un'interfaccia utente personalizzata. WPF fornisce le geometrie per creare una forma personalizzata che può essere disegnata direttamente o usata come pennello o per ritagliare altre forme e controlli.

Per ulteriori informazioni, vedere la panoramica della geometria .

Le funzionalità 2D di WPF comprendono effetti visivi, come sfumature, bitmap, disegni, pittura con video, rotazione, ridimensionamento e inclinazione. Questi effetti sono tutti ottenuti con pennelli. Nella figura seguente vengono mostrati alcuni esempi:

Per ulteriori informazioni, vedere la panoramica sui pennelli WPF .

Rendering 3D

WPF include anche funzionalità di rendering 3D che si integrano con grafica 2D per consentire la creazione di interfacce utente più interessanti e interessanti. Ad esempio, la figura seguente mostra le immagini 2D di cui è stato eseguito il rendering in forme 3D:

Per altre informazioni, vedere panoramica della grafica 3D.

Animazione

Il supporto per le animazioni WPF consente di ingrandire, scuotere, ruotare e dissolvere i controlli, per creare transizioni di pagina interessanti e altro ancora. È possibile animare la maggior parte delle classi WPF, anche classi personalizzate. La figura seguente mostra un'animazione semplice in azione:

Per ulteriori informazioni, vedere la panoramica dell'animazione .

Testo e tipografia

Per offrire il rendering di testo di alta qualità, WPF offre le funzionalità seguenti:

• Supporto dei tipi di carattere OpenType.
• Miglioramenti di ClearType.
• Prestazioni elevate che sfruttano l'accelerazione hardware.
• Integrazione del testo con elementi multimediali, grafici e animazioni.
• Supporto dei tipi di carattere internazionale e meccanismi di fallback.

Come dimostrazione dell'integrazione del testo con la grafica, la figura seguente illustra l'applicazione delle decorazioni di testo:

Per altre informazioni, vedere tipografia in Windows Presentation Foundation.

Personalizzare le app WPF

Finora, sono stati presentati i blocchi di compilazione principali di WPF per lo sviluppo di applicazioni:

• Si usa il modello di applicazione per ospitare e distribuire il contenuto dell'applicazione, costituito principalmente da controlli.
• Per semplificare la disposizione dei controlli in un'interfaccia utente, viene usato il sistema di layout di WPF.
• Per ridurre le operazioni di integrazione dell'interfaccia utente con i dati viene usata l'associazione dati.
• Per migliorare l'aspetto visivo dell'applicazione, è possibile usare la gamma completa di grafica, animazione e supporto multimediale fornito da WPF.

Spesso, tuttavia, le funzionalità di base non sono sufficienti per creare e gestire applicazioni davvero uniche e visivamente sorprendenti per gli utenti. I controlli WPF standard potrebbero non integrarsi con l'aspetto desiderato dell'applicazione. I dati potrebbero non essere visualizzati nel modo più efficace. L'esperienza utente complessiva dell'applicazione potrebbe non essere adatta all'aspetto predefinito dei temi di Windows.

Per questo motivo, WPF offre vari meccanismi per la creazione di esperienze utente univoche.

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 viene definito 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 stringa assegnato alla proprietà Text.

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 i controlli di layout, testo, immagini e forme.

Per altre informazioni sui tipi di contenuto supportati da vari controlli, vedere modello di contenuto WPF.

Attivatori

Anche se lo scopo principale del markup XAML è implementare l'aspetto di un'applicazione, puoi anche usare XAML per implementare alcuni aspetti del comportamento di un'applicazione. Un esempio è l'uso di trigger per modificare l'aspetto di un'applicazione in base alle interazioni dell'utente. Per altre informazioni, vedere Stili e modelli.

Modelli

Le interfacce utente predefinite per i controlli WPF vengono in genere costruite da altri controlli e forme. Ad esempio, un Button è composto sia da ButtonChrome che da controlli ContentPresenter. Il ButtonChrome fornisce l'aspetto standard del pulsante, mentre il ContentPresenter visualizza il contenuto del pulsante, come specificato dalla proprietà Content.

A volte l'aspetto predefinito di un controllo può essere in conflitto con l'aspetto complessivo di un'applicazione. In questo caso, è possibile usare un ControlTemplate per modificare l'aspetto dell'interfaccia utente del controllo senza modificarne il contenuto e il comportamento.

Ad esempio, un controllo Button genera l'evento Click quando viene fatto clic. Modificando il modello di un pulsante per visualizzare una forma Ellipse, l'oggetto visivo dell'aspetto del controllo è cambiato, ma la funzionalità non è stata modificata. È comunque possibile fare clic sull'aspetto visivo del controllo e l'evento Click viene generato come previsto.

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 usati per migliorare la modalità di visualizzazione dei dati associati. La figura seguente mostra l'aspetto predefinito di un ListBox associato a una raccolta di oggetti Task, in cui ogni attività ha un nome, una descrizione e una priorità:

L'aspetto predefinito è ciò che ci si aspetterebbe da un ListBox. Tuttavia, l'aspetto predefinito di ogni attività contiene solo il nome dell'attività. Per visualizzare il nome, la descrizione e la priorità dell'attività, è necessario modificare l'aspetto predefinito degli elementi associati dell'elenco del controllo ListBox utilizzando un DataTemplate. Ecco un esempio di applicazione di un modello di dati creato per l'oggetto Task.

ListBox mantiene il proprio comportamento e l'aspetto complessivo e solo l'aspetto del contenuto visualizzato dalla casella di riepilogo viene modificato.

Per altre informazioni, vedere la panoramica della modellazione dei dati .

Stili

Gli stili consentono agli sviluppatori e ai progettisti di standardizzare in base a un aspetto specifico per il prodotto. WPF offre un modello di stile sicuro, la cui base è l'elemento Style. Gli stili possono applicare i valori delle proprietà ai tipi. Possono essere applicati automaticamente a tutti gli oggetti in base al tipo o ai singoli oggetti quando vi viene fatto riferimento. L'esempio seguente descrive come creare uno stile che imposta il colore di sfondo per ogni oggetto Button di una finestra su Orange:

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

    <Window.Resources>
        <!-- Style that will be applied to all buttons for this window -->
        <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>
    </Window.Resources>
    <StackPanel>

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

    </StackPanel>
</Window>

Poiché questo stile è destinato a tutti i controlli Button, lo stile viene applicato automaticamente a tutti i pulsanti nella finestra, come illustrato nella figura seguente:

Per altre informazioni, vedere Stili e modelli.

Risorse

I controlli in un'applicazione devono condividere lo stesso aspetto, che può includere qualsiasi elemento, dai tipi di carattere e dai colori di sfondo ai modelli di controllo, ai modelli di dati e agli stili. È possibile usare il supporto di WPF per le risorse dell'interfaccia utente per incapsulare queste risorse in un'unica posizione per il riutilizzo.

Nell'esempio seguente viene definito un colore di sfondo comune condiviso da un Button e da un Label:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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>

Per altre informazioni, vedere Come definire e fare riferimento a una risorsa WPF.

Controlli personalizzati

Sebbene WPF offra una serie di supporto per la personalizzazione, è possibile che si verifichino situazioni in cui i controlli WPF esistenti non soddisfano le esigenze dell'applicazione o dei relativi utenti. Questo problema può verificarsi quando:

• L'interfaccia utente necessaria non può essere creata personalizzando l'aspetto delle implementazioni 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 WPF per creare un nuovo controllo. Ogni modello è destinato a uno scenario specifico e richiede che il controllo personalizzato derivi da una determinata classe di base 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 usato per compilare implementazioni che separano il comportamento dall'aspetto tramite modelli, come la maggior parte dei controlli di WPF. Derivare da Control ti permette maggiore libertà per creare un'interfaccia utente personalizzata rispetto ai controlli utente, ma potrebbe richiedere più impegno.

• Modello di Elementi del Framework.
  Un controllo personalizzato deriva da FrameworkElement quando l'aspetto è definito dalla logica di rendering personalizzata (non dai modelli).

Per altre informazioni sui controlli personalizzati, vedere Panoramica sulla creazione di controlli.

Vedere anche

• Esercitazione: Creare una nuova app WPF
• Eseguire la migrazione di un'app WPF a .NET
• Panoramica delle finestre WPF
• Panoramica dell'associazione dati
• panoramica del XAML