Cenni preliminari sulle finestre WPF

Le finestre consentono l'interazione degli utenti con le applicazioni autonome Windows Presentation Foundation (WPF). Scopo principale di una finestra è ospitare il contenuto che visualizza i dati e consente agli utenti di interagire con essi. Le applicazioni WPF autonome utilizzano la classe Window per fornire le rispettive finestre. In questo argomento viene descritta la classe Window e successivamente vengono illustrate le nozioni fondamentali sulla creazione e gestione delle finestre nelle applicazioni autonome.

Nota
Le applicazioni WPF ospitate da browser, incluse le XAML browser applications (XBAPs) e le pagine Extensible Application Markup Language (XAML) separate, non dispongono di finestre proprie.Al contrario, vengono ospitate nelle finestre fornite da Windows Internet Explorer.Vedere Panoramica delle applicazioni browser XAML di WPF.

Nel presente argomento sono contenute le seguenti sezioni.

• Classe Window
• Implementazione di una finestra
• Configurazione della definizione di una finestra per MSBuild
• Durata di una finestra
• Posizione di una finestra
• Dimensioni di una finestra
• Ordine di precedenza per le proprietà di dimensione
• Stato di una finestra
• Aspetto di una finestra
• Considerazioni sulla sicurezza
• Altri tipi di finestre
• Argomenti correlati

Classe Window

Nella figura che segue vengono illustrate le diverse parti che compongono una finestra.

Una finestra è suddivisa in due aree: l'area non client e l'area client.

L'area non client di una finestra viene implementata da WPF e include le parti comuni alla maggior parte delle finestre, tra cui le seguenti:

• Un bordo.

• Una barra del titolo.

• Un'icona.

• I pulsanti Riduci a icona, Ingrandisci e Ripristina.

• Un pulsante Chiudi.

• Un menu Sistema le cui voci consentono agli utenti di ridurre a icona, ingrandire, ripristinare, spostare, ridimensionare e chiudere una finestra.

L'area client di una finestra è l'area situata all'interno dell'area non client e utilizzata dagli sviluppatori per aggiungere un contenuto specifico dell'applicazione, ad esempio barre dei menu, barre degli strumenti e controlli.

In WPF una finestra viene incapsulata dalla classe Window, utilizzata per effettuare le seguenti operazioni:

• Visualizzare una finestra.

• Configurare le dimensioni, la posizione e l'aspetto di una finestra.

• Ospitare contenuto specifico dell'applicazione.

• Gestire la durata di una finestra.

Implementazione di una finestra

L'implementazione di una finestra tipica include sia l'aspetto che il comportamento: l'aspetto definisce le caratteristiche visive della finestra, mentre il comportamento ne definisce il funzionamento nel momento in cui gli utenti interagiscono con essa. In WPF è possibile implementare l'aspetto e il comportamento di una finestra tramite codice o markup XAML.

Tuttavia, accade in genere che l'aspetto di una finestra venga implementato tramite markup XAML e il comportamento tramite code-behind, come illustrato nell'esempio che segue.

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

  <!-- Client area (for content) -->

</Window>

Imports System.Windows ' Window

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

using System.Windows; // Window

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

Per consentire il funzionamento congiunto di un file di markup XAML e un file code-behind, è necessario soddisfare le seguenti condizioni:

• Nel markup, l'elemento Window deve includere l'attributo x:Class. Quando l'applicazione viene compilata, la presenza di x:Class nel file di markup fa sì che Microsoft build engine (MSBuild) crei una classe partial derivante da Window e avente il nome specificato dall'attributo x:Class. Questo richiede l'aggiunta di una dichiarazione dello spazio dei nomi XML per lo schema XAML (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"). La classe partial generata implementa il metodo InitializeComponent, il quale viene chiamato per registrare gli eventi e impostare le proprietà implementate nel markup.

• Nel code-behind, la classe deve essere una classe partial avente lo stesso nome specificato dall'attributo x:Class nel markup e deve derivare da Window. In questo modo il file code-behind può essere associato alla classe partial generata per il file di markup durante la compilazione dell'applicazione (vedere Compilazione di un'applicazione WPF (WPF)).

• Nel code-behind, la classe Window deve implementare un costruttore che chiama il metodo InitializeComponent. Il metodo InitializeComponent viene implementato dalla classe partial generata per il file di markup per registrare gli eventi e impostare le proprietà definite nel markup.

Nota
Quando si aggiunge un nuovo oggetto Window al progetto utilizzando Microsoft Visual Studio, questo viene implementato tramite markup e code-behind e include la configurazione necessaria per creare l'associazione tra il file di markup e il file code-behind, come descritto in questo argomento.

Grazie a questa configurazione sarà possibile concentrarsi sulla definizione dell'aspetto della finestra nel markup XAML e sull'implementazione del comportamento nel code-behind. Nell'esempio seguente viene illustrata una finestra con un pulsante, implementato nel markup XAML, e un gestore eventi per l'evento Click del pulsante, implementato nel code-behind.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  <!-- Client area (for content) -->
  <Button Click="button_Click">Click This Button</Button>
</Window>

Imports System.Windows

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            MessageBox.Show("Button was clicked.")
        End Sub
    End Class
End Namespace

using System.Windows;

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

        void button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}

Configurazione della definizione di una finestra per MSBuild

Il modo in cui una finestra viene implementata ne determina la configurazione per MSBuild. Nel caso di una finestra definita tramite markup XAML e code-behind:

• I file di markup XAML vengono configurati come elementi Page MSBuild.

• I file code-behind vengono configurati come elementi Compile MSBuild.

Nel file di progetto MSBuild che segue viene illustrato quanto detto.

<Project ... xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Per informazioni sulla compilazione di applicazioni WPF, vedere Compilazione di un'applicazione WPF (WPF).

Durata di una finestra

Come accade per qualsiasi classe, la durata di una finestra ha inizio nel momento in cui ne viene creata un'istanza, dopo di che la finestra verrà aperta, attivata, disattivata ed eventualmente chiusa.

Nella presente sezione sono contenute le seguenti sottosezioni.

• Apertura di una finestra
• Attivazione di una finestra
• Chiusura di una finestra
• Eventi di durata di una finestra

Apertura di una finestra

Per aprire una finestra occorre innanzitutto crearne un'istanza, come illustrato nell'esempio che segue.

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub app_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Create a window
            Dim window As New MarkupAndCodeBehindWindow()

            ' Open a window
            window.Show()
        End Sub
    End Class
End Namespace

using System.Windows;
namespace SDKSample
{
    public partial class App : Application
    {
        void app_Startup(object sender, StartupEventArgs e)
        {
            // Create a window
            MarkupAndCodeBehindWindow window = new MarkupAndCodeBehindWindow();

            // Open a window
            window.Show();
        }
    }
}

In questo esempio viene creata un'istanza di MarkupAndCodeBehindWindow all'avvio dell'applicazione, ovvero nel momento in cui viene generato l'evento Startup.

Quando si crea un'istanza di una finestra, un riferimento a questa viene automaticamente aggiunto a un elenco di finestre gestito dall'oggetto Application (vedere Application.Windows). Inoltre, per impostazione predefinita, la prima finestra di cui si crea un'istanza viene impostata da Application come finestra principale dell'applicazione (vedere Application.MainWindow).

Infine la finestra viene aperta mediante una chiamata al metodo Show. Nella figura riportata di seguito viene illustrato il risultato.

La chiamata al metodo Show genera una finestra non modale. In altri termini, la modalità di funzionamento dell'applicazione consente agli utenti di attivare altre finestre nella stessa applicazione.

Nota
La chiamata al metodo ShowDialog consente invece di aprire finestre modali, quali ad esempio le finestre di dialogo.Per ulteriori informazioni, vedere Cenni preliminari sulle finestre di dialogo.

La chiamata a Show non comporta l'immediata visualizzazione di una finestra, poiché questa esegue prima le operazioni di inizializzazione per stabilire l'infrastruttura necessaria per ricevere l'input dell'utente. Una volta inizializzata la finestra, viene generato l'evento SourceInitialized e la finestra in questione viene visualizzata.

Per una procedura più rapida, è possibile impostare StartupUri in modo tale da specificare la prima finestra che viene automaticamente aperta all'avvio dell'applicazione.

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

Quando l'applicazione viene avviata, la finestra specificata dal valore di StartupUri viene aperta come non modale. A livello interno, la finestra viene aperta chiamando il metodo Show.

Proprietà di una finestra

In caso di utilizzo del metodo Show, non si crea alcuna relazione implicita tra la finestra aperta e la finestra che l'ha creata. Gli utenti possono quindi interagire con una finestra indipendentemente dall'altra. In altre parole, ogni finestra può eseguire le operazioni seguenti:

• Coprire l'altra finestra, a meno che una delle finestre non abbia la proprietà Topmost impostata su true.

• Essere ridotta a icona, ingrandita e ripristinata senza influire sull'altra.

Alcune finestre necessitano di una relazione con la finestra da cui vengono aperte. Ad esempio, è possibile che in un'applicazione nell'Integrated Development Environment (IDE) vengano aperte finestre delle proprietà e degli strumenti il cui comportamento tipico prevede la copertura della finestra che le crea. Tali finestre dovranno sempre essere chiuse, ridotte a icona, ingrandite e ripristinate insieme alla finestra che le ha create. Questa relazione può essere stabilita facendo in modo che una finestra diventi proprietaria di un'altra finestra, ovvero impostando la proprietà Owner della finestra secondaria con un riferimento alla finestra proprietaria, come illustrato nell'esempio che segue.

' Create a window and make this window its owner
Dim ownedWindow As New Window()
ownedWindow.Owner = Me
ownedWindow.Show()

// Create a window and make this window its owner
Window ownedWindow = new Window();
ownedWindow.Owner = this;
ownedWindow.Show();

Una volta stabilita la proprietà:

• La finestra secondaria può fare riferimento alla finestra proprietaria controllando il valore della proprietà Owner.

• La finestra proprietaria può individuare tutte le finestre che le appartengono controllando il valore della proprietà OwnedWindows.

Prevenzione dell'attivazione della finestra

In alcuni scenari le finestre non devono essere attivate quando vengono visualizzate, come ad esempio nelle finestre di conversazione di un'applicazione Internet di tipo Messenger o nelle finestre di notifica di un'applicazione di posta elettronica.

Se l'applicazione dispone di una finestra che non deve essere attivata quando viene visualizzata, è possibile impostarne la proprietà ShowActivated su false prima di chiamare il metodo Show per la prima volta. Di conseguenza:

• La finestra non viene attivata.

• L'evento Activated non viene generato.

• La finestra correntemente attiva resterà tale.

Verrà tuttavia attivata da parte dell'utente quando fa clic sull'area client o non client. In questo caso:

• La finestra viene attivata.

• Viene generato l'evento Activated della finestra.

• La finestra precedentemente attivata viene disattivata.

• Gli eventi Deactivated e Activated della finestra vengono quindi generati come previsto in risposta alle azioni dell'utente.

Attivazione di una finestra

Quando la finestra viene aperta inizialmente, diviene la finestra attiva (a meno che non sia visualizzata con ShowActivated impostato su false). La finestra attiva è quella che acquisisce attualmente l'input dell'utente, quale ad esempio la pressione di un tasto o un clic del mouse. Quando una finestra diventa attiva, genera l'evento Activated.

Nota
All'apertura di una finestra, gli eventi Loaded e ContentRendered vengono generati soltanto dopo l'evento Activated.Tenuto conto di questo, una finestra può considerarsi effettivamente aperta quando viene generato ContentRendered.

Una volta attivata una finestra, un utente può attivare un'altra finestra nella stessa applicazione oppure attivare un'altra applicazione. In tal caso, la finestra attualmente attiva viene disattivata e genera l'evento Deactivated. In modo analogo, quando l'utente seleziona una finestra attualmente disattivata, questa diventa nuovamente attiva e genera Activated.

In genere, Activated e Deactivated vengono gestiti per abilitare e disabilitare le funzionalità eseguibili soltanto con la finestra attiva. Alcune finestre, ad esempio, visualizzano un contenuto interattivo che richiede attenzione o input costanti da parte dell'utente. È il caso di giochi o lettori video. Di seguito viene riportato l'esempio di un lettore video semplificato nel quale viene illustrato come gestire Activated e Deactivated per implementare questo comportamento.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CustomMediaPlayerWindow"
    Activated="window_Activated"
    Deactivated="window_Deactivated">

    <!-- Media Player -->
    <MediaElement 
      Name="mediaElement" 
      Stretch="Fill" 
      LoadedBehavior="Manual" 
      Source="numbers.wmv" />

</Window>

Imports System ' EventArgs
Imports System.Windows ' Window

Namespace SDKSample
    Partial Public Class CustomMediaPlayerWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub window_Activated(ByVal sender As Object, ByVal e As EventArgs)
            ' Recommence playing media if window is activated
            Me.mediaElement.Play()
        End Sub

        Private Sub window_Deactivated(ByVal sender As Object, ByVal e As EventArgs)
            ' Pause playing if media is being played and window is deactivated
            Me.mediaElement.Pause()
        End Sub
    End Class
End Namespace

using System; // EventArgs
using System.Windows; // Window

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

        void window_Activated(object sender, EventArgs e)
        {
            // Recommence playing media if window is activated
            this.mediaElement.Play();
        }

        void window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            this.mediaElement.Pause();
        }
    }
}

Altri tipi di applicazioni possono comunque eseguire codice in background quando una finestra viene disattivata. Ad esempio, è possibile che un client di posta elettronica continui a eseguire il polling del server di posta mentre l'utente utilizza altre applicazioni. Applicazioni di questo tipo forniscono spesso un comportamento diverso o aggiuntivo mentre la finestra principale è disattivata. Nel caso del programma di posta elettronica, può accadere che un nuovo elemento di posta venga aggiunto nella posta in arrivo e contemporaneamente un'icona di notifica venga visualizzata nella barra delle applicazioni. L'icona di notifica deve essere visualizzata soltanto quando la finestra di posta elettronica non è attiva. A tal proposito, controllare la proprietà IsActive.

Se un'attività in background viene completata, è possibile che una finestra voglia informare l'utente in modo più tempestivo, chiamando il metodo Activate. Se al momento della chiamata ad Activate l'utente sta interagendo con un'altra applicazione attivata, il pulsante della finestra nella barra delle applicazioni lampeggia. Se l'utente sta interagendo con l'applicazione corrente, la chiamata ad Activate fa sì che la finestra venga visualizzata in primo piano.

Nota
È possibile gestire l'attivazione con ambito di applicazione utilizzando gli eventi Application.Activated e Application.Deactivated.

Chiusura di una finestra

La durata di una finestra volge al termine nel momento in cui la stessa viene chiusa da un utente. Una finestra può essere chiusa utilizzando gli elementi presenti nell'area non client, tra cui:

• L'elemento Chiudi del menu Sistema.

• La combinazione di tasti ALT + F4.

• Il pulsante Chiudi.

È anche possibile fornire meccanismi di chiusura aggiuntivi nell'area client. Di seguito vengono riportati alcuni tra i meccanismi più comuni:

• Un elemento Esci nel menu File, in genere nelle finestre principali delle applicazioni.

• Un elemento Chiudi nel menu File, in genere in una finestra secondaria dell'applicazione.

• Un pulsante Annulla, in genere in una finestra di dialogo modale.

• Un pulsante Chiudi, in genere in una finestra di dialogo non modale.

Per chiudere una finestra in risposta a uno di questi meccanismi personalizzati, è necessario chiamare il metodo Close. Nell'esempio seguente viene implementata la possibilità di chiudere una finestra mediante l'elemento Esci del menu File.

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

  <Menu>
    <MenuItem Header="_File">
      <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
    </MenuItem>
  </Menu>

</Window>

Imports System.Windows ' window, RoutedEventArgs

Namespace SDKSample
    Partial Public Class WindowWithFileExit
        Inherits System.Windows.Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub fileExitMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Close this window
            Me.Close()
        End Sub
    End Class
End Namespace

using System.Windows; // window, RoutedEventArgs

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

        void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close this window
            this.Close();
        }
    }
}

Quando una finestra si chiude, genera due eventi: Closing e Closed.

Closing viene generato prima che la finestra si chiuda e fornisce un meccanismo mediante il quale è possibile impedirne la chiusura. Una ragione comune per impedire la chiusura è data dalla presenza di dati modificati nel contenuto della finestra. In questo caso è possibile gestire l'evento Closing per stabilire se i dati siano stati modificati e, in caso affermativo, chiedere all'utente se proseguire con la chiusura della finestra senza salvare i dati o piuttosto annullare la chiusura. Nell'esempio seguente vengono illustrati gli aspetti principali della gestione di Closing.

Imports System ' EventArgs
Imports System.ComponentModel ' CancelEventArgs
Imports System.Windows ' window

Namespace VisualBasic
    Partial Public Class DataWindow
        Inherits Window
        ' Is data dirty
        Private isDataDirty As Boolean = False


...


        Private Sub DataWindow_Closing(ByVal sender As Object, ByVal e As CancelEventArgs)
            MessageBox.Show("Closing called")

            ' If data is dirty, notify user and ask for a response
            If Me.isDataDirty Then
                Dim msg As String = "Data is dirty. Close without saving?"
                Dim result As MessageBoxResult = MessageBox.Show(msg, "Data App", MessageBoxButton.YesNo, MessageBoxImage.Warning)
                If result = MessageBoxResult.No Then
                    ' If user doesn't want to close, cancel closure
                    e.Cancel = True
                End If
            End If
        End Sub
    End Class
End Namespace

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // window

namespace CSharp
{
    public partial class DataWindow : Window
    {
        // Is data dirty
        bool isDataDirty = false;


...


        void DataWindow_Closing(object sender, CancelEventArgs e)
        {
            MessageBox.Show("Closing called");

            // If data is dirty, notify user and ask for a response
            if (this.isDataDirty)
            {
                string msg = "Data is dirty. Close without saving?";
                MessageBoxResult result = 
                  MessageBox.Show(
                    msg, 
                    "Data App", 
                    MessageBoxButton.YesNo, 
                    MessageBoxImage.Warning);
                if (result == MessageBoxResult.No)
                {
                    // If user doesn't want to close, cancel closure
                    e.Cancel = true;
                }
            }
        }
    }
}

Al gestore dell'evento Closing viene passato un oggetto CancelEventArgs, il quale implementa la proprietà Cancel Boolean impostata su true per impedire la chiusura di una finestra.

Se Closing non viene gestito oppure viene gestito ma non annullato, la finestra si chiuderà. Prima dell'effettiva chiusura di una finestra, viene generato Closed. A questo punto non sarà più possibile impedirne la chiusura.

Nota
È possibile configurare un'applicazione in modo tale che si chiuda quando viene chiusa la finestra principale della stessa (vedere MainWindow) oppure l'ultima finestra rimasta aperta.Per informazioni dettagliate, vedere ShutdownMode.

Una finestra può essere chiusa in modo esplicito tramite meccanismi forniti nelle aree non client e client, ma può anche essere chiusa in modo implicito in seguito a comportamenti in altre parti dell'applicazione o in Windows, inclusi i seguenti:

• Un utente si disconnette o termina la sessione di lavoro di Windows.

• La finestra proprietaria della finestra in questione viene chiusa (vedere Owner).

• La finestra principale dell'applicazione viene chiusa e ShutdownMode è impostata su OnMainWindowClose.

• Viene chiamato Shutdown.

Nota
Una volta chiusa, una finestra non può essere riaperta.

Eventi di durata di una finestra

Nella figura che segue viene illustrata la sequenza dei principali eventi di durata di una finestra.

Nell'illustrazione seguente è mostrata la sequenza degli eventi principali nella durata di una finestra, visualizzata senza attivazione (ShowActivated viene impostato su false prima che venga visualizzata la finestra).

Posizione di una finestra

Una finestra aperta occupa una posizione nelle dimensioni x e y relativamente al desktop. Questa posizione può essere determinata controllando rispettivamente le proprietà Left e Top. Tramite impostazione di queste proprietà è possibile modificare la posizione della finestra.

È anche possibile specificare la posizione iniziale di Window, ovvero la posizione in cui viene visualizzato all'avvio, impostando la proprietà WindowStartupLocation con uno dei valori di enumerazione WindowStartupLocation seguenti:

• Manual (impostazione predefinita)

• CenterScreen

• CenterOwner

Se la posizione di avvio è specificata come Manual e le proprietà Left e Top non sono state impostate, Window chiederà a Windows in quale posizione effettuare la visualizzazione.

Finestre in primo piano e ordine Z

Oltre a occupare una posizione x e y, una finestra occupa anche una posizione nella dimensione z, la quale determina la posizione verticale in relazione alle altre finestre. Si tratta del cosiddetto ordine Z della finestra, il quale può essere di due tipi: normale e di primo piano. La posizione di una finestra nell'ordine Z normale dipende dal fatto che questa sia attualmente attiva o meno. Per impostazione predefinita una finestra si trova nell'ordine Z normale. Anche la posizione di una finestra nell'ordine Z di primo piano dipende dal fatto che questa sia attualmente attiva o meno. Inoltre, le finestre situate nell'ordine Z di primo piano vengono sempre sovrapposte alle finestre situate nell'ordine Z normale. Per collocare una finestra nell'ordine Z di primo piano, impostare la proprietà Topmost su true.

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


...


</Window>

All'interno di ogni ordine Z, la finestra attualmente attiva viene visualizzata sopra a tutte le altre finestre dello stesso ordine.

Dimensioni di una finestra

Oltre a occupare una posizione nel desktop, una finestra è caratterizzata da dimensioni specifiche determinate da diverse proprietà, tra cui le varie proprietà di larghezza e altezza e SizeToContent.

MinWidth, Width e MaxWidth vengono utilizzate per gestire l'intervallo delle larghezze che possono caratterizzare una finestra nel corso della sua durata. Queste proprietà vengono configurate come illustrato nell'esempio che segue.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinWidth="300" Width="400" MaxWidth="500">


...


</Window>

L'altezza di una finestra viene gestita mediante MinHeight, Height e MaxHeight. Queste proprietà vengono configurate come illustrato nell'esempio che segue.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinHeight="300" Height="400" MaxHeight="500">


...


</Window>

Poiché i diversi valori di larghezza e di altezza specificano un intervallo, la larghezza e l'altezza di una finestra ridimensionabile possono assumere un valore qualsiasi all'interno dell'intervallo specificato per la rispettiva dimensione. Per rilevare la larghezza e l'altezza correnti, controllare rispettivamente ActualWidth e ActualHeight.

Per fare in modo che la larghezza e l'altezza della finestra si adattino al contenuto della stessa, è possibile utilizzare la proprietà SizeToContent, la quale può assumere i seguenti valori:

• Manual. Nessun effetto (impostazione predefinita).

• Width. Adattamento alla larghezza del contenuto; stesso effetto ottenuto impostando MinWidth e MaxWidth sulla larghezza del contenuto.

• Height. Adattamento all'altezza del contenuto; stesso effetto ottenuto impostando MinHeight e MaxHeight sull'altezza del contenuto.

• WidthAndHeight. Adattamento alla larghezza e all'altezza del contenuto; stesso effetto ottenuto impostando MinHeight e MaxHeight sull'altezza del contenuto e MinWidth e MaxWidth sulla larghezza del contenuto.

Nel codice che segue viene illustrata una finestra le cui dimensioni si adattano automaticamente al contenuto, sia verticalmente che orizzontalmente, nel momento stesso in cui viene visualizzata.

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


...


</Window>

Ordine di precedenza per le proprietà di dimensione

Essenzialmente, le varie proprietà di dimensione di una finestra si combinano per definire l'intervallo di larghezza e di altezza di una finestra ridimensionabile. Per fare in modo che venga mantenuto un intervallo valido, Window valuta i valori delle proprietà di dimensione utilizzando i seguenti ordini di precedenza.

Per le proprietà di altezza:

1. FrameworkElement.MinHeight >

2. FrameworkElement.MaxHeight >

3. SizeToContent.Height/SizeToContent.WidthAndHeight >

4. FrameworkElement.Height

Per le proprietà di larghezza:

1. FrameworkElement.MinWidth >

2. FrameworkElement.MaxWidth >

3. SizeToContent.Width/SizeToContent.WidthAndHeight >

4. FrameworkElement.Width

L'ordine di precedenza può determinare anche le dimensioni di una finestra quando viene ingrandita. A tal proposito occorre gestire la proprietà WindowState.

Stato di una finestra

Nel corso della sua durata, una finestra ridimensionabile può avere tre stati: normale, ridotta a icona e ingrandita. Lo stato normale rappresenta lo stato predefinito di una finestra. Se una finestra si trova in questo stato, un utente ha la possibilità di spostarla e ridimensionarla utilizzando un controllo per il ridimensionamento oppure il bordo, se ridimensionabile.

Una finestra con uno stato ridotta a icona viene compressa nel relativo pulsante nella barra delle applicazioni nel caso in cui ShowInTaskbar sia impostata su true; in caso contrario, viene compressa nella dimensione minima possibile e collocata nell'angolo inferiore sinistro del desktop. Entrambi i tipi di finestra ridotta a icona non possono essere ridimensionati utilizzando un bordo o un controllo di ridimensionamento. Tuttavia, una finestra ridotta a icona che non sia visualizzata nella barra delle applicazioni può essere trascinata sul desktop.

Una finestra con uno stato ingrandita viene allargata fino a raggiungere le dimensioni massime, ovvero quelle determinate dalle proprietà MaxWidth, MaxHeight e SizeToContent. Come avviene per una finestra ridotta a icona, una finestra ingrandita non può essere ridimensionata utilizzando un controllo per il ridimensionamento né trascinando il bordo.

Nota
I valori delle proprietà Top, Left, Width e Height di una finestra rappresentano sempre i valori relativi allo stato normale, anche quando la finestra è ingrandita o ridotta.

Per configurare lo stato di una finestra occorre impostare la proprietà WindowState, che può assumere uno dei valori di enumerazione WindowState seguenti:

• Normal (impostazione predefinita)

• Maximized

• Minimized

Nell'esempio seguente viene illustrato come creare una finestra che, una volta aperta, viene visualizzata come ingrandita.

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


...


</Window>

In genere, WindowState viene impostata per configurare lo stato iniziale di una finestra. Una volta visualizzata una finestra ridimensionabile, gli utenti possono utilizzare i pulsanti Riduci a icona, Ingrandisci e Ripristina che si trovano nella barra del titolo per modificare lo stato della finestra.

Aspetto di una finestra

Per modificare l'aspetto dell'area client di una finestra, è possibile aggiungere contenuto specifico della stessa, ad esempio pulsanti, etichette e caselle di testo. Per configurare l'area non client, Window fornisce diverse proprietà, tra cui Icon per impostare l'icona di una finestra e Title per impostarne il titolo.

È anche possibile modificare l'aspetto e il comportamento del bordo dell'area non client configurando la modalità di ridimensionamento e lo stile di una finestra, nonché la possibilità che questa venga visualizzata come pulsante nella barra delle applicazioni sul desktop.

Nella presente sezione sono contenute le seguenti sottosezioni.

• Modalità di ridimensionamento
• Stile di una finestra
• Presenza nella barra delle applicazioni

Modalità di ridimensionamento

In base alla proprietà WindowStyle è possibile controllare la possibilità di ridimensionare la finestra nonché la modalità di ridimensionamento. La scelta dello stile influisce sul fatto che un utente possa o meno ridimensionare la finestra trascinando il bordo con il mouse, nonché sull'eventuale visualizzazione e abilitazione nell'area non client dei pulsanti Riduci a icona, Ingrandisci e Ridimensiona.

Per configurare la modalità di ridimensionamento di una finestra, è possibile impostare la proprietà ResizeMode, la quale può assumere uno dei valori di enumerazione ResizeMode seguenti:

• NoResize

• CanMinimize

• CanResize (impostazione predefinita)

• CanResizeWithGrip

Analogamente a WindowStyle, la modalità di ridimensionamento di una finestra non viene in genere modificata nel corso della sua durata, pertanto è molto probabile che venga impostata dal markup XAML.

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


...


</Window>

Per rilevare se una finestra è stata ingrandita, ridotta a icona o ripristinata, controllare la proprietà WindowState.

Stile di una finestra

Il bordo esposto dall'area non client di una finestra è adatto per la maggior parte delle applicazioni. In alcuni casi, tuttavia, è possibile che siano necessari tipi di bordi diversi oppure che non sia necessario alcun bordo, a seconda del tipo di finestra.

Per controllare il tipo di bordo di una finestra, impostare la proprietà WindowStyle con uno dei valori di enumerazione WindowStyle seguenti:

• None

• SingleBorderWindow (impostazione predefinita)

• ThreeDBorderWindow

• ToolWindow

Nella figura che segue viene illustrato l'effetto di questi stili della finestra.

WindowStyle può essere impostata tramite markup XAML o codice. Tuttavia, poiché non viene in genere modificata nel corso della durata di una finestra, è molto probabile che venga configurata tramite markup XAML.

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


...


</Window>

Stile non rettangolare di una finestra

In alcuni casi, gli stili del bordo applicabili con WindowStyle non sono sufficienti. Può accadere che si desideri creare un'applicazione con un bordo non rettangolare, come quello utilizzato da Microsoft Windows Media Player.

Si consideri ad esempio il fumetto illustrato nella figura che segue.

Questo tipo di finestra può essere creato impostando la proprietà WindowStyle su None e utilizzando il supporto speciale di Window per la trasparenza.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="None"
    AllowsTransparency="True"
    Background="Transparent">


...


</Window>

Grazie a questa combinazione di valori, la finestra apparirà completamente trasparente. In questo stato non è possibile utilizzare le aree di controllo dell'area non client della finestra, ovvero il menu Chiudi, i pulsanti Riduci a icona, Ingrandisci e Ripristina e così via. Sarà quindi necessario fornire aree di controllo personalizzate.

Presenza nella barra delle applicazioni

L'aspetto predefinito di una finestra include un pulsante nella barra delle applicazioni, come quello illustrato nella figura che segue.

Alcuni tipi di finestre non possiedono un pulsante nella barra delle applicazioni: è il caso delle finestre di messaggio e delle finestre di dialogo (vedere Cenni preliminari sulle finestre di dialogo). Per stabilire se il pulsante nella barra delle applicazioni debba essere visualizzato o meno, impostare la proprietà ShowInTaskbar. L'impostazione predefinita è true.

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


...


</Window>

Considerazioni sulla sicurezza

Per poter creare un'istanza di Window, è necessaria l'autorizzazione di sicurezza UnmanagedCode. Nel caso delle applicazioni installate e avviate dal computer locale, tale autorizzazione rientra nell'insieme di autorizzazioni concesse all'applicazione.

Al contrario, non è inclusa nell'insieme di autorizzazioni concesse alle applicazioni avviate dall'area Internet o intranet locale ClickOnce. In questo caso, gli utenti riceveranno un avviso di sicurezza ClickOnce e dovranno innalzare l'insieme di autorizzazioni dell'applicazione a un livello di attendibilità totale.

Per impostazione predefinita, inoltre, le applicazioni XBAPs non possono visualizzare né finestre né finestre di dialogo. Per alcune considerazioni sulla sicurezza delle applicazioni autonome, vedere Strategia di sicurezza di WPF - Sicurezza della piattaforma.

Altri tipi di finestre

NavigationWindow è una finestra progettata per ospitare contenuto esplorabile. Per ulteriori informazioni, vedere Cenni preliminari sulla navigazione.

Le finestre di dialogo vengono spesso utilizzate per raccogliere informazioni da un utente e completare una funzione. Si supponga ad esempio che un utente voglia aprire un file: la finestra di dialogo Apri file viene di norma visualizzata da un'applicazione per ottenere dall'utente il nome del file. Per ulteriori informazioni, vedere Cenni preliminari sulle finestre di dialogo.

Vedere anche

Riferimenti

Window

MessageBox

NavigationWindow

Application

Concetti

Cenni preliminari sulle finestre di dialogo

Compilazione di un'applicazione WPF (WPF)