Finestre MAUI .NET

La classe .NET Multi-platform App UI (.NET MAUI) Window consente di creare, configurare, visualizzare e gestire più finestre.

Window definisce le proprietà seguenti:

• FlowDirection, di tipo FlowDirection, definisce la direzione in cui viene disposto l'elemento dell'interfaccia utente della finestra.
• Height, di tipo double, specifica l'altezza della finestra in Windows.
• MaximumHeight, di tipo double, rappresenta l'altezza massima della finestra nelle piattaforme desktop. I valori validi sono compresi tra 0 e double.PositiveInfinity.
• MaximumWidth, di tipo double, rappresenta la larghezza massima della finestra nelle piattaforme desktop. I valori validi sono compresi tra 0 e double.PositiveInfinity.
• MinimumHeight, di tipo double, rappresenta l'altezza minima della finestra nelle piattaforme desktop. I valori validi sono compresi tra 0 e double.PositiveInfinity.
• MinimumWidth, di tipo double, rappresenta la larghezza minima della finestra nelle piattaforme desktop. I valori validi sono compresi tra 0 e double.PositiveInfinity.
• Overlays, di tipo IReadOnlyCollection<IWindowOverlay>, rappresenta la raccolta di sovrapposizioni di finestre.
• Page, di tipo Page, indica la pagina visualizzata dalla finestra. Questa proprietà è la proprietà content della Window classe e pertanto non deve essere impostata in modo esplicito.
• Title, di tipo string, rappresenta il titolo della finestra.
• Width, di tipo double, specifica la larghezza della finestra in Windows.
• X, di tipo double, specifica la coordinata X della finestra in Windows.
• Y, di tipo double, specifica la coordinata Y della finestra in Windows.

Queste proprietà, ad eccezione della Overlays proprietà , sono supportate da BindableProperty oggetti , il che significa che possono essere destinazioni di data binding e stili.

La Window classe definisce gli eventi seguenti:

• Created, generato al momento della creazione della finestra.
• Resumed, generato quando la finestra viene ripresa da uno stato di sospensione.
• Activated, generato quando la finestra viene attivata.
• Deactivated, generato quando la finestra viene disattivata.
• Stopped, generato quando la finestra viene arrestata.
• Destroying, generato quando la finestra viene eliminata definitivamente.
• SizeChanged, che viene generato sulle piattaforme desktop quando la finestra cambia dimensione.
• Backgrounding, con un oggetto associato BackgroundingEventArgs , che viene generato in iOS e Mac Catalyst quando la finestra viene chiusa o entra in uno stato di sfondo. Questo evento può essere usato per salvare in modo permanente qualsiasi string stato alla State proprietà dell'oggetto BackgroundingEventArgs , che il sistema operativo manterrà fino a quando non è il momento di riprendere la finestra. Quando la finestra viene ripresa, lo stato viene fornito tramite l'argomento IActivationState al CreateWindow metodo .
• <xref:Microsoft.Maui.Controls.WindowDisplayDensityChanged, con un oggetto associato DisplayDensityChangedEventArgs , che viene generato in Android e Windows quando i punti effettivi per pollice (DPI) per la finestra sono cambiati.

Per altre informazioni sugli eventi del ciclo di vita e sulle sostituzioni associate, vedere Ciclo di vita dell'app.

La Window classe definisce anche gli eventi di spostamento modali seguenti:

• ModalPopped, con ModalPoppedEventArgs, che viene generato quando una vista è stata estratta modally.
• ModalPopping, con ModalPoppingEventArgs, che viene generato quando una vista viene estratta modally.
• ModalPushed, con ModalPushedEventArgs, che viene generato dopo che è stato eseguito il push di una visualizzazione in modalità modally.
• ModalPushing, con ModalPushingEventArgs, che viene generato quando viene eseguito il push di una visualizzazione in modalità modally.
• PopCanceled, generato quando un pop modale viene annullato.

La VisualElement classe ha una Window proprietà che espone l'oggetto padre Window . È possibile accedere a questa proprietà da qualsiasi pagina, layout o visualizzazione per modificare Window gli oggetti.

Creare una finestra

Per impostazione predefinita, .NET MAUI crea un Window oggetto quando si imposta la MainPage proprietà su un Page oggetto nella App classe . Tuttavia, è anche possibile eseguire l'override del CreateWindow metodo nella App classe per creare un Window oggetto :

namespace MyMauiApp
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new MainPage();
        }

        protected override Window CreateWindow(IActivationState activationState)
        {
            Window window = base.CreateWindow(activationState);

            // Manipulate Window object

            return window;
        }
    }
}

Mentre la Window classe ha un costruttore predefinito e un costruttore che accetta un Page argomento, che rappresenta la pagina radice dell'app, è anche possibile chiamare il metodo di base CreateWindow per restituire l'oggetto maUI creato Window da .NET.

Inoltre, è anche possibile creare il proprio Windowoggetto derivato da :

namespace MyMauiApp
{
    public class MyWindow : Window
    {
        public MyWindow() : base()
        {
        }

        public MyWindow(Page page) : base(page)
        {
        }

        // Override Window methods
    }
}

La Windowclasse derivata da può quindi essere utilizzata creando un MyWindow oggetto nell'override CreateWindow nella App classe .

Indipendentemente dalla modalità Window di creazione dell'oggetto, sarà l'elemento padre della pagina radice nell'app.

Supporto per più finestre

È possibile aprire più finestre contemporaneamente in Android, iOS in iPad (iPadOS), Mac Catalyst e Windows. A tale scopo, è possibile creare un Window oggetto e aprirlo usando il OpenWindow metodo sull'oggetto Application :

Window secondWindow = new Window(new MyPage());
Application.Current.OpenWindow(secondWindow);

L'insieme Application.Current.Windows , di tipo IReadOnlyList<Window> mantiene riferimenti a tutti gli Window oggetti registrati con l'oggetto Application .

Windows può essere chiuso con il Application.Current.CloseWindow metodo :

// Close a specific window
Application.Current.CloseWindow(secondWindow);

// Close the active window
Application.Current.CloseWindow(GetParentWindow());

Importante

Il supporto multi-finestra funziona in Android e Windows senza configurazione aggiuntiva. Tuttavia, è necessaria una configurazione aggiuntiva in iPadOS e Mac Catalyst.

Configurazione di iPadOS e macOS

Per usare il supporto multi-finestra in iPadOS e Mac Catalyst, aggiungere una classe denominata SceneDelegate alle cartelle Platforms iOS e Platforms >> MacCatalyst:

using Foundation;
using Microsoft.Maui;
using UIKit;

namespace MyMauiApp;

[Register("SceneDelegate")]
public class SceneDelegate : MauiUISceneDelegate
{
}

Nell'editor XML aprire quindi il file Platforms > iOS > Info.plist e il file Platforms > MacCatalyst > Info.plist e aggiungere il codice XML seguente alla fine di ogni file:

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <true/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>__MAUI_DEFAULT_SCENE_CONFIGURATION__</string>
        <key>UISceneDelegateClassName</key>
        <string>SceneDelegate</string>
      </dict>
    </array>
  </dict>
</dict>

Importante

Il supporto multi-finestra non funziona in iOS per i Telefono.

Posizionare e ridimensionare una finestra

La posizione e le dimensioni di una finestra possono essere definite a livello di codice per un'app MAUI .NET in Windows impostando le Xproprietà , YWidth, e Height in un Window oggetto .

Avviso

Mac Catalyst non supporta il ridimensionamento o il riposizionamento delle finestre a livello di codice impostando le Xproprietà , YWidth, e Height .

Ad esempio, per impostare la posizione e le dimensioni della finestra all'avvio, è necessario eseguire l'override del CreateWindow metodo nella App classe e impostare le Xproprietà , WidthY, e Height in un Window oggetto :

public partial class App : Application
{
    public App()
    {
        InitializeComponent();
    }

    protected override Window CreateWindow(IActivationState activationState) =>
        new Window(new AppShell())
        {
            Width = 700,
            Height = 500,
            X = 100,
            Y = 100
        };
}

In alternativa, una finestra può essere posizionata e ridimensionata accedendo alla Window proprietà da qualsiasi pagina, layout o visualizzazione. Ad esempio, il codice seguente mostra come posizionare una finestra al centro dello schermo:

// Get display size
var displayInfo = DeviceDisplay.Current.MainDisplayInfo;

// Center the window
Window.X = (displayInfo.Width / displayInfo.Density - Window.Width) / 2;
Window.Y = (displayInfo.Height / displayInfo.Density - Window.Height) / 2;

Per informazioni su come ottenere le metriche dello schermo del dispositivo, vedere Informazioni sulla visualizzazione del dispositivo.

Mac Catalyst

Mac Catalyst non supporta il ridimensionamento o il riposizionamento delle finestre a livello di codice. Tuttavia, una soluzione alternativa per abilitare il ridimensionamento consiste nell'impostare le MinimumWidth proprietà e MaximumWidth sulla larghezza desiderata della finestra e sulle MinimumHeight proprietà e MaximumHeight sull'altezza desiderata della finestra. Verrà attivato un ridimensionamento e sarà quindi possibile ripristinare i valori originali delle proprietà:

Window.MinimumWidth = 700;
Window.MaximumWidth = 700;
Window.MinimumHeight = 500;
Window.MaximumHeight = 500;

// Give the Window time to resize
Dispatcher.Dispatch(() =>
{
    Window.MinimumWidth = 0;
    Window.MinimumHeight = 0;
    Window.MaximumWidth = double.PositiveInfinity;
    Window.MaximumHeight = double.PositiveInfinity;
});

Separare la gestione delle finestre dalla classe App

La gestione delle finestre può essere disaccoppiata dalla App classe creando una classe che implementa l'interfaccia IWindowCreator e aggiungendo il codice di gestione delle finestre nel CreateWindow metodo :

public class WindowCreator : IWindowCreator
{
    public Window CreateWindow(Application app, IActivationState activationState)
    {
        var window = new Window(new ContentPage
        {
            Content = new Grid
            {
                new Label
                {
                    Text = "Hello from IWindowCreator",
                    HorizontalOptions = LayoutOptions.Center,
                    VerticalOptions = LayoutOptions.Center
                }
            }
        });

        return window;
    }
}

Quindi, nella MauiProgram classe è necessario registrare il tipo di gestione delle finestre come dipendenza nel contenitore del servizio dell'app:

builder.Services.AddSingleton<IWindowCreator, WindowCreator>();

Importante

Assicurarsi che il codice di registrazione specifichi l'interfaccia IWindowCreator e il relativo tipo concreto.

Assicurarsi quindi che la App classe non imposti la MainPage proprietà :

public partial class App : Application
{
    public App()
    {
        InitializeComponent();
    }
}

A condizione che l'interfaccia IWindowCreator e il relativo tipo concreto siano stati registrati nel contenitore del servizio dell'app e che la MainPage proprietà della Application classe non sia impostata, il tipo registrato verrà usato per creare l'oggetto Window.