Delen via

Overzicht van WPF-vensters (WPF .NET)

  • Artikel

Gebruikers communiceren met WPF-toepassingen (Windows Presentation Foundation) via Windows. Het primaire doel van een venster is het hosten van inhoud waarmee gegevens worden gevisualiseerd en waarmee gebruikers kunnen communiceren met gegevens. WPF-toepassingen bieden hun eigen vensters met behulp van de Window-klasse. In dit artikel wordt Window geïntroduceerd voordat u de basisprincipes van het maken en beheren van vensters in toepassingen beschrijft.

Belangrijk

In dit artikel wordt XAML gebruikt die is gegenereerd op basis van een C#--project. Als u Visual Basic-gebruikt, ziet de XAML er mogelijk iets anders uit. Deze verschillen zijn doorgaans aanwezig op x:Class kenmerkwaarden. C# bevat de hoofdnaamruimte voor het project, terwijl Visual Basic dat niet doet.

De projectsjablonen voor C# maken in het bestand app.xaml een type App aan. In Visual Basic heeft het type de naam Application en heeft het bestand de naam Application.xaml.

De klasse Window

In WPF wordt een venster ingekapseld door de Window klasse die u gebruikt om het volgende te doen:

  • Een venster weergeven.
  • Configureer de grootte, positie en weergave van een venster.
  • Toepassingsspecifieke inhoud hosten.
  • De levensduur van een venster beheren.

In de volgende afbeelding ziet u de samenstellende onderdelen van een venster:

Schermopname van delen van een WPF-venster.

Een venster is onderverdeeld in twee gebieden: het niet-clientgebied en het clientgebied.

Het niet-clientgebied van een venster wordt geïmplementeerd door WPF en bevat de onderdelen van een venster dat voor de meeste vensters gebruikelijk is, waaronder:

  • Een titelbalk (1-5).
  • Een pictogram (1).
  • Titel (2).
  • De knoppen Minimaliseren (3), Maximaliseren (4) en Sluiten (5).
  • Systeemmenu (6) met menu-items. Wordt weergegeven wanneer u op het pictogram (1) klikt.
  • Rand (7).

Het clientgebied van een venster is het gebied binnen het niet-clientgebied van een venster en wordt gebruikt door ontwikkelaars om toepassingsspecifieke inhoud toe te voegen, zoals menubalken, hulpprogrammabalken en besturingselementen.

  • Clientgebied (8).
  • Formaatgreep aanpassen (9). Dit is een element dat is toegevoegd aan het klantgedeelte (8).

Een venster implementeren

De implementatie van een typisch venster omvat zowel uiterlijk als gedrag, waarbij uiterlijk definieert hoe een venster eruitziet voor gebruikers en gedrag definieert hoe een venster functioneert wanneer gebruikers ermee werken. In WPF kunt u het uiterlijk en gedrag van een venster implementeren met behulp van code of XAML-markeringen.

In het algemeen wordt het uiterlijk van een venster echter geïmplementeerd met behulp van XAML-markeringen en wordt het gedrag ervan geïmplementeerd met behulp van code-behind, zoals wordt weergegeven in het volgende voorbeeld.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->
    
</Window>

De volgende code is de achterliggende code voor de XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }
}

Public Class Window1

End Class

Als u wilt dat een XAML-markeringsbestand en code-behind-bestand samenwerken, moet u het volgende doen:

  • In markeringen moet het Window-element het kenmerk x:Class bevatten. Wanneer de toepassing is gebouwd, zorgt het bestaan van x:Class kenmerk ervoor dat microsoft build engine (MSBuild) een partial klasse genereert die is afgeleid van Window met de naam die is opgegeven door het x:Class kenmerk. Hiervoor moet een XML-naamruimtedeclaratie worden toegevoegd voor het XAML-schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). De gegenereerde partial-klasse implementeert de InitializeComponent methode, die wordt aangeroepen om de gebeurtenissen te registreren en de eigenschappen in te stellen die zijn geïmplementeerd in markeringen.

  • In code-behind moet de klasse een partial-klasse zijn met dezelfde naam die is opgegeven door het kenmerk x:Class in markeringen en moet deze zijn afgeleid van Window. Hierdoor kan het code-behind-bestand worden gekoppeld aan de partial-klasse die wordt gegenereerd voor het opmaakbestand wanneer de toepassing wordt gebouwd, zie Een WPF-toepassing compilerenvoor meer informatie.

  • In code-behind moet de Window-klasse een constructor implementeren die de InitializeComponent methode aanroept. InitializeComponent wordt geïmplementeerd door de gegenereerde partial-klasse van het opmaakbestand om gebeurtenissen te registreren en eigenschappen in te stellen die zijn gedefinieerd in de opmaak.

Notitie

Wanneer u een nieuwe Window aan uw project toevoegt met behulp van Visual Studio, wordt de Window geïmplementeerd met zowel markeringen als codeachter, en bevat de benodigde configuratie om de koppeling tussen de markeringen en code-behind-bestanden te maken, zoals hier wordt beschreven.

Met deze configuratie kunt u zich richten op het definiëren van het uiterlijk van het venster in XAML-markeringen en het implementeren van het gedrag in codeachter. In het volgende voorbeeld ziet u een venster met een knop waarmee een gebeurtenis-handler voor de Click gebeurtenis wordt gedefinieerd. Dit wordt geïmplementeerd in de XAML en de handler wordt geïmplementeerd in code-behind.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

    <Button Click="Button_Click">Click This Button</Button>
    
</Window>

De volgende code is de code-achter voor de XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}

Public Class Window1

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        MessageBox.Show("Button was clicked.")
    End Sub

End Class

Een venster configureren voor MSBuild

Hoe u uw venster implementeert, bepaalt hoe het is geconfigureerd voor MSBuild. Voor een venster dat is gedefinieerd met zowel XAML-markup als code-behind:

  • XAML-opmaakbestanden worden geconfigureerd als MSBuild Page items.
  • Code-behind-bestanden worden geconfigureerd als MSBuild Compile-items.

.NET SDK-projecten importeren automatisch de juiste Page en Compile items voor u en u hoeft deze niet te declareren. Wanneer het project is geconfigureerd voor WPF, worden de XAML-markeringsbestanden automatisch geïmporteerd als Page items en wordt het bijbehorende code-behind-bestand geïmporteerd als Compile.

MSBuild-projecten importeren de typen niet automatisch en u moet ze zelf declareren:

<Project>
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Zie Compileer een WPF-toepassingvoor meer informatie over het bouwen van WPF-toepassingen.

Levensduur van venster

Net als bij elke klasse heeft een venster een levensduur die begint wanneer het voor het eerst wordt geïnstantieerd, waarna het wordt geopend, geactiveerd/gedeactiveerd en uiteindelijk gesloten.

Een venster openen

Als u een venster wilt openen, maakt u eerst een exemplaar van het venster. Dit wordt gedemonstreerd in het volgende voorbeeld:

using System.Windows;

namespace WindowsOverview
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // Create the window
            Window1 window = new Window1();

            // Open the window
            window.Show();
        }
    }
}

Class Application

    Private Sub Application_Startup(sender As Object, e As StartupEventArgs)
        ' Create the window
        Dim window As New Window1

        ' Open the window
        window.Show()
    End Sub

End Class

In dit voorbeeld wordt Window1 geïnstantieerd wanneer de toepassing wordt gestart. Dit gebeurt wanneer de Startup gebeurtenis wordt gegenereerd. Voor meer informatie over het opstartvenster, zie Hoe u het hoofdtoepassingsvenster kunt ophalen of instellen.

Wanneer een venster wordt geïnstantieerd, wordt er automatisch een verwijzing naar het venster toegevoegd aan een lijst met vensters die wordt beheerd door het Application-object. Het eerste venster dat moet worden geïnstantieerd, wordt automatisch door Application ingesteld als het hoofdtoepassingsvenster.

Het venster wordt eindelijk geopend door de methode Show aan te roepen, zoals wordt weergegeven in de volgende afbeelding:

WPF-venster met één knop binnen met de tekst 'Klik op mij'.

Een venster, dat wordt geopend door Show aan te roepen, is een niet-modusgebonden venster, en door de toepassing wordt niet voorkomen dat gebruikers met andere vensters in de toepassing werken. Als u een venster opent met ShowDialog, wordt een venster geopend als modale en wordt de interactie van gebruikers tot het specifieke venster beperkt. Zie Dialoogvensters overzichtvoor meer informatie.

Wanneer Show wordt aangeroepen, wordt er een venster initiatiewerk uitgevoerd voordat het wordt weergegeven om een infrastructuur tot stand te brengen waarmee het gebruikersinvoer kan ontvangen. Wanneer het venster is geïnitialiseerd, wordt de gebeurtenis SourceInitialized gegenereerd en wordt het venster weergegeven.

Zie Een venster of dialoogvenster openenvoor meer informatie.

Opstartvenster

In het vorige voorbeeld werd de Startup gebeurtenis gebruikt om code uit te voeren die het eerste toepassingsvenster weergeeft. Gebruik als snelkoppeling StartupUri om het pad naar een XAML-bestand in uw toepassing op te geven. De toepassing maakt en geeft automatisch het venster weer dat is opgegeven door die eigenschap.

<Application x:Class="WindowsOverview.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WindowsOverview"
             StartupUri="ClippedWindow.xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

Eigendom van venster

Een venster dat wordt geopend met behulp van de methode Show heeft geen impliciete relatie met het venster dat het heeft gemaakt. Gebruikers kunnen onafhankelijk van de andere vensters communiceren, wat betekent dat beide vensters het volgende kunnen doen:

  • Bedek de andere (tenzij een van de vensters de eigenschap Topmost heeft ingesteld op true).
  • Worden geminimaliseerd, gemaximaliseerd en hersteld zonder dat dit van invloed is op de andere.

Sommige vensters vereisen een relatie met het venster waarmee ze worden geopend. Een IDE-toepassing (Integrated Development Environment) kan bijvoorbeeld eigenschappenvensters en hulpprogrammavensters openen waarvan het typische gedrag is om het venster te bedekken dat deze maakt. Bovendien moeten dergelijke vensters altijd sluiten, minimaliseren, maximaliseren en herstellen in combinatie met het venster dat ze heeft gemaakt. Een dergelijke relatie kan tot stand worden gebracht door één venster eigen een ander venster te maken en wordt bereikt door de Owner eigenschap van het venster van eigendom in te stellen met een verwijzing naar het eigenaarsvenster. Dit wordt weergegeven in het volgende voorbeeld.

private void Button_Click(object sender, RoutedEventArgs e)
{
    // Create a window and make the current window its owner
    var ownedWindow = new ChildWindow1();
    ownedWindow.Owner = this;
    ownedWindow.Show();
}

Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    ' Create a window and make the current window its owner
    Dim ownedWindow As New ChildWindow1
    ownedWindow.Owner = Me
    ownedWindow.Show()
End Sub

Nadat het eigendom tot stand is gebracht:

  • Het bezeten venster kan verwijzen naar het venster van de eigenaar door de waarde van de Owner eigenschap te controleren.
  • Het venster van de eigenaar kan alle vensters detecteren die het bezit door de waarde van de eigenschap OwnedWindows ervan te inspecteren.

Vensteractivering

Wanneer een venster voor het eerst wordt geopend, wordt het actieve venster. Het actieve venster is het venster dat momenteel gebruikersinvoer vastlegt, zoals toetsstreken en muisklikken. Wanneer een venster actief wordt, wordt het Activated-evenement geactiveerd.

Notitie

Wanneer een venster voor het eerst wordt geopend, worden de gebeurtenissen Loaded en ContentRendered pas gegenereerd nadat de gebeurtenis Activated is gegenereerd. Met dit in gedachten kan een venster effectief worden beschouwd als geopend wanneer ContentRendered wordt verhoogd.

Nadat een venster actief is, kan een gebruiker een ander venster in dezelfde toepassing activeren of een andere toepassing activeren. Als dat gebeurt, wordt het momenteel actieve venster gedeactiveerd en wordt de Deactivated gebeurtenis gegenereerd. Wanneer de gebruiker een momenteel gedeactiveerd venster selecteert, wordt het venster weer actief en wordt Activated gegenereerd.

Een veelvoorkomende reden voor het afhandelen van Activated en Deactivated is het in- en uitschakelen van functionaliteit die alleen kan worden uitgevoerd wanneer een venster actief is. Sommige vensters geven bijvoorbeeld interactieve inhoud weer waarvoor constante gebruikersinvoer of aandacht vereist is, waaronder games en videospelers. Het volgende voorbeeld is een vereenvoudigde videospeler die laat zien hoe u Activated en Deactivated kunt verwerken om dit gedrag te implementeren.

<Window x:Class="WindowsOverview.CustomMediaPlayerWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Activated="Window_Activated"
        Deactivated="Window_Deactivated"
        Title="CustomMediaPlayerWindow" Height="450" Width="800">
    <Grid>
        <MediaElement x:Name="mediaElement" Stretch="Fill"
                      LoadedBehavior="Manual" Source="numbers.mp4" />
    </Grid>
</Window>

De volgende code is de code-achter voor de XAML.

using System;
using System.Windows;

namespace WindowsOverview
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow() =>
            InitializeComponent();

        private void Window_Activated(object sender, EventArgs e)
        {
            // Continue playing media if window is activated
            mediaElement.Play();
        }

        private void Window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            mediaElement.Pause();
        }
    }
}

Public Class CustomMediaPlayerWindow
    Private Sub Window_Activated(sender As Object, e As EventArgs)
        ' Continue playing media if window Is activated
        mediaElement.Play()
    End Sub

    Private Sub Window_Deactivated(sender As Object, e As EventArgs)
        ' Pause playing if media is being played and window is deactivated
        mediaElement.Pause()
    End Sub
End Class

Andere typen toepassingen kunnen nog steeds code op de achtergrond uitvoeren wanneer een venster wordt gedeactiveerd. Een e-mailclient kan bijvoorbeeld de e-mailserver blijven peilen terwijl de gebruiker andere toepassingen gebruikt. Toepassingen zoals deze bieden vaak een ander of extra gedrag terwijl het hoofdvenster wordt gedeactiveerd. Voor een e-mailprogramma kan dit betekenen dat zowel het nieuwe e-mailitem aan het postvak in wordt toegevoegd als een meldingspictogram aan het systeemvak wordt toegevoegd. Er hoeft alleen een meldingspictogram te worden weergegeven wanneer het e-mailvenster niet actief is. Dit wordt bepaald door de eigenschap IsActive te controleren.

Als een achtergrondtaak is voltooid, kan het zijn dat een venster de gebruiker dringender op de hoogte wil stellen door Activate methode aan te roepen. Als de gebruiker communiceert met een andere toepassing die is geactiveerd wanneer Activate wordt aangeroepen, knippert de taakbalkknop van het venster. Als een gebruiker echter interactie heeft met de huidige toepassing, brengt het aanroepen van Activate het venster op de voorgrond.

Notitie

U kunt activering van toepassingsbereik afhandelen met behulp van de gebeurtenissen Application.Activated en Application.Deactivated.

Activering van vensters voorkomen

Er zijn scenario's waarin vensters niet moeten worden geactiveerd wanneer deze worden weergegeven, zoals gespreksvensters van een chattoepassing of meldingsvensters van een e-mailtoepassing.

Als uw toepassing een venster heeft dat niet moet worden geactiveerd wanneer deze wordt weergegeven, kunt u de eigenschap ShowActivated instellen op false voordat u de Show methode voor de eerste keer aanroept. Als gevolg hiervan:

  • Het venster is niet geactiveerd.
  • De Activated gebeurtenis van het venster wordt niet geactiveerd.
  • Het momenteel geactiveerde venster blijft geactiveerd.

Het venster wordt echter geactiveerd zodra de gebruiker het activeert door op de client of het niet-clientgebied te klikken. In dit geval:

  • Het venster is geactiveerd.
  • De Activated gebeurtenis van het venster wordt gegenereerd.
  • Het eerder geactiveerde venster is gedeactiveerd.
  • De Deactivated- en Activated gebeurtenissen van het venster worden vervolgens gegenereerd zoals verwacht als reactie op gebruikersacties.

Een venster sluiten

De levensduur van een venster begint aan een einde te komen wanneer een gebruiker het sluit. Zodra een venster is gesloten, kan het niet meer worden geopend. Een venster kan worden gesloten met behulp van elementen in het niet-klantgebied, waaronder het volgende:

  • Het item van het menu System sluiten.
  • Druk op Alt + F4.
  • Druk op de knop sluiten.
  • Druk op ESC wanneer de eigenschap IsCancel van een knop is ingesteld op true in een modaal venster.

U kunt meer mechanismen bieden voor het client-gebied om een venster te sluiten, waarvan de meest gebruikelijke de volgende zijn:

  • Een -item afsluiten in het menu Bestand, meestal voor hoofdvensters van toepassingen.
  • Een -item sluiten in het menu Bestand, meestal in een secundair toepassingsvenster.
  • Een 'Annuleren'-knop, meestal in een modaal dialoogvenster.
  • Een Sluit-knop, typisch op een venster zonder modaal.

Als u een venster wilt sluiten als reactie op een van deze aangepaste mechanismen, moet u de methode Close aanroepen. In het volgende voorbeeld wordt de mogelijkheid geïmplementeerd om een venster te sluiten door Afsluiten te kiezen in een Bestand menu.

<Window x:Class="WindowsOverview.ClosingWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClosingWindow" Height="450" Width="800">
    <StackPanel>
        <Menu>
            <MenuItem Header="_File">
                <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
            </MenuItem>
        </Menu>
    </StackPanel>
</Window>

De volgende code is de achterliggende code voor de XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class ClosingWindow : Window
    {
        public ClosingWindow() =>
            InitializeComponent();

        private void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close the current window
            this.Close();
        }
    }
}

Public Class ClosingWindow
    Private Sub fileExitMenuItem_Click(sender As Object, e As RoutedEventArgs)
        ' Close the current window
        Me.Close()
    End Sub
End Class

Notitie

Een toepassing kan worden geconfigureerd om automatisch af te sluiten wanneer het hoofdtoepassingsvenster wordt gesloten (zie MainWindow) of het laatste venster wordt gesloten. Zie ShutdownModevoor meer informatie.

Hoewel een venster expliciet kan worden gesloten via mechanismen die worden geboden in de niet-client- en clientgebieden, kan een venster ook impliciet worden gesloten als gevolg van gedrag in andere onderdelen van de toepassing of Windows, waaronder het volgende:

Belangrijk

Een venster kan niet opnieuw worden geopend nadat het is gesloten.

Venstersluiting annuleren

Wanneer een venster wordt gesloten, worden er twee gebeurtenissen gegenereerd: Closing en Closed.

Closing wordt verhoogd voordat het venster wordt gesloten en biedt een mechanisme waarmee venstersluiting kan worden voorkomen. Een veelvoorkomende reden om het sluiten van vensters te voorkomen, is als vensterinhoud gewijzigde gegevens bevat. In deze situatie kan de Closing gebeurtenis worden verwerkt om te bepalen of gegevens vuil zijn en, als dat het geval is, om de gebruiker te vragen of het venster moet worden gesloten zonder de gegevens op te slaan of om het sluiten van vensters te annuleren. In het volgende voorbeeld ziet u de belangrijkste aspecten van de verwerking van Closing.

<Window x:Class="WindowsOverview.DataWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="DataWindow" Height="450" Width="800"
        Closing="Window_Closing">
    <Grid>
        <TextBox x:Name="documentTextBox" TextChanged="documentTextBox_TextChanged" />
    </Grid>
</Window>

De volgende code is de achterliggende code voor XAML.

using System.Windows;
using System.Windows.Controls;

namespace WindowsOverview
{
    public partial class DataWindow : Window
    {
        private bool _isDataDirty;

        public DataWindow() =>
            InitializeComponent();

        private void documentTextBox_TextChanged(object sender, TextChangedEventArgs e) =>
            _isDataDirty = true;

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // If data is dirty, prompt user and ask for a response
            if (_isDataDirty)
            {
                var result = MessageBox.Show("Document has changed. Close without saving?",
                                             "Question",
                                             MessageBoxButton.YesNo);

                // User doesn't want to close, cancel closure
                if (result == MessageBoxResult.No)
                    e.Cancel = true;
            }
        }
    }
}

Public Class DataWindow

    Private _isDataDirty As Boolean

    Private Sub documentTextBox_TextChanged(sender As Object, e As TextChangedEventArgs)
        _isDataDirty = True
    End Sub

    Private Sub Window_Closing(sender As Object, e As ComponentModel.CancelEventArgs)

        ' If data is dirty, prompt user and ask for a response
        If _isDataDirty Then
            Dim result = MessageBox.Show("Document has changed. Close without saving?",
                                         "Question",
                                         MessageBoxButton.YesNo)

            ' User doesn't want to close, cancel closure
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End If

    End Sub
End Class

De Closing gebeurtenis-handler wordt doorgegeven aan een CancelEventArgs, waarmee de Cancel eigenschap wordt geïmplementeerd die u hebt ingesteld op true om te voorkomen dat een venster wordt gesloten.

Als Closing niet wordt verwerkt, of het wordt wel verwerkt maar niet geannuleerd, wordt het venster gesloten. Net voordat een venster daadwerkelijk wordt gesloten, wordt Closed verhoogd. Op dit moment kan niet worden voorkomen dat een venster wordt gesloten.

Gebeurtenissen voor levensduur van vensters

In de volgende afbeelding ziet u de volgorde van de principal-gebeurtenissen in de levensduur van een venster:

diagram met gebeurtenissen in de levensduur van een venster.

In de volgende afbeelding ziet u de volgorde van de principal-gebeurtenissen in de levensduur van een venster dat wordt weergegeven zonder activering (ShowActivated is ingesteld op false voordat het venster wordt weergegeven):

diagram met gebeurtenissen in de levensduur van een venster zonder activering.

Locatie van venster

Terwijl een venster is geopend, heeft het een locatie in de x- en y-dimensies ten opzichte van het bureaublad. Deze locatie kan worden bepaald door respectievelijk de eigenschappen van de Left en Top te inspecteren. Stel deze eigenschappen in om de locatie van het venster te wijzigen.

U kunt ook de eerste locatie van een Window opgeven wanneer deze voor het eerst wordt weergegeven door de eigenschap WindowStartupLocation in te stellen met een van de volgende WindowStartupLocation opsommingswaarden:

Als de opstartlocatie is opgegeven als Manualen de eigenschappen Left en Top niet zijn ingesteld, vraagt Window het besturingssysteem om een locatie in te zien.

Bovenste vensters en z-order

Naast een x- en y-locatie heeft een venster ook een locatie in de z-dimensie, die de verticale positie bepaalt ten opzichte van andere vensters. Dit staat bekend als de z-volgorde van het venster en er zijn twee typen: normale z-volgorde en bovenste z-order. De locatie van een venster in de normale z-volgorde wordt bepaald door of het momenteel actief is of niet. Standaard bevindt een venster zich in de normale z-volgorde. De locatie van een venster in de bovenste z-volgorde wordt ook bepaald door of het momenteel actief is of niet. Bovendien bevinden vensters in de bovenste z-volgorde zich altijd boven vensters in de normale z-volgorde. Een venster bevindt zich in de bovenste z-volgorde door de eigenschap Topmost in te stellen op true.

Binnen elk z-ordertype wordt het huidige actieve venster weergegeven boven alle andere vensters in dezelfde z-volgorde.

Venstergrootte

Naast het hebben van een bureaubladlocatie heeft een venster een grootte die wordt bepaald door verschillende eigenschappen, waaronder de verschillende eigenschappen voor breedte en hoogte en SizeToContent.

MinWidth, Widthen MaxWidth worden gebruikt voor het beheren van het bereik van breedten die een venster tijdens de levensduur kan hebben.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinWidth="300" Width="400" MaxWidth="500">
</Window>

Vensterhoogte wordt beheerd door MinHeight, Heighten MaxHeight.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinHeight="300" Height="400" MaxHeight="500">
</Window>

Omdat de verschillende breedtewaarden en hoogtewaarden elk een bereik opgeven, is het mogelijk dat de breedte en hoogte van een formaatbaar venster zich overal binnen het opgegeven bereik voor de respectieve dimensie bevinden. Als u de huidige breedte en hoogte wilt detecteren, inspecteert u respectievelijk ActualWidth en ActualHeight.

Als u wilt dat de breedte en hoogte van het venster een grootte hebben die past bij de grootte van de inhoud van het venster, kunt u de eigenschap SizeToContent met de volgende waarden gebruiken:

In het volgende voorbeeld ziet u een venster dat automatisch wordt aangepast aan de inhoud, zowel verticaal als horizontaal, wanneer deze voor het eerst wordt weergegeven.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    SizeToContent="WidthAndHeight">
</Window>

In het volgende voorbeeld ziet u hoe u de eigenschap SizeToContent in code instelt om op te geven hoe het formaat van een venster wordt aangepast aan de inhoud ervan.

// Manually alter window height and width
this.SizeToContent = SizeToContent.Manual;

// Automatically resize width relative to content
this.SizeToContent = SizeToContent.Width;

// Automatically resize height relative to content
this.SizeToContent = SizeToContent.Height;

// Automatically resize height and width relative to content
this.SizeToContent = SizeToContent.WidthAndHeight;

' Manually alter window height and width
Me.SizeToContent = SizeToContent.Manual

' Automatically resize width relative to content
Me.SizeToContent = SizeToContent.Width

' Automatically resize height relative to content
Me.SizeToContent = SizeToContent.Height

' Automatically resize height and width relative to content
Me.SizeToContent = SizeToContent.WidthAndHeight

Volgorde van prioriteit voor grootte-eigenschappen

In wezen bepalen de verschillende grootte-eigenschappen van een venster de breedte- en hoogterange voor een aanpasbaar venster. Om ervoor te zorgen dat een geldig bereik wordt gehandhaafd, Window de waarden van de grootte-eigenschappen evalueert met behulp van de volgende prioriteitsvolgordes.

voor hoogte-eigenschappen:

  1. FrameworkElement.MinHeight
  2. FrameworkElement.MaxHeight
  3. SizeToContent.Height / SizeToContent.WidthAndHeight
  4. FrameworkElement.Height

Voor eigenschappen van breedte:

  1. FrameworkElement.MinWidth
  2. FrameworkElement.MaxWidth
  3. SizeToContent.Width / SizeToContent.WidthAndHeight
  4. FrameworkElement.Width

De volgorde van prioriteit kan ook de grootte van een venster bepalen wanneer het wordt gemaximaliseerd, dat wordt beheerd met de eigenschap WindowState.

Vensterstatus

Tijdens de levensduur van een formaatbaar venster kan het drie statussen hebben: normaal, geminimaliseerd en gemaximaliseerd. Een venster met een normale status is de standaardstatus van een venster. Met een venster met deze status kan een gebruiker deze verplaatsen en het formaat ervan wijzigen met behulp van een formaatgreep of de rand, als het formaat ervan kan worden aangepast.

Een venster met een geminimaliseerde status wordt samengevouwen tot de taakbalkknop als ShowInTaskbar is ingesteld op true; anders wordt het samengevouwen tot de kleinste mogelijke grootte en verplaatst het zich naar de linkerbenedenhoek van het bureaublad. Geen van beide typen geminimaliseerde vensters kan worden gewijzigd van formaat met behulp van een rand of formaatgreep, hoewel een geminimaliseerd venster dat niet in de taakbalk wordt weergegeven, rond het bureaublad kan worden gesleept.

Een venster met een gemaximaliseerde status wordt uitgebreid tot de maximale grootte die het kan hebben, wat alleen zo groot is als de MaxWidth, MaxHeighten SizeToContent eigenschappen dicteren. Net als een geminimaliseerd venster kan het formaat van een gemaximaliseerd venster niet worden gewijzigd met behulp van een formaatgreep of door de rand te slepen.

Notitie

De waarden van de Top, Left, Widthen Height eigenschappen van een venster vertegenwoordigen altijd de waarden voor de normale toestand, zelfs wanneer het venster momenteel is gemaximaliseerd of geminimaliseerd.

De status van een venster kan worden geconfigureerd door de eigenschap WindowState in te stellen, die een van de volgende WindowState opsommingswaarden kan hebben:

In het volgende voorbeeld ziet u hoe u een venster maakt dat wordt weergegeven als gemaximaliseerd wanneer het wordt geopend.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowState="Maximized">
</Window>

Over het algemeen moet u WindowState instellen om de initiële status van een venster te configureren. Zodra een kan worden aangepast venster wordt weergegeven, kunnen gebruikers op de knoppen minimaliseren, maximaliseren en herstellen op de titelbalk van het venster drukken om de vensterstatus te wijzigen.

Uiterlijk van venster

U wijzigt het uiterlijk van het clientgebied van een venster door er vensterspecifieke inhoud aan toe te voegen, zoals knoppen, labels en tekstvakken. Als u het niet-clientgebied wilt configureren, biedt Window verschillende eigenschappen, waaronder Icon om het pictogram van een venster in te stellen en Title om de titel in te stellen.

U kunt ook het uiterlijk en gedrag van de rand van het niet-clientgebied wijzigen door de formaatmodus, de vensterstijl van een venster te configureren en of deze wordt weergegeven als een knop op de taakbalk van het bureaublad.

Grootte-modus wijzigen

Afhankelijk van de eigenschap WindowStyle kunt u bepalen of en hoe gebruikers het formaat van het venster wijzigen. De stijl van het venster is van invloed op het volgende:

  • Sta toe of verbied het wijzigen van het formaat door de vensterrand met de muis te slepen.
  • Of de knoppen minimaliseren, maximaliserenen sluiten worden weergegeven op het niet-client gebied.
  • Of de knoppen minimaliseren, maximaliseren, en sluiten zijn ingeschakeld.

U kunt configureren hoe het formaat van een venster wordt gewijzigd door de eigenschap ResizeMode in te stellen. Dit kan een van de volgende ResizeMode opsommingswaarden zijn:

Net als bij WindowStyleis het onwaarschijnlijk dat de groottemodus van een venster tijdens de levensduur wordt gewijzigd. Dit betekent dat u deze waarschijnlijk instelt op basis van XAML-markeringen.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ResizeMode="CanResizeWithGrip">
</Window>

U kunt detecteren of een venster is gemaximaliseerd, geminimaliseerd of hersteld door de eigenschap WindowState te controleren.

Vensterstijl

De rand die wordt weergegeven vanuit het niet-clientgebied van een venster is geschikt voor de meeste toepassingen. Er zijn echter omstandigheden waarin verschillende soorten randen nodig zijn of helemaal geen randen nodig zijn, afhankelijk van het type venster.

Als u wilt bepalen welk type rand een venster krijgt, stelt u de eigenschap WindowStyle in met een van de volgende waarden van de opsomming WindowStyle:

Het effect van het toepassen van een vensterstijl wordt geïllustreerd in de volgende afbeelding:

Schermopname die laat zien hoe WindowStyle van invloed is op een venster in WPF.

U ziet dat in de bovenstaande afbeelding geen merkbaar verschil wordt weergegeven tussen SingleBorderWindow en ThreeDBorderWindow. In Windows XP had ThreeDBorderWindow invloed op hoe het venster werd getekend, waarbij een 3D-rand aan het clientgebied werd toegevoegd. Vanaf Windows 7 zijn de verschillen tussen de twee stijlen minimaal.

U kunt WindowStyle instellen met behulp van XAML-markeringen of code. Omdat deze waarschijnlijk niet kan worden gewijzigd tijdens de levensduur van een venster, configureert u deze waarschijnlijk met behulp van XAML-markeringen.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="ToolWindow">
</Window>

Niet-rechthoekige vensterstijl

Er zijn ook situaties waarin de randstijlen die WindowStyle toestaat niet voldoende zijn. U kunt bijvoorbeeld een toepassing maken met een niet-rechthoekige rand, zoals Microsoft Windows Media Player gebruikt.

Denk bijvoorbeeld aan het spraakballonvenster dat wordt weergegeven in de volgende afbeelding:

Schermopname van een WPF-venster met een geknipt gebied en aangepaste vorm.

Dit type venster kan worden gemaakt door de eigenschap WindowStyle in te stellen op Noneen door speciale ondersteuning te gebruiken die Window heeft voor transparantie.

<Window x:Class="WindowsOverview.ClippedWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClippedWindow" SizeToContent="WidthAndHeight"
        WindowStyle="None" AllowsTransparency="True" Background="Transparent">
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>

        <Rectangle Stroke="#FF000000" RadiusX="10" RadiusY="10"/>
        <Path Fill="White" Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="15,-5.597,0,-0.003" Width="30" Grid.Row="1" Data="M22.166642,154.45381 L29.999666,187.66699 40.791059,154.54395"/>
        <Rectangle Fill="White" RadiusX="10" RadiusY="10" Margin="1"/>
        
        <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center" FontSize="25" Text="Greetings!" TextWrapping="Wrap" Margin="5,5,50,5"/>
        <Button HorizontalAlignment="Right" VerticalAlignment="Top" Background="Transparent" BorderBrush="{x:Null}" Foreground="Red" Content="❌" FontSize="15" />

        <Grid.Effect>
            <DropShadowEffect BlurRadius="10" ShadowDepth="3" Color="LightBlue"/>
        </Grid.Effect>
    </Grid>
</Window>

Met deze combinatie van waarden wordt het venster geïnstrueerd om transparant te worden. In deze staat kunnen de decoratieknoppen in het niet-klantgedeelte van het venster niet worden gebruikt en moet u uw eigen knoppen voorzien.

Aanwezigheid op taakbalk

De standaardweergave van een venster bevat een taakbalkknop. Sommige typen vensters hebben geen taakbalkknop, zoals berichtvakken, dialoogvenstersof vensters waarvoor de eigenschap WindowStyle is ingesteld op ToolWindow. U kunt bepalen of de taakbalkknop voor een venster wordt weergegeven door de eigenschap ShowInTaskbar in te stellen. Deze eigenschap is standaard true.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ShowInTaskbar="False">
</Window>

Andere typen vensters

NavigationWindow is een venster dat is ontworpen om bevaarbare inhoud te hosten.

Dialoogvensters zijn vensters die vaak worden gebruikt om informatie van een gebruiker te verzamelen om een functie te voltooien. Wanneer een gebruiker bijvoorbeeld een bestand wil openen, wordt het dialoogvenster Bestand openen weergegeven door een toepassing om de bestandsnaam van de gebruiker op te halen. Zie Dialoogvensters overzichtvoor meer informatie.

Zie ook