Översikt över fönster för WinUI och Windows App SDK

Fönsterfunktioner i en WinUI-app tillhandahålls av en kombination av XAML-klassen Window och AppWindow klassen, som båda baseras på Win32 HWND-modellen.

WinUI 3-galleriappen innehåller interaktiva exempel på de flesta WinUI 3-kontroller, funktioner och funktioner. Hämta appen från Microsoft Store eller hämta källkoden på GitHub

XAML Window

I din app är fönsterobjektet en instans av klassen Microsoft.UI.Xaml.Window (eller en härledd klass) som representerar fönstret i programkoden. Du skapar den direkt med ett anrop till konstruktorn. I XAML Window bifogar du appens innehåll och hanterar livscykeln för appens fönster.

HWND

Programfönstret skapas av Windows operativsystemet och representeras av ett Win32-fönsterobjekt. Det är en systemhanterad container där innehållet finns och representerar den entitet som användarna interagerar med när de ändrar storlek på och flyttar appen på skärmen. (Mer information finns i Om Windows i Win32-dokumentationen.)

Efter att Windows har skapat programfönstret returnerar skapandefunktionen en window handle (HWND) som unikt identifierar fönstret. A window handle har HWND-datatypen, även om den visas i C# som en IntPtr. Det är ett ogenomskinligt handtag till en intern Windows datastruktur som motsvarar ett fönster som ritas upp av operativsystemet och förbrukar systemresurser när det finns.

HWND skapas efter XAML-objektet Window , vanligtvis när Window. Metoden Aktivera anropas.

AppWindow

Windows App SDK tillhandahåller ytterligare fönsterfunktioner via klassen Microsoft.UI.Windowing.AppWindow AppWindow representerar en abstraktion på hög nivå av HWND. Det finns en 1:1-mappning mellan en AppWindow och en HWND på toppnivå i din app. AppWindow och dess relaterade klasser tillhandahåller API:er som gör att du kan hantera många aspekter av appens toppnivåfönster utan att behöva komma åt HWND direkt.

Livslängden för ett AppWindow objekt och en HWND är densamma – den AppWindow är tillgänglig direkt efter att fönstret har skapats och det förstörs när fönstret stängs.

Api-diagram för fönster

Det här diagrammet visar relationen mellan de klasser och API:er som du använder för att hantera fönster i din app och vilka klasser som ansvarar för varje del av fönsterhanteringen. I vissa fall, till exempel ExtendsContentIntoTitleBar, är API:et medlem i AppWindow för att göra det tillgängligt för andra gränssnittsramverk, men exponeras också för klassen för enkelhetens Window skull. Diagrammet är inte omfattande, men visar de vanligaste API:erna.

Window/AppWindow API-jämförelse

Om du använder WinUI 3 XAML som appens gränssnittsramverk är både API:erna WindowAppWindow och tillgängliga för dig. Windows Från och med App SDK 1.4 kan du använda Windowegenskapen .AppWindow för att hämta ett AppWindow objekt från ett befintligt XAML-fönster. Med det här AppWindow objektet har du åtkomst till ytterligare API:er för fönsterhantering.

Livslängdshantering

När du skapar ett nytt WinUI-projekt i Visual Studio tillhandahåller projektmallen en MainWindow klass åt dig, som är en underklass till Window. Om din app bara behöver ett fönster är det allt du behöver. Mer information om hur du skapar och hanterar ytterligare fönster och varför du kanske vill kan du läsa Visa flera fönster för din app.

Klassen AppWindow har API:er för att skapa och förstöra ett nytt fönster. Men för en WinUI-app gör du inte detta i praktiken eftersom det inte finns något API för att koppla innehåll till fönstret som du skapar. I stället får du en instans av AppWindow som skapas av systemet och som är associerad med XAML Window och HWND. I WinUI 1.4 och senare kan du använda Windowegenskapen .AppWindow för att hämta instansen av AppWindow. I andra fall kan du använda den statiska AppWindow. GetFromWindowId-metoden för att hämta instansen AppWindow . Mer information finns i Hantera appfönster .

Content

.Window Innehållsegenskapen är den platsen där du bifogar appinnehållet till fönstret som visar det. Du kan göra detta i XAML eller i kod.

Rubrik, ikon och namnlist

Du kan ändra appens namnlist i varierande grad. ange rubrik och ikon, ändra färgerna eller helt ersätta namnlisten med anpassat appinnehåll.

Information om hur du använder API:er för namnlist, inklusive kodexempel, finns i Anpassning av namnlist.

Storlek och position

Du använder Window. Bounds-egenskapen och SizeChanged-händelsen för att hantera saker i appens användargränssnitt, till exempel flytta runt element när fönsterstorleken ändras. XAML använder effective pixels (epx), inte faktiska fysiska pixlar. Effective pixels är en virtuell måttenhet och används för att uttrycka layoutdimensioner och avstånd, oberoende av skärmdensitet.

AppWindowanvänder å andra sidan Window koordinatsystemet, där den grundläggande måttenheten är fysiska enhetspixlar. Du använder API:erna AppWindow för fönsteråtgärder, till exempel ändra storlek på fönstret eller flytta det i förhållande till något annat på skärmen.

I vissa fall kan du behöva använda mått från en klass i den andra klassen, och då behöver du konvertera mellan enhetspixlar och effective pixels bildpunkter. Om du till exempel definierar draområden i en anpassad titelrad måste du konvertera mått. Ett exempel på hur du använder XamlRoot.RasterizationScale för att konvertera mått finns i avsnittet interaktivt innehåll i artikeln Om anpassning av namnlist .

Utseende och beteende

XAML-API Window :er ansvarar vanligtvis för utseendet på ditt appinnehåll, till exempel bakgrunden. För mer information om SystemBackdrop, se Tillämpa glimmer- eller akrylmaterial.

AppWindow API:er ansvarar för icke-klientdelen av fönstret och appens interaktion med Windows operativsystemet.

Spåra det aktuella fönstret

Även om egenskapen Current inte stöds i WinUI-appar kan du fortfarande behöva komma åt API:erna Window från andra platser i appen. Du kan till exempel behöva hämta Window gränserna eller hantera Window.SizeChanged-händelse från kod för en Page. I det här fallet kan du ge åtkomst till Window på ett liknande sätt som Current egenskapen med hjälp av en offentlig statisk egenskap i klassen App .

Det gör du genom att ändra deklarationen Window i klassen App enligt nedan.

// App.xaml.cs in a WinUI app
public partial class App : Application
{
    ...
    public static Window Window { get { return m_window; } }
    private static Window m_window;
}

// App.xaml.h in a WinUI app
...
struct App : AppT<App>
{
    ...
    static winrt::Microsoft::UI::Xaml::Window Window(){ return window; };

private:
    static winrt::Microsoft::UI::Xaml::Window window;
};
...

// App.xaml.cpp
...
winrt::Microsoft::UI::Xaml::Window App::window{ nullptr };
...

Om du sedan vill komma åt Window från andra platser i din app använder du App.Window, så här:

// MainPage.xaml.cs in a WinUI app
var width = App.Window.Bounds.Width;

// MainPage.xaml.cpp in a WinUI app
#include <App.xaml.h>
auto width{ App::Window().Bounds().Width };

Relaterade ämnen

• Hantera appfönster
• Migrering av fönsterfunktionalitet
• Anropa interop-API:er från en .NET-app
• Hämta en window handle (HWND)
• exempel på fönstergalleri