.NET MAUI für Windows

Die Klasse .NET Multi-platform App UI (.NET MAUI) Window bietet die Möglichkeit, mehrere Fenster zu erstellen, zu konfigurieren, anzuzeigen und zu verwalten.

Window definiert die folgenden Eigenschaften:

• FlowDirection, vom Typ FlowDirection, definiert die Richtung, in der das UI-Element des Fensters angeordnet ist.
• Height, vom Typ double, gibt die Höhe des Fensters unter Windows an.
• MaximumHeight, vom Typ double, stellt die maximale Höhe des Fensters auf Desktopplattformen dar. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• MaximumWidth, vom Typ double, stellt die maximale Breite des Fensters auf Desktopplattformen dar. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• MinimumHeight, vom Typ double, stellt die Mindesthöhe des Fensters auf Desktopplattformen dar. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• MinimumWidth, vom Typ double, stellt die Mindestbreite des Fensters auf Desktopplattformen dar. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• Overlays, vom Typ IReadOnlyCollection<IWindowOverlay>, stellt die Auflistung von Fensterüberlagerungen dar.
• Page, vom Typ Page, gibt die Seite an, die vom Fenster angezeigt wird. Diese Eigenschaft ist die Inhaltseigenschaft der Klasse Window und muss daher nicht explizit festgelegt werden.
• Title, vom Typ string, stellt den Titel des Fensters dar.
• Width, vom Typ double, gibt die Breite des Fensters unter Windows an.
• X, vom Typ double, gibt die x-Koordinate des Fensters unter Windows an.
• Y, vom Typ double, gibt die y-Koordinate des Fensters unter Windows an.

Alle diese Eigenschaften, mit Ausnahme der Overlays-Eigenschaft, werden durch BindableProperty-Objekte gestützt, was bedeutet, dass die Eigenschaften Ziele von Datenverbindungen sein können.

Die Klasse Window definiert die folgenden Ereignisse:

• Created wird ausgelöst, wenn das Fenster erstellt wird.
• Resumed wird ausgelöst, wenn das Fenster aus einem Ruhezustand fortgesetzt wird.
• Activated wird ausgelöst, wenn das Fenster aktiviert wird.
• Deactivated wird ausgelöst, wenn das Fenster deaktiviert wird.
• Stopped wird ausgelöst, wenn das Fenster beendet wird.
• Destroying wird ausgelöst, wenn das Fenster zerstört wird.
• SizeChanged wird auf Desktopplattformen ausgelöst, wenn sich die Fenstergröße ändert.
• Backgrounding, mit einem begleitenden BackgroundingEventArgs-Objekt, das unter iOS und Mac Catalyst ausgelöst wird, wenn das Fenster geschlossen wird oder in einen Hintergrundzustand übergeht. Dieses Ereignis kann verwendet werden, um einen beliebigen string-Zustand in der State-Eigenschaft des BackgroundingEventArgs-Objekts zu erhalten, den das Betriebssystem beibehält, bis es Zeit ist, das Fenster wieder aufzunehmen. Wenn das Fenster wieder aufgenommen wird, wird der Status über das IActivationState-Argument der CreateWindow-Methode bereitgestellt.
• DisplayDensityChanged, mit einem begleitenden DisplayDensityChangedEventArgs-Objekt, das unter Android und Windows ausgelöst wird, wenn sich der effektive DPI-Wert (Dots per Inch) für das Fenster geändert hat.

Weitere Informationen über die Lebenszyklus-Ereignisse und ihre zugehörigen Überschreibungen finden Sie unter App-Lebenszyklus.

Die Window-Klasse definiert auch die folgenden modalen Navigationsereignisse:

• ModalPopped, mit ModalPoppedEventArgs, die ausgelöst wird, wenn eine Ansicht modal gepoppt wurde.
• ModalPopping, mit ModalPoppingEventArgs, die ausgelöst wird, wenn eine Ansicht modal gepoppt wurde.
• ModalPushed, mit ModalPushedEventArgs, die erhoben wird, nachdem eine Ansicht modal gepusht worden ist.
• ModalPushing, mit ModalPushingEventArgs, die ausgelöst wird, wenn eine Ansicht modal gepusht wird.
• PopCanceledwird ausgelöst, wenn ein modales Pop abgebrochen wird.

Die VisualElement-Klasse hat eine Window-Eigenschaft, die das übergeordnete Window-Objekt offenlegt. Auf diese Eigenschaft kann von jeder Seite, jedem Layout oder jeder Ansicht aus zugegriffen werden, um Window-Objekte zu manipulieren.

Erstellen eines Fensters

Standardmäßig erstellt .NET MAUI ein Window-Objekt, wenn Sie die MainPage-Eigenschaft auf ein Page-Objekt in Ihrer App-Klasse setzen. Sie können jedoch auch die CreateWindow-Methode in Ihrer App-Klasse überschreiben, um ein Window-Objekt zu erstellen:

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

Die Klasse Window hat einen Standardkonstruktor und einen Konstruktor, der ein Page-Argument akzeptiert, das die Stammseite der App darstellt. Sie können auch die Basismethode CreateWindow aufrufen, um das von .NET MAUI erstellte Window-Objekt zurückzugeben.

Darüber hinaus können Sie auch Ihr eigenes Window-abgeleitetes Objekt erstellen:

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

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

        // Override Window methods
    }
}

Die Window-abgeleitete Klasse kann dann durch Erstellen eines MyWindow-Objekts in der CreateWindow-Überschreibung in Ihrer App-Klasse verwendet werden.

Unabhängig davon, wie Ihr Window-Objekt erstellt wird, ist es das übergeordnete Objekt der Stammseite in Ihrer App.

Unterstützung für mehrere Fenster

Mehrere Fenster können auf Android, iOS auf iPad (iPadOS), Mac Catalyst und Windows gleichzeitig geöffnet werden. Dies kann erreicht werden, indem ein Window-Objekt erstellt und mithilfe der OpenWindow-Methode für das Application-Objekt geöffnet wird:

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

Die Application.Current.Windows-Sammlung vom Typ IReadOnlyList<Window> enthält Verweise auf alle Window-Objekte, die mit dem Application-Objekt registriert sind.

Application.Current?.ActivateWindow(secondWindow);

Windows kann mit der Application.Current.CloseWindow-Methode geschlossen werden:

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

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

Android-Konfiguration

Um die Unterstützung für mehrere Fenster unter Android zu nutzen, müssen Sie den MainActivity Startmodus in Plattformen > Android > MainActivity.cs von LaunchMode.SingleTop auf LaunchMode.Multiple ändern:

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

iPadOS- und macOS-Konfiguration

Um die Unterstützung für mehrere Fenster auf iPadOS und Mac Catalyst zu verwenden, fügen Sie eine Klasse mit dem Namen SceneDelegate zu den Ordnern Platforms > iOS und Platforms > MacCatalyst hinzu:

using Foundation;
using Microsoft.Maui;
using UIKit;

namespace MyMauiApp;

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

Öffnen Sie dann im XML-Editor die Datei Platforms > iOS > Info.plist und die Datei Platforms > MacCatalyst > Info.plist und fügen Sie die folgende XML-Datei am Ende jeder Datei hinzu:

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

Position und Größe eines Fensters

Die Position und Größe eines Fensters kann für eine .NET MAUI-App unter Windows programmatisch definiert werden, indem die Eigenschaften X, Y, Width und Height für ein Window-Objekt festgelegt werden.

Um beispielsweise die Fensterposition und -größe beim Start festzulegen, sollten Sie die Methode CreateWindow in Ihrer Klasse App außer Kraft setzen und die Eigenschaften X, Y, Width und Height auf ein Objekt Window setzen:

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

Alternativ kann ein Fenster durch Zugriff auf die Eigenschaft Window von jeder Seite, jedem Layout oder jeder Ansicht aus positioniert und in der Größe verändert werden. Der folgende Code zeigt beispielsweise, wie ein Fenster in der Mitte des Bildschirms positioniert wird:

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

Informationen zum Abrufen der Bildschirmmetriken des Geräts finden Sie unter Geräteanzeigeinformationen.

Mac Catalyst

Mac Catalyst unterstützt keine programmgesteuerte Größenänderung oder Neupositionierung von Fenstern. Um die Größenänderung zu ermöglichen, kann man jedoch die Eigenschaften MinimumWidth und MaximumWidth auf die gewünschte Breite des Fensters und die Eigenschaften MinimumHeight und MaximumHeight auf die gewünschte Höhe des Fensters setzen. Dadurch wird eine Größenänderung ausgelöst, und Sie können dann die Eigenschaften zurück zu ihren ursprünglichen Werten rückgängig machen:

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

Entkoppeln der Fensterverwaltung von der App-Klasse

Die Fensterverwaltung kann von der App-Klasse entkoppelt werden, indem eine Klasse erstellt wird, die die IWindowCreator-Schnittstelle implementiert, und der Code für die Fensterverwaltung in der CreateWindow-Methode hinzugefügt wird:

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

Dann sollten Sie in der Klasse MauiProgram Ihren Fenstermanagement-Typ als Abhängigkeit im Service-Container der App registrieren:

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

Stellen Sie dann sicher, dass Ihre App-Klasse die MainPage-Eigenschaft nicht festgelegt hat:

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

Unter der Voraussetzung, dass die IWindowCreator-Schnittstelle und ihr konkreter Typ im Service-Container der App registriert wurden und dass die MainPage-Eigenschaft der Application-Klasse nicht gesetzt ist, wird Ihr registrierter Typ verwendet, um den Window zu erstellen.