.NET MAUI-Fenster

Die .NET Multi-Platform App UI (.NET MAUI)Window-Klasse 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, gibt die maximale Höhe des Fensters auf Desktop-Plattformen an. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• MaximumWidth, vom Typ double, gibt die maximale Breite des Fensters auf Desktop-Plattformen an. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• MinimumHeight, vom Typ double, gibt die Mindesthöhe des Fensters auf Desktop-Plattformen an. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• MinimumWidth, vom Typ double, gibt die Mindestbreite des Fensters auf Desktop-Plattformen an. Gültige Werte liegen zwischen 0 und double.PositiveInfinity.
• Overlays, vom Typ IReadOnlyCollection<IWindowOverlay>, gibt die Auflistung von Fensterüberlagerungen an.
• 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, gibt den Titel des Fensters an.
• 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.

Mit Ausnahme der Overlays-Eigenschaft, werden diese Eigenschaften durch BindableProperty-Objekte gestützt, was bedeutet, dass sie Ziele von Datenverbindungen sein und gestaltet werden können.

Die Window-Klasse definiert die folgenden Ereignisse:

• Created wird ausgelöst, wenn das Fenster erstellt wird.
• Resumed wird ausgelöst, wenn das Fenster aus dem 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 gelöscht wird.
• SizeChanged wird auf Desktop-Plattformen ausgelöst, wenn sich die Fenstergröße ändert.
• Backgrounding, mit einem begleitenden BackgroundingEventArgs-Objekt, wird auf iOS und Mac Catalyst ausgelöst, wenn das Fenster geschlossen wird oder in einen Hintergrundzustand wechselt. Dieses Ereignis kann verwendet werden, um jeden string-Zustand für die State-Eigenschaft des BackgroundingEventArgs-Objekts beizubehalten, der vom Betriebssystem bis zum Fortsetzen des Fensters beibehalten wird. Wenn das Fenster fortgesetzt wird, wird der Zustand über das IActivationState-Argument für die CreateWindow-Methode bereitgestellt.
• <xref:Microsoft.Maui.Controls.WindowDisplayDensityChanged, mit einem zugehörigen DisplayDensityChangedEventArgs-Objekt, das unter Android und Windows ausgelöst wird, wenn sich die effektiven Punkte pro Zoll (DPI) für das Fenster geändert haben.

Weitere Informationen zu den Lebenszyklusereignissen und den zugehörigen Außerkraftsetzungen finden Sie unter App-Lebenszyklus.

Die Window-Klasse definiert auch die folgenden modalen Navigationsereignisse:

• ModalPopped, mit ModalPoppedEventArgs, wird ausgelöst, wenn eine Ansicht modal gepoppt wurde.
• ModalPopping, mit ModalPoppingEventArgs, wird ausgelöst, wenn eine Ansicht modal gepoppt wird.
• ModalPushed, mit ModalPushedEventArgs, wird ausgelöst, wenn eine Ansicht modal gepusht wurde.
• ModalPushing, mit ModalPushingEventArgs, wird ausgelöst, wenn eine Ansicht modal gepusht wird.
• PopCanceled wird ausgelöst, wenn ein modaler Pop abgebrochen wird.

Die VisualElement-Klasse verfügt über eine Window-Eigenschaft, die das übergeordnete Window-Objekt verfügbar macht. Auf diese Eigenschaft kann von jeder Seite, jedem Layout oder jeder Ansicht aus zugegriffen werden, um Window-Objekte zu bearbeiten.

Fenster erstellen

Standardmäßig erstellt .NET MAUI ein Window-Objekt, wenn Sie die MainPage-Eigenschaft auf ein Page-Objekt in Ihrer App-Klasse festlegen. Sie können die CreateWindow-Methode in Ihrer App-Klasse jedoch auch ü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;
        }
    }
}

Während die Window-Klasse über einen Standardkonstruktor und einen Konstruktor verfügt, der ein Page-Argument akzeptiert, das die Stammseite der App darstellt, können Sie auch die Basismethode CreateWindow aufrufen, um das erstellte .NET MAUI Window-Objekt zurückzugeben.

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

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

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

        // Override Window methods
    }
}

Die von Window abgeleitete Klasse kann dann genutzt werden, indem ein MyWindow-Objekt in der CreateWindow-Außerkraftsetzung in Ihrer App-Klasse erstellt wird.

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

Unterstützung für mehrere Fenster

Unter Android, iOS auf iPad (iPadOS), Mac Catalyst und Windows können mehrere Fenster 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-Auflistung vom Typ IReadOnlyList<Window> verwaltet Verweise auf alle Window-Objekte, die beim Application-Objekt registriert sind.

Fenster können mit der Application.Current.CloseWindow-Methode geschlossen werden:

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

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

Wichtig

Die Unterstützung für mehrere Fenster funktioniert unter Android und Windows ohne zusätzliche Konfiguration. Unter iPadOS und Mac Catalyst ist jedoch eine zusätzliche Konfiguration erforderlich.

iPadOS- und macOS-Konfiguration

Um die Unterstützung für mehrere Fenster unter 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 Platforms > MacCatalyst > Info.plist und fügen Sie am Ende jeder Datei die folgende XML 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>

Wichtig

Die Unterstützung für mehrere Fenster funktioniert unter iOS für iPhone nicht.

Position und Größe eines Fensters definieren

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

Warnung

Mac Catalyst unterstützt keine programmgesteuerte Größenänderung oder Neupositionierung von Fenstern, indem die Eigenschaften X, Y, Width und Height festgelegt werden.

Wenn Sie beispielsweise die Fensterposition und -größe beim Start festlegen möchten, sollten Sie die CreateWindow-Methode in Ihrer App-Klasse überschreiben und die Eigenschaften X, Y, Width und Height für ein Window-Objekt festlegen:

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 können Position und Größe eines Fensters definiert werden, indem von einer beliebigen Seite, einem beliebigen Layout oder einer Beliebigen Ansicht aus auf die Window-Eigenschaft zugegriffen wird. 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. Eine Problemumgehung zur Aktivierung der Größenänderung ist, 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 festzulegen. Dadurch wird eine Größenänderung ausgelöst, wonach Sie die Eigenschaften auf ihre ursprünglichen Werten zurücksetzen können:

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 sie eine Klasse erstellen, die die IWindowCreator-Schnittstelle implementiert, und den Fensterverwaltungscode in der CreateWindow-Methode hinzufügen:

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

Anschließend sollten Sie in der MauiProgram-Klasse Ihren Fensterverwaltungstyp als Abhängigkeit im Dienstcontainer der App registrieren:

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

Wichtig

Stellen Sie sicher, dass Ihr Registrierungscode die IWindowCreator-Schnittstelle sowie den konkreten Typ angibt.

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

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

Sofern die IWindowCreator-Schnittstelle und ihr konkreter Typ beim Dienstcontainer der App registriert wurden und die MainPage-Eigenschaft der Application-Klasse nicht festgelegt ist, wird Ihr registrierter Typ verwendet, um Window zu erstellen.