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 .
• DisplayDensityChanged, 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

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

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

        protected override Window CreateWindow(IActivationState? activationState)
        {
            return new Window(new AppShell());
        }
    }
}

La Window classe ha un costruttore predefinito e un costruttore che accetta un Page argomento, che rappresenta la pagina radice dell'app.

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 .

Application.Current?.ActivateWindow(secondWindow);

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());

Configurazione di Android

Per usare il supporto a più finestre in Android, è necessario modificare la MainActivity modalità di avvio in Piattaforme > Android > MainActivity.cs da LaunchMode.SingleTop a LaunchMode.Multiple:

using Android.App;
using Android.Content.PM;
using Android.OS;

namespace MyMauiApp;

[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, LaunchMode = LaunchMode.Multiple, ...)]
public class MainActivity : MauiAppCompatActivity
{
}

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>

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 .

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>();

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.