Window Window Window Window Class


Represents an application window.

public : sealed class Window : IWindow, IWindow2, IWindow3
struct winrt::Windows::UI::Xaml::Window : IWindow, IWindow2, IWindow3
public sealed class Window : IWindow, IWindow2, IWindow3
Public NotInheritable Class Window Implements IWindow, IWindow2, IWindow3
Windows 10 requirements
Device family
Windows 10 (introduced v10.0.10240.0)
API contract
Windows.Foundation.UniversalApiContract (introduced v1)


The following code example shows the OnLaunched method override generated for the blank application template in Microsoft Visual Studio. This code demonstrates typical usage patterns for the Current and Content properties and the Activate method.

protected override void OnLaunched(LaunchActivatedEventArgs args)
    // Create a Frame to act navigation context and navigate to the first page
    var rootFrame = new Frame();

    // Place the frame in the current Window and ensure that it is active
    Window.Current.Content = rootFrame;
Protected Overrides Sub OnLaunched(args As 

    ' Create a Frame to act navigation context and navigate to the first page
    Dim rootFrame As New Frame()

    ' Place the frame in the current Window and ensure that it is active
    Window.Current.Content = rootFrame
End Sub


This class represents the window of the current Application. In the same manner as the static Application property, the static Current property will return the app window object. From this object, an app can utilize the Dispatcher or determine the size of the Window from the Bounds property. The most common usage for Window is setting a UIElement to the Content that represents the app UI. This is usually done as part of app activation (for example in the OnLaunched override.) You can change this window content throughout the lifetime of the window.

There is no XAML representation of the Window class because it is not a control.

A Window object is just surfacing information from CoreWindow, which in turn is referencing the window created by the system.

Make sure to call Activate on any Window you use on initial activation. If you use the default app templates from Microsoft Visual Studio, calling Window.Activate is part of the initial code in the app.xaml code-behind file.

The LayoutAwarePage class that is part of some application templates in Microsoft Visual Studio has handling for the SizeChanged event, which is used for keeping track of visual states that match values of ApplicationViewState. LayoutAwarePage also has code that checks Bounds and uses this value to influence how page-wide input events are handled.


Bounds Bounds Bounds Bounds

Gets a Rect value containing the height and width of the application window in units of effective (view) pixels.

public : Rect Bounds { get; }
Rect Bounds();
public Rect Bounds { get; }
Public ReadOnly Property Bounds As Rect
Rect Rect

A value that reports the height and width of the application window.

See Also

Compositor Compositor Compositor Compositor

Gets the Compositor for this window.

public : Compositor Compositor { get; }
Compositor Compositor();
public Compositor Compositor { get; }
Public ReadOnly Property Compositor As Compositor
Compositor Compositor

The Compositor for this window.

Additional features and requirements
Device family
Windows 10 Creators Update (introduced v10.0.15063.0)
API contract
Windows.Foundation.UniversalApiContract (introduced v4)
See Also

Content Content Content Content

Gets or sets the visual root of an application window.

public : UIElement Content { get; set; }
UIElement Content(); void Content(UIElement content);
public UIElement Content { get; set; }
Public ReadWrite Property Content As UIElement
UIElement UIElement

The visual root of an application window.

CoreWindow CoreWindow CoreWindow CoreWindow

Gets an internal core object for the application window.

public : CoreWindow CoreWindow { get; }
CoreWindow CoreWindow();
public CoreWindow CoreWindow { get; }
Public ReadOnly Property CoreWindow As CoreWindow
CoreWindow CoreWindow

A CoreWindow object.

Current Current Current Current

Gets the currently activated window for an application.

public : static Window Current { get; }
static Window Current();
public static Window Current { get; }
Public Static ReadOnly Property Current As Window
Window Window Window Window

The currently activated window.

Dispatcher Dispatcher Dispatcher Dispatcher

Gets the CoreDispatcher object for the Window, which is generally the CoreDispatcher for the UI thread.

public : CoreDispatcher Dispatcher { get; }
CoreDispatcher Dispatcher();
public CoreDispatcher Dispatcher { get; }
Public ReadOnly Property Dispatcher As CoreDispatcher
CoreDispatcher CoreDispatcher

An object that references the UI thread for the Window.

Visible Visible Visible Visible

Gets a value that reports whether the window is visible.

public : Platform::Boolean Visible { get; }
bool Visible();
public bool Visible { get; }
Public ReadOnly Property Visible As bool
bool bool

true if the window is visible; false if the window is not visible.


Activate() Activate() Activate() Activate()

Attempts to activate the application window by bringing it to the foreground and setting the input focus to it.

public : void Activate()
void Activate() const;
public void Activate()
Public Function Activate() As void


If you use the default app templates from Microsoft Visual Studio, Window.Activate is part of the initial code in the app.xaml code-behind file. Specifically, Activate is called from the default OnLaunched override. In cases where the template produces a page navigation experience, previous states are detected so that the navigation framework isn't overwritten if it already existed, but Activate is called regardless.

Calling Activate is required for all app activation scenario, not just app launch.

This method is important for the correct operation of an app. If an app does not call Activate on the Current window, and the app is not visible on screen, then the app will be terminated after 15 seconds. If the app or its splash screen is kept on screen there is no time limit, but eventually the app needs to call Activate to progress. Also, certain app contracts extend the time limit.

You can modify the default OnLaunched implementation in order to delay calling Activate. You might do this to have all app rendering be complete before the main Window is shown. For example, a delay can be useful to finish loading Image source files in the initial UI. (These load asynchronously and it's impractical to handle ImageOpened from app.xaml code-behind.) On the other hand, delaying the call can create an undesirable user experience if the splash screen is visible for too long.

For secondary windows, you also need to call Activate. For more info about secondary windows, see Show multiple views for an app.

See Also

Close() Close() Close() Close()

Closes the application window.

public : void Close()
void Close() const;
public void Close()
Public Function Close() As void


UWP app typically use a single Window instance, and do not open and close additional Window instances. Additionally, you will not typically provide custom UI to enable users to close the app window.

The Closed event occurs when a Window closes.

SetTitleBar(UIElement) SetTitleBar(UIElement) SetTitleBar(UIElement) SetTitleBar(UIElement)

Makes a XAML element interact with the system as if it’s the title bar.

public : void SetTitleBar(UIElement value)
void SetTitleBar(UIElement value) const;
public void SetTitleBar(UIElement value)
Public Function SetTitleBar(value As UIElement) As void
UIElement UIElement

Custom XAML content that should act as the title bar. To use multiple objects, wrap them in a container element such as one derived from Panel.


This method lets you specify a XAML element that interacts with the system as if it’s the app window's title bar. When you use this method, you typically set the CoreApplicationViewTitleBar.ExtendViewIntoTitleBar property to true in order to hide the default system title bar. However, even when the default system title bar is not hidden, this can be used to make additional regions in your app behave like the title bar.

Use the CoreApplicationView.TitleBar property to get the instance of CoreApplicationViewTitleBar for your app window, like this.

// Requires using Windows.ApplicationModel.Core
CoreApplicationView coreView = CoreApplication.GetCurrentView();
CoreApplicationViewTitleBar coreTitleBar = coreView.TitleBar;
coreTitleBar.ExtendViewIntoTitleBar = true;

// -- OR --

CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = true;


This method has no effect when an app is run on a mobile device, because apps are always full-screen on mobile devices and do not have a window title bar.


When you call this method to set a XAML UIElement as the title bar, it lets Windows handle input to the title bar UIElement the same way it handles input to the default system title bar. For example, a user can move the window by dragging the XAML UIElement, or invoke the window context menu by right-clicking it.

This means that your app no longer receives pointer input when the user interacts with the target UIElement or its children using touch, mouse, or pen. However, you must still handle (or prevent) keyboard input, and determine whether content in the title bar can receive focus by tabbing to it with the keyboard.

Layout and appearance

You must update the visual content and layout of the target UIElement in response to title bar changes, like visibility and size.

To match the visibility of the system title bar, handle the CoreApplicationViewTitleBar.IsVisibleChanged event and respect the CoreApplicationViewTitleBar.IsVisible property by showing and hiding your custom title bar as appropriate. This ensures that your custom title bar content is correctly hidden when the system title bar is hidden; for example, when the user chooses to display your app in full-screen mode.

To ensure that your title bar matches the size of other title bar elements like the always-present system Minimize, Maximize, and Close buttons, handle the CoreApplicationViewTitleBar.LayoutMetricsChanged event and respect the CoreApplicationViewTitleBar.Height, SystemOverlayLeftInset, and SystemOverlayRightInset properties.

The default title bar buttons, such as Minimize, Maximize, and Close, are always shown by the system, so you might also want to modify their color to match your custom XAML title bar content. To do this, use the Windows.UI.ViewManagement.ApplicationView.TitleBar property to get the instance of ApplicationViewTitleBar for your app window. You can then set the various color properties on ApplicationViewTitleBar to modify the default buttons.


Activated Activated Activated Activated

Occurs when the window has successfully been activated.

public : event WindowActivatedEventHandler Activated<>
// Register
event_token Activated(WindowActivatedEventHandler<> const& handler) const;

// Revoke with event_token
void Activated(event_token const& cookie) const;

// Revoke with event_revoker
Activated_revoker Activated(auto_revoker_t, WindowActivatedEventHandler<> const& handler) const;
public event WindowActivatedEventHandler Activated<>
Public Event WindowActivatedEventHandler Activated( Of )


The following code example demonstrates a typical usage pattern for this event.

void Current_Activated(object sender, Windows.UI.Core.WindowActivatedEventArgs e)
    if (e.WindowActivationState == 
        // Show the "paused" UI. 
        VisualStateManager.GoToState(this, "PauseUI", false);
    else if (e.WindowActivationState == 
        // Show the "active" UI. 
        VisualStateManager.GoToState(this, "ActivateUI", false);


This event occurs when a Window has been activated or deactivated by the system. An app can determine what the status of the Window activation is by checking the WindowActivatedEventArgs.WindowActivationState property. A Window could be visible on screen but not be active (for example, in snapped apps). Additionally, if any other parts of the system takes focus away from the window, this event will occur. This could happen as a result of user interaction or code, and the WindowActivationState will indicate which action has taken place.

Closed Closed Closed Closed

Occurs when the window has closed.

public : event WindowClosedEventHandler Closed<>
// Register
event_token Closed(WindowClosedEventHandler<> const& handler) const;

// Revoke with event_token
void Closed(event_token const& cookie) const;

// Revoke with event_revoker
Closed_revoker Closed(auto_revoker_t, WindowClosedEventHandler<> const& handler) const;
public event WindowClosedEventHandler Closed<>
Public Event WindowClosedEventHandler Closed( Of )


The Closed event occurs when a Window closes. However, UWP app typically use a single Window instance, and do not open and close additional Window instances.

SizeChanged SizeChanged SizeChanged SizeChanged

Occurs when the app window has first rendered or has changed its rendering size.

public : event WindowSizeChangedEventHandler SizeChanged<>
// Register
event_token SizeChanged(WindowSizeChangedEventHandler<> const& handler) const;

// Revoke with event_token
void SizeChanged(event_token const& cookie) const;

// Revoke with event_revoker
SizeChanged_revoker SizeChanged(auto_revoker_t, WindowSizeChangedEventHandler<> const& handler) const;
public event WindowSizeChangedEventHandler SizeChanged<>
Public Event WindowSizeChangedEventHandler SizeChanged( Of )


This event occurs whenever there are changes in the Bounds values for the app window. This might be because the user resizes your app or changes the display orientation. Another trigger is if the user moves your app to a new display that has a different resolution and the app window expands to fill it.

Window.SizeChanged is the event to handle in order to detect that the user has deliberately resized your app or rotated the display on a PC that detects orientation. You may want to detect that the app window has changed from landscape to portrait orientation or vice versa. The app window orientation might influence how you want the individual controls within the app window to appear. For example, you might want to display data lists in a ListView for portrait orientation, but in a GridView for landscape orientation. Typically you would compare the ratio of Window.Current.Bounds.Width to Window.Current.Bounds.Height in order to determine the orientation based on the Bounds, and you'd do this whenever Window.SizeChanged fires. Exactly how you interpret width/height ratios is up to you.

If you're attaching handlers for Window.SizeChanged at the Page level within a handler for the FrameworkElement.Loaded event, you should detach those handlers in a FrameworkElement.Unloaded event handler from that Page. The Window.Current instance remains active between page navigations and should only have a handler active for the most current page code.

A Window.SizeChanged handler is not how you enforce the minimum size that your app can be resized to. That's controlled by the app manifest. However, your logic for changing the visual states should be able to load a state that's designed for the minimum width you intended, and you'd typically use the Bounds values and Window.SizeChanged handling to detect when the app window is using minimum width.

For more info on how to use Window.SizeChanged to detect changes in the app window environment and load the appropriate visual states for your app, see Quickstart: Designing apps for different window sizes.

There's another event named SizeChanged that exists on FrameworkElement derived types (Window is not a FrameworkElement type). FrameworkElement.SizeChanged events might fire in many of the same circumstances that cause Window.SizeChanged to fire. An app window size change can cause the root visual element (typically a Page or panel) to change its size. This sets off a cascade of layout invalidations for any the subelements that are using adaptive layout to fill available space. Each element that has new dimensions because of a layout pass will fire its own FrameworkElement.SizeChanged event.

See Also

VisibilityChanged VisibilityChanged VisibilityChanged VisibilityChanged

Occurs when the value of the Visible property changes.

public : event WindowVisibilityChangedEventHandler VisibilityChanged<>
// Register
event_token VisibilityChanged(WindowVisibilityChangedEventHandler<> const& handler) const;

// Revoke with event_token
void VisibilityChanged(event_token const& cookie) const;

// Revoke with event_revoker
VisibilityChanged_revoker VisibilityChanged(auto_revoker_t, WindowVisibilityChangedEventHandler<> const& handler) const;
public event WindowVisibilityChangedEventHandler VisibilityChanged<>
Public Event WindowVisibilityChangedEventHandler VisibilityChanged( Of )


VisibilityChangedEventArgs includes a Boolean Visible property that you should check to determine the current visibility state.

See Also