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, 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 Window Klasse 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.

Diese Eigenschaften, mit Ausnahme der Overlays Eigenschaft, werden von BindableProperty Objekten unterstützt, was bedeutet, dass sie Ziele von Datenbindungen sein können und formatiert werden können.

Die Window Klasse definiert die folgenden Ereignisse:

  • Created wird ausgelöst, wenn das Fenster erstellt wird.
  • Resumed wird erzeugt, wenn der Ruhezustand des Fensters beendet wird.
  • Activated wird ausgelöst, wenn das Fenster aktiviert wird.
  • Deactivated, wird ausgelöst, wenn das Fenster deaktiviert wird.
  • Stoppedwird ausgelöst, wenn das Fenster gestoppt wird.
  • Destroying, das ausgelöst wird, wenn das Fenster zerstört wird.
  • SizeChanged wird auf den Desktop-Plattformen ausgelöst, wenn sich die Größe eines Fensters ändert.
  • Backgrounding, mit einem begleitenden BackgroundingEventArgs Objekt, das auf iOS und Mac Catalyst ausgelöst wird, wenn das Fenster geschlossen oder in einen Hintergrundzustand wechselt. Dieses Ereignis kann verwendet werden, um jeden string Zustand für die State Eigenschaft des BackgroundingEventArgs Objekts beizubehalten, die vom Betriebssystem bis zum Fortsetzen des Fensters beibehalten wird. Wenn das Fenster fortgesetzt wird, wird der Zustand über das IActivationState Argument an die CreateWindow Methode bereitgestellt.
  • DisplayDensityChangedmit 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, die ausgelöst wird, wenn eine Ansicht modal geschlossen wurde.
  • ModalPopping, mit ModalPoppingEventArgs, wird ausgelöst, wenn eine Ansicht modal geschlossen wird.
  • ModalPushed, mit ModalPushedEventArgs, die ausgelöst wird, nachdem eine Ansicht modal verschoben wurde.
  • ModalPushing, mit ModalPushingEventArgs, die ausgelöst wird, wenn eine Ansicht modal verschoben wird.
  • PopCanceled wird ausgelöst, wenn ein modaler Dialog 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 beliebigen Seite, einem beliebigen 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 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 Window .NET MAUI-Objekt zurückzugeben.

Standardmäßig setzt Ihre .NET MAUI-App die CreateWindow Methode in Ihrer App Klasse außer Kraft, um ein Window Objekt zu erstellen:

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

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

Die Window Klasse verfügt über einen Standardkonstruktor und einen Konstruktor, der ein Page Argument akzeptiert, das die Stammseite der App darstellt.

Darüber hinaus können Sie auch ein eigenes Windowabgeleitetes Objekt erstellen:

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

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

        // Override Window methods
    }
}

Die abgeleitete Klasse von Window kann dann verwendet werden, indem ein MyWindow Objekt in der CreateWindow Überschreibung in Ihrer App Klasse erstellt wird.

Unabhängig davon, wie Das Window Objekt erstellt wird, ist es das übergeordnete Element 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 Auflistung des Typs IReadOnlyList<Window> verwaltet Verweise auf alle Window Objekte, die mit dem Application Objekt registriert sind.

Ein bestimmtes Fenster kann mit der Application.Current.ActivateWindow Methode auf Mac Catalyst und Windows in den Vordergrund gebracht werden:

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

Von Bedeutung

Die Mehrfensterunterstützung funktioniert unter Windows ohne zusätzliche Konfiguration. Für Android, iPadOS und Mac Catalyst ist jedoch eine zusätzliche Konfiguration erforderlich.

Android-Konfiguration

Um die Unterstützung für mehrere Fenster unter Android zu verwenden, müssen Sie den MainActivity Startmodus in dem Platforms > 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 unter iPadOS und Mac Catalyst zu verwenden, fügen Sie eine Klasse mit dem Namen SceneDelegate"Plattformen > iOS " und "Plattformen > 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 am Ende jeder Datei die folgende XML-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>

Von Bedeutung

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

Positionieren und Ändern der Größe eines Fensters

Die Position und Größe eines Fensters kann programmgesteuert für eine .NET MAUI-App unter Windows 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 X, Y, Width und Height Eigenschaften festgelegt werden.

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

Wenn Sie beispielsweise die Fensterposition und die Größe beim Start festlegen möchten, sollten Sie die CreateWindow Methode in Ihrer App Klasse überschreiben und die XEigenschaften , Y, und WidthHeightEigenschaften 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, kann ein Fenster positioniert und angepasst werden, indem auf die Window Eigenschaft von einer beliebigen Seite, einem beliebigen Layout oder einer beliebigen Ansicht aus 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 zum Aktivieren der Größenänderung ist jedoch das Festlegen der MinimumWidth Eigenschaften MaximumWidth auf die gewünschte Breite des Fensters und die MinimumHeight Eigenschaften MaximumHeight auf die gewünschte Höhe des Fensters. Dadurch wird eine Größenänderung ausgelöst, und Sie können die Eigenschaften dann wieder auf ihre ursprünglichen Werte zurücksetzen:

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

Von Bedeutung

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 festgelegt hat:

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

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

Aktivieren oder Deaktivieren von Schaltflächen zum Minimieren und Maximieren von Schaltflächen unter Windows

Unter Windows können Sie die Schaltflächen "Minimieren" und "Maximieren" in einem Fenster aktivieren oder deaktivieren. Dies kann erreicht werden, indem das zugrunde liegende WinUI-Fenster abgerufen und seine Referenteneigenschaften angepasst werden.

Im folgenden Beispiel werden sowohl die Schaltflächen "Minimieren" als auch "Maximieren" deaktiviert:

#if WINDOWS
using Microsoft.Maui.Platform; // MauiWinUIWindow
using Microsoft.UI.Windowing;  // AppWindow, OverlappedPresenter

public static void ConfigureWindowButtons(Window window)
{
    var nativeWindow = (MauiWinUIWindow)window.Handler.PlatformView;
    var appWindow = nativeWindow.AppWindow;

    if (appWindow.Presenter is OverlappedPresenter presenter)
    {
        presenter.IsMinimizable = false;
        presenter.IsMaximizable = false;
    }
}
#endif

Rufen Sie ConfigureWindowButtons während des App-Starts auf (z. B. nach dem Erstellen des Window in CreateWindow) oder beim Anzeigen eines sekundären Fensters.

Hinweis

Diese Eigenschaften gelten nur für Windows-Desktops. Andere Plattformen ignorieren diesen Codepfad. Um Schaltflächen erneut zu aktivieren, setzen Sie IsMinimizable und IsMaximizable wieder auf true.

  • Last updated on