Bureaubladhandleiding (WPF .NET)

Welkom bij de Bureaubladhandleiding voor Windows Presentation Foundation (WPF), een UI-framework dat oplossingsonafhankelijk is en gebruikmaakt van een vectorgebaseerde rendering-engine die is gebouwd om te profiteren van moderne grafische hardware. WPF biedt een uitgebreide set functies voor toepassingsontwikkeling, waaronder Extensible Application Markup Language (XAML), besturingselementen, gegevensbinding, indeling, 2D- en 3D-afbeeldingen, animatie, stijlen, sjablonen, documenten, media, tekst en typografie. WPF maakt deel uit van .NET, zodat u toepassingen kunt bouwen die andere elementen van de .NET-API bevatten.

Er zijn twee implementaties van WPF:

1. .NET versie (deze handleiding):

   Een opensource-implementatie van WPF die wordt gehost op GitHub-, die wordt uitgevoerd op .NET. Voor de XAML-ontwerpfunctie is minimaal Visual Studio 2019 versie 16.8vereist. Afhankelijk van uw versie van .NET moet u mogelijk een nieuwere versie van Visual Studio gebruiken.

   Hoewel .NET een platformoverschrijdende technologie is, wordt WPF alleen uitgevoerd in Windows.

2. .NET Framework 4 versie:

   De .NET Framework-implementatie van WPF die wordt ondersteund door Visual Studio 2019 en Visual Studio 2017.

   .NET Framework 4 is een windows-versie van .NET en wordt beschouwd als een Windows-besturingssysteemonderdeel. Deze versie van WPF wordt gedistribueerd met .NET Framework. Zie Inleiding tot WPF voor .NET Frameworkvoor meer informatie over de .NET Framework-versie van WPF.

Dit overzicht is bedoeld voor nieuwkomers en behandelt de belangrijkste mogelijkheden en concepten van WPF. Zie Zelfstudie: Een nieuwe WPF-app makenvoor meer informatie over het maken van een WPF-app.

Waarom upgraden van .NET Framework

Wanneer u uw toepassing bijwerkt van .NET Framework naar .NET, profiteert u van:

• Betere prestaties
• Nieuwe .NET-API's
• De nieuwste taalverbeteringen
• Verbeterde toegankelijkheid en betrouwbaarheid
• Bijgewerkte hulpprogramma's en meer

Zie Een WPF-desktop-app upgraden naar .NET 7voor meer informatie over het upgraden van uw toepassing.

Programma met WPF

WPF bestaat als een subset van .NET-typen die zich voornamelijk in de System.Windows naamruimte bevinden. Als u eerder toepassingen met .NET hebt gebouwd met frameworks zoals ASP.NET en Windows Forms, moet u bekend zijn met de fundamentele WPF-programmeerervaring:

• Klassen instantiëren
• Eigenschappen instellen
• Aanroepmethoden
• Gebeurtenissen verwerken

WPF bevat meer programmeerconstructies die eigenschappen en gebeurtenissen verbeteren: afhankelijkheidseigenschappen en gerouteerde gebeurtenissen.

Opmaak en achterliggende code

Met WPF kunt u een toepassing ontwikkelen met behulp van zowel markeringen als code-behind, een ervaring waarmee ASP.NET ontwikkelaars vertrouwd moeten zijn. Over het algemeen gebruikt u XAML-markeringen om het uiterlijk van een toepassing te implementeren terwijl u beheerde programmeertalen (code-behind) gebruikt om het gedrag ervan te implementeren. Deze scheiding van uiterlijk en gedrag heeft de volgende voordelen:

• De ontwikkelings- en onderhoudskosten worden verlaagd omdat de vormgevingsspecifieke markeringen niet nauw zijn gekoppeld aan gedragspecifieke code.

• Ontwikkeling is efficiënter omdat ontwerpers het uiterlijk van een toepassing tegelijkertijd kunnen implementeren met ontwikkelaars die het gedrag van de toepassing implementeren.

• globalisatie en lokalisatie voor WPF-toepassingen is vereenvoudigd.

Opmaak

XAML is een op XML gebaseerde opmaaktaal waarmee het uiterlijk van een toepassing declaratief wordt geïmplementeerd. Doorgaans gebruikt u deze om vensters, dialoogvensters, pagina's en gebruikersbesturingselementen te definiëren en deze te vullen met besturingselementen, vormen en afbeeldingen.

In het volgende voorbeeld wordt XAML gebruikt om het uiterlijk van een venster met één knop te implementeren:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Window with button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button">Click Me!</Button>

</Window>

Deze XAML definieert met name een venster en een knop met behulp van de Window en Button elementen. Elk element is geconfigureerd met kenmerken, zoals het Title kenmerk van het Window element om de titelbalktekst van het venster op te geven. Tijdens runtime converteert WPF de elementen en kenmerken die zijn gedefinieerd in markeringen naar exemplaren van WPF-klassen. Het Window-element wordt bijvoorbeeld geconverteerd naar een exemplaar van de Window-klasse waarvan de eigenschap Title de waarde is van het kenmerk Title.

In de volgende afbeelding ziet u de gebruikersinterface (UI) die is gedefinieerd door de XAML in het vorige voorbeeld:

Omdat XAML XML is gebaseerd, wordt de gebruikersinterface die u ermee opstelt, samengevoegd in een hiërarchie van geneste elementen die een elementstructuurwordt genoemd. De elementstructuur biedt een logische en intuïtieve manier om UIS's te maken en te beheren.

Code-behind

Het belangrijkste gedrag van een toepassing is het implementeren van de functionaliteit die reageert op gebruikersinteracties. Klik bijvoorbeeld op een menu of knop en roep bedrijfslogica en gegevenstoegangslogica aan als reactie. In WPF wordt dit gedrag geïmplementeerd in code die is gekoppeld aan markeringen. Dit type code staat bekend als code-behind. In het volgende voorbeeld ziet u de bijgewerkte markeringen uit het vorige voorbeeld en de code-behind:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.AWindow"
    Title="Window with button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button" Click="button_Click">Click Me!</Button>

</Window>

De bijgewerkte markering definieert de xmlns:x naamruimte en wijst deze toe aan het schema waarmee ondersteuning wordt toegevoegd voor de code-behind-typen. Het kenmerk x:Class wordt gebruikt om een code-behind-klasse te koppelen aan deze specifieke XAML-markering. Aangezien dit kenmerk wordt gedeclareerd op het <Window> element, moet de code-behind-klasse overnemen van de Window-klasse.

using System.Windows;

namespace SDKSample
{
    public partial class AWindow : Window
    {
        public AWindow()
        {
            // InitializeComponent call is required to merge the UI
            // that is defined in markup with this class, including  
            // setting properties and registering event handlers
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked.
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Namespace SDKSample

    Partial Public Class AWindow
        Inherits System.Windows.Window

        Public Sub New()

            ' InitializeComponent call is required to merge the UI
            ' that is defined in markup with this class, including  
            ' setting properties and registering event handlers
            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

            ' Show message box when button is clicked.
            MessageBox.Show("Hello, Windows Presentation Foundation!")

        End Sub

    End Class

End Namespace

InitializeComponent wordt aangeroepen vanuit de constructor van de code-behind-klasse om de gebruikersinterface die in de markup is gedefinieerd samen te voegen met de code-behind-klasse. (InitializeComponent wordt voor u gegenereerd wanneer uw toepassing wordt gebouwd. Daarom hoeft u deze niet handmatig te implementeren.) De combinatie van x:Class en InitializeComponent ervoor zorgen dat uw implementatie correct wordt geïnitialiseerd wanneer deze wordt gemaakt.

U ziet dat in de markering het <Button>-element een waarde van button_Click heeft gedefinieerd voor het kenmerk Click. Met de markup en de code-behind geïnitialiseerd en samenwerkend, wordt het Click event voor de knop automatisch toegewezen aan de button_Click methode. Wanneer op de knop wordt geklikt, wordt de gebeurtenis-handler aangeroepen en wordt er een berichtvak weergegeven door de System.Windows.MessageBox.Show methode aan te roepen.

In de volgende afbeelding ziet u het resultaat wanneer op de knop wordt geklikt:

Invoer en opdrachten

Besturingselementen detecteren en reageren het vaakst op gebruikersinvoer. Het WPF-invoersysteem maakt gebruik van directe en gerouteerde gebeurtenissen ter ondersteuning van tekstinvoer, focusbeheer en plaatsing van de muis.

Toepassingen hebben vaak complexe invoervereisten. WPF biedt een opdrachtsysteem waarmee gebruikersinvoeracties worden gescheiden van de code die op deze acties reageert. Met het opdrachtsysteem kunnen meerdere bronnen dezelfde opdrachtlogica aanroepen. Neem bijvoorbeeld de algemene bewerkingen die door verschillende toepassingen worden gebruikt: Kopiëren, Knippenen Plakken. Deze bewerkingen kunnen worden aangeroepen met behulp van verschillende gebruikersacties als ze worden geïmplementeerd met behulp van opdrachten.

Besturingselementen

De gebruikerservaringen die door het toepassingsmodel worden geleverd, zijn samengestelde besturingselementen. In WPF is controle een overkoepelende term die van toepassing is op een categorie WPF-klassen met de volgende kenmerken:

• Gehost in een venster of een pagina.
• Een gebruikersinterface hebben.
• Implementeer een bepaald gedrag.

Zie Besturingselementenvoor meer informatie.

WPF-besturingselementen per functie

De ingebouwde WPF-besturingselementen worden hier vermeld:

• knoppen: Button en RepeatButton.

• gegevensweergave: DataGrid, ListViewen TreeView.

• datumweergave en selectie: Calendar en DatePicker.

• dialoogvensters: OpenFileDialog, PrintDialogen SaveFileDialog.

• Digital Ink: InkCanvas en InkPresenter.

• Documenten: DocumentViewer, FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollVieweren StickyNoteControl.

• invoer: TextBox, RichTextBoxen PasswordBox.

• indeling: Border, BulletDecorator, Canvas, DockPanel, Expander, Grid, GridView, GridSplitter, GroupBox, Panel, ResizeGrip, Separator, ScrollBar, ScrollViewer, StackPanel, Thumb, Viewbox, VirtualizingStackPanel, Windowen WrapPanel.

• Media: Image, MediaElementen SoundPlayerAction.

• Menus: ContextMenu, Menuen ToolBar.

• navigatie: Frame, Hyperlink, Page, NavigationWindowen TabControl.

• Selectie: CheckBox, ComboBox, ListBox, RadioButtonen Slider.

• gebruikersgegevens: AccessText, Label, Popup, ProgressBar, StatusBar, TextBlocken ToolTip.

Indeling

Wanneer u een gebruikersinterface maakt, rangschikt u uw besturingselementen op locatie en grootte om een indeling te vormen. Een belangrijke vereiste van elke indeling is om zich aan te passen aan wijzigingen in de venstergrootte en weergave-instellingen. In plaats van dat u de code hoeft te schrijven om een indeling in deze omstandigheden aan te passen, biedt WPF een eersteklas, uitbreidbaar indelingssysteem voor u.

De hoeksteen van het lay-outsysteem is relatieve positionering, waardoor de mogelijkheid om zich aan te passen aan veranderende venster- en weergaveomstandigheden toeneemt. Het indelingssysteem beheert ook de onderhandeling tussen besturingselementen om de indeling te bepalen. De onderhandeling is een proces in twee stappen: eerst vertelt een bedieningselement aan zijn ouder welke locatie en grootte het nodig heeft. Ten tweede geeft de ouder aan welke ruimte de besturing mag hebben.

Het indelingssysteem wordt blootgesteld aan kindbesturingselementen via WPF-basisklassen. Voor algemene indelingen, zoals rasters, stapelen en dockingen, bevat WPF verschillende indelingsbesturingselementen:

• Canvas: onderliggende besturingselementen bieden hun eigen indeling.

• DockPanel: Subbesturingselementen worden uitgelijnd met de randen van het paneel.

• Grid: kindbesturingselementen worden gepositioneerd op rijen en kolommen.

• StackPanel: onderliggende besturingselementen worden verticaal of horizontaal gestapeld.

• VirtualizingStackPanel: onderliggende besturingselementen worden gevirtualiseerd en gerangschikt op één regel die horizontaal of verticaal is gericht.

• WrapPanel: onderliggende besturingselementen worden in de volgorde van links naar rechts geplaatst en verpakt naar de volgende regel wanneer er onvoldoende ruimte is op de huidige regel.

In het volgende voorbeeld wordt een DockPanel gebruikt om verschillende TextBox besturingselementen in te stellen:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.LayoutWindow"
    Title="Layout with the DockPanel" Height="143" Width="319">
  
  <!--DockPanel to layout four text boxes--> 
  <DockPanel>
    <TextBox DockPanel.Dock="Top">Dock = "Top"</TextBox>
    <TextBox DockPanel.Dock="Bottom">Dock = "Bottom"</TextBox>
    <TextBox DockPanel.Dock="Left">Dock = "Left"</TextBox>
    <TextBox Background="White">This TextBox "fills" the remaining space.</TextBox>
  </DockPanel>

</Window>

De DockPanel laat de TextBox besturingselementen weten hoe ze gerangschikt moeten worden. Hiervoor implementeert de DockPanel een Dock gekoppelde eigenschap die beschikbaar is voor de onderliggende besturingselementen, zodat elk van deze besturingselementen een dockstijl kan opgeven.

Notitie

Een eigenschap die wordt geïmplementeerd door een bovenliggend besturingselement voor gebruik door onderliggende besturingselementen, is een WPF-constructie die een gekoppelde eigenschapwordt genoemd.

In de volgende afbeelding ziet u het resultaat van de XAML-markering in het voorgaande voorbeeld:

Gegevensbinding

De meeste toepassingen worden gemaakt om gebruikers de middelen te bieden om gegevens te bekijken en te bewerken. Voor WPF-toepassingen is het werk voor het opslaan en openen van gegevens al beschikbaar voor veel verschillende .NET-gegevenstoegangsbibliotheken zoals SQL en Entity Framework Core. Nadat de gegevens zijn geopend en geladen in de beheerde objecten van een toepassing, begint het harde werk voor WPF-toepassingen. In wezen omvat dit twee dingen:

1. Kopieer de gegevens van de beheerde objecten naar besturingselementen, waar de gegevens kunnen worden weergegeven en bewerkt.

2. Ervoor zorgen dat wijzigingen in gegevens met behulp van besturingselementen worden teruggezet naar de beheerde objecten.

Om de ontwikkeling van toepassingen te vereenvoudigen, biedt WPF een krachtige engine voor gegevensbinding om deze stappen automatisch af te handelen. De kerneenheid van de gegevensbindingsengine is de Binding klasse, waarvan de taak is om een besturingselement (het bindingsdoel) te binden aan een gegevensobject (de bindingsbron). Deze relatie wordt geïllustreerd door de volgende afbeelding:

WPF ondersteunt het rechtstreeks declareren van bindingen in de XAML-markeringen. Met de volgende XAML-code wordt bijvoorbeeld de eigenschap Text van de TextBox gekoppeld aan de eigenschap Name van een object met behulp van de syntaxis XAML{Binding ... }. Hierbij wordt ervan uitgegaan dat er een gegevensobject is ingesteld op de eigenschap DataContext van de Window met een eigenschap Name.

 <Window
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     x:Class="SDKSample.DataBindingWindow">

   <!-- Bind the TextBox to the data source (TextBox.Text to Person.Name) -->
   <TextBox Name="personNameTextBox" Text="{Binding Path=Name}" />

 </Window>

De WPF-gegevensbindingsengine biedt meer dan alleen binding, het biedt validatie, sorteren, filteren en groeperen. Bovendien ondersteunt gegevensbinding het gebruik van gegevenssjablonen voor het maken van een aangepaste gebruikersinterface voor afhankelijke gegevens.

Zie Overzicht van gegevensbindingvoor meer informatie.

Afbeeldingen & animatie

WPF biedt een uitgebreide en flexibele set grafische functies met de volgende voordelen:

• resolutie-onafhankelijke en apparaatonafhankelijke afbeeldingen. De basiseenheid van de meting in het WPF-grafische systeem is de apparaatonafhankelijke pixel, die 1/96e van een inch is en de basis biedt voor resolutie-onafhankelijke en apparaatonafhankelijke rendering. Elke apparaatonafhankelijke pixel wordt automatisch geschaald zodat deze overeenkomt met de dpi-instelling (dots-per-inch) van het systeem waarop het wordt weergegeven.

• Verbeterde precisie. Het WPF-coördinaatsysteem wordt gemeten met getallen met dubbele precisie in plaats van één precisie. Transformaties en ondoorzichtigheidswaarden worden ook uitgedrukt als dubbele precisie. WPF ondersteunt ook een breed kleurengamma (scRGB) en biedt geïntegreerde ondersteuning voor het beheren van invoer uit verschillende kleurruimten.

• Ondersteuning voor geavanceerde afbeeldingen en animatie. WPF vereenvoudigt het programmeren van afbeeldingen door animatiescènes voor u te beheren; u hoeft zich geen zorgen te maken over scèneverwerking, renderinglussen en bilineaire interpolatie. Daarnaast biedt WPF ondersteuning voor hit-testing en volledige alfacompositing-ondersteuning.

• Hardwareversnelling. Het WPF-grafische systeem maakt gebruik van grafische hardware om het CPU-gebruik te minimaliseren.

2D-afbeeldingen

WPF biedt een bibliotheek met gebruikelijke vectorgetekende 2D-vormen, zoals de rechthoeken en ellipsen. De shapes zijn niet alleen voor weergave; shapes implementeren veel van de functies die u verwacht van besturingselementen, waaronder toetsenbord- en muisinvoer.

De 2D-shapes van WPF dekken de standaardset basisshapes. Mogelijk moet u echter aangepaste shapes maken om het ontwerp van een aangepaste gebruikersinterface te helpen. WPF biedt geometrieën om een aangepaste vorm te maken die rechtstreeks kan worden getekend, gebruikt als borstel of gebruikt om andere vormen en besturingselementen te knippen.

Zie Geometrieoverzichtvoor meer informatie.

Een subset van WPF 2D-mogelijkheden omvat visuele effecten, zoals kleurovergangen, bitmaps, tekeningen, schilderen met video's, draaien, schalen en scheven. Deze effecten worden allemaal bereikt met borstels. In de volgende afbeelding ziet u enkele voorbeelden:

Zie overzicht van WPF-borstelsvoor meer informatie.

3D-rendering

WPF bevat ook 3D-renderingmogelijkheden die kunnen worden geïntegreerd met 2D-afbeeldingen om het creëren van interessantere en interessantere gebruikersinterfaces mogelijk te maken. In de volgende afbeelding ziet u bijvoorbeeld 2D-afbeeldingen die worden weergegeven op 3D-shapes:

Zie 3D-afbeeldingenoverzichtvoor meer informatie.

Animatie

Met WPF-animatieondersteuning kunt u besturingselementen laten groeien, schudden, draaien en vervagen, om interessante paginaovergangen te maken, en meer. U kunt de meeste WPF-klassen animeren, zelfs aangepaste klassen. In de volgende afbeelding ziet u een eenvoudige animatie in actie:

Zie Animatieoverzichtvoor meer informatie.

Tekst en typografie

WpF biedt de volgende functies om tekstweergave van hoge kwaliteit te bieden:

• Ondersteuning voor OpenType-lettertypen.
• ClearType-verbeteringen.
• Hoge prestaties die profiteren van hardwareversnelling.
• Integratie van tekst met media, afbeeldingen en animaties.
• Internationale lettertypeondersteuning en terugvalmechanismen.

Als demonstratie van tekstintegratie met afbeeldingen toont de volgende afbeelding de toepassing van tekstdecoraties:

Zie Typografie in Windows Presentation Foundationvoor meer informatie.

WPF-apps aanpassen

Tot nu toe hebt u de belangrijkste WPF-bouwstenen voor het ontwikkelen van toepassingen gezien:

• U gebruikt het toepassingsmodel om toepassingsinhoud te hosten en te leveren, die voornamelijk uit besturingselementen bestaat.
• Om de rangschikking van besturingselementen in een gebruikersinterface te vereenvoudigen, gebruikt u het WPF-indelingssysteem.
• U gebruikt gegevensbinding om het werk van de integratie van uw gebruikersinterface met gegevens te verminderen.
• Om het uiterlijk van uw toepassing te verbeteren, gebruikt u het uitgebreide scala aan afbeeldingen, animaties en mediaondersteuning van WPF.

Vaak zijn de basisprincipes echter niet voldoende voor het maken en beheren van een echt unieke en visueel verbluffende gebruikerservaring. De standaard WPF-besturingselementen kunnen niet worden geïntegreerd met het gewenste uiterlijk van uw toepassing. Gegevens worden mogelijk niet op de meest effectieve manier weergegeven. De algehele gebruikerservaring van uw toepassing is mogelijk niet geschikt voor het standaard uiterlijk van Windows-thema's.

Daarom biedt WPF verschillende mechanismen voor het maken van unieke gebruikerservaringen.

Inhoudsmodel

Het belangrijkste doel van de meeste WPF-besturingselementen is om inhoud weer te geven. In WPF wordt het type en het aantal items dat de inhoud van een besturingselement kan vormen, het inhoudsmodel van het besturingselementgenoemd. Sommige besturingselementen kunnen één item en een bepaald type inhoud bevatten. De inhoud van een TextBox is bijvoorbeeld een tekenreekswaarde die is toegewezen aan de eigenschap Text.

Andere besturingselementen kunnen echter meerdere items van verschillende soorten inhoud bevatten; de inhoud van een Button, die is opgegeven door de eigenschap Content, kan verschillende items bevatten, waaronder indelingsbesturingselementen, tekst, afbeeldingen en vormen.

Zie WPF-inhoudsmodelvoor meer informatie over de soorten inhoud die wordt ondersteund door verschillende besturingselementen.

Triggers

Hoewel het belangrijkste doel van XAML-markeringen is om het uiterlijk van een toepassing te implementeren, kunt u ook XAML gebruiken om bepaalde aspecten van het gedrag van een toepassing te implementeren. Een voorbeeld is het gebruik van triggers om het uiterlijk van een toepassing te wijzigen op basis van gebruikersinteracties. Zie stijlen en sjablonenvoor meer informatie.

Sjablonen

De standaardgebruikersinterfaces voor WPF-besturingselementen worden doorgaans samengesteld uit andere besturingselementen en vormen. Een Button bestaat bijvoorbeeld uit zowel ButtonChrome als ContentPresenter besturingselementen. De ButtonChrome biedt de standaardweergave van de knop, terwijl de ContentPresenter de inhoud van de knop weergeeft, zoals opgegeven door de eigenschap Content.

Soms kan de standaardweergave van een besturingselement conflicteren met het algehele uiterlijk van een toepassing. In dit geval kunt u een ControlTemplate gebruiken om het uiterlijk van de gebruikersinterface van het besturingselement te wijzigen zonder de inhoud en het gedrag ervan te wijzigen.

Een Button activeert bijvoorbeeld de Click gebeurtenis wanneer erop wordt geklikt. Door de sjabloon van een knop te wijzigen om een Ellipse-vorm weer te geven, is het uiterlijk van het bedieningselement veranderd, maar de functionaliteit is onveranderd gebleven. U kunt nog steeds klikken op het visuele aspect van het besturingselement en de Click gebeurtenis wordt gegenereerd zoals verwacht.

Gegevenssjablonen

Terwijl u met een besturingselementsjabloon het uiterlijk van een besturingselement kunt opgeven, kunt u met een gegevenssjabloon het uiterlijk van de inhoud van een besturingselement opgeven. Gegevenssjablonen worden vaak gebruikt om te verbeteren hoe afhankelijke gegevens worden weergegeven. In de volgende afbeelding ziet u de standaardweergave voor een ListBox die is gebonden aan een verzameling Task objecten, waarbij elke taak een naam, beschrijving en prioriteit heeft:

De standaardweergave is wat u zou verwachten van een ListBox. De standaardweergave van elke taak bevat echter alleen de naam van de taak. Als u de taaknaam, beschrijving en prioriteit wilt weergeven, moet de standaardweergave van de afhankelijke lijstitems van het besturingselement ListBox worden gewijzigd met behulp van een DataTemplate. Hier volgt een voorbeeld van het toepassen van een gegevenssjabloon die is gemaakt voor het Task-object.

De ListBox behoudt het gedrag en het algehele uiterlijk en alleen het uiterlijk van de inhoud die door de keuzelijst wordt weergegeven, is gewijzigd.

Zie voor meer informatie Overzicht van gegevenssjablonering.

Stijlen

Met stijlen kunnen ontwikkelaars en ontwerpers hun product standaardiseren op een bepaald uiterlijk. WPF biedt een sterk stijlmodel, waarvan de basis het Style element is. Stijlen kunnen eigenschapswaarden toepassen op typen. Ze kunnen automatisch worden toegepast op alles op basis van het type of afzonderlijke objecten wanneer ernaar wordt verwezen. In het volgende voorbeeld wordt een stijl gemaakt waarmee de achtergrondkleur voor elke Button in het venster wordt ingesteld op Orange:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.StyleWindow"
    Title="Styles">

    <Window.Resources>
        <!-- Style that will be applied to all buttons for this window -->
        <Style TargetType="{x:Type Button}">
            <Setter Property="Background" Value="Orange" />
            <Setter Property="BorderBrush" Value="Crimson" />
            <Setter Property="FontSize" Value="20" />
            <Setter Property="FontWeight" Value="Bold" />
            <Setter Property="Margin" Value="5" />
        </Style>
    </Window.Resources>
    <StackPanel>

        <!-- This button will have the style applied to it -->
        <Button>Click Me!</Button>

        <!-- This label will not have the style applied to it -->
        <Label>Don't Click Me!</Label>

        <!-- This button will have the style applied to it -->
        <Button>Click Me!</Button>
        
    </StackPanel>
</Window>

Omdat deze stijl gericht is op alle Button besturingselementen, wordt de stijl automatisch toegepast op alle knoppen in het venster, zoals wordt weergegeven in de volgende afbeelding:

Zie stijlen en sjablonenvoor meer informatie.

Middelen

Besturingselementen in een toepassing moeten hetzelfde uiterlijk hebben, wat kan variëren van lettertypen en achtergrondkleuren tot besturingssjablonen, gegevenssjablonen en stijlen. U kunt de ondersteuning van WPF voor resources van de gebruikersinterface gebruiken om deze resources op één locatie in te kapselen voor hergebruik.

In het volgende voorbeeld wordt een gemeenschappelijke achtergrondkleur gedefinieerd die wordt gedeeld door een Button en een Label:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ResourcesWindow"
    Title="Resources Window">

  <!-- Define window-scoped background color resource -->
  <Window.Resources>
    <SolidColorBrush x:Key="defaultBackground" Color="Red" />
  </Window.Resources>

  <!-- Button background is defined by window-scoped resource -->
  <Button Background="{StaticResource defaultBackground}">One Button</Button>

  <!-- Label background is defined by window-scoped resource -->
  <Label Background="{StaticResource defaultBackground}">One Label</Label>
</Window>

Zie Een WPF-resource definiëren en ernaar verwijzenvoor meer informatie.

Aangepaste bedieningselementen

Hoewel WPF een groot aantal aanpassingsondersteuning biedt, kunnen er situaties optreden waarin bestaande WPF-besturingselementen niet voldoen aan de behoeften van uw toepassing of de gebruikers ervan. Dit kan gebeuren wanneer:

• De gebruikersinterface die u nodig hebt, kan niet worden gemaakt door het uiterlijk van bestaande WPF-implementaties aan te passen.
• Het gedrag dat u nodig hebt, wordt niet ondersteund (of niet eenvoudig ondersteund) door bestaande WPF-implementaties.

Op dit moment kunt u echter profiteren van een van de drie WPF-modellen om een nieuw besturingselement te maken. Elk model is gericht op een specifiek scenario en vereist dat uw aangepaste controle moet afleiden van een bepaalde WPF-basisklasse. De drie modellen worden hier vermeld:

• gebruikersbeheermodel
  Een aangepast besturingselement is afgeleid van UserControl en bestaat uit een of meer andere besturingselementen.

• Control Model Een aangepast besturingselement is afgeleid van Control en wordt gebruikt om implementaties te bouwen die hun gedrag scheiden van hun uiterlijk met behulp van sjablonen, vergelijkbaar met de meeste WPF-besturingselementen. Als u afgeleid bent van Control hebt u meer vrijheid voor het maken van een aangepaste gebruikersinterface dan gebruikersbesturingselementen, maar het kan meer moeite vergen.

• Framework-elementmodel.
  Een aangepast besturingselement erft van FrameworkElement wanneer het uiterlijk wordt bepaald door aangepaste weergavelogica (niet door sjablonen).

Zie Overzicht van het ontwerpen van besturingselementenvoor meer informatie over aangepaste besturingselementen.

Zie ook

• Zelfstudie: Een nieuwe WPF-app maken
• Een WPF-app migreren naar .NET-
• Overzicht van WPF-vensters
• Overzicht van gegevensbinding
• Overzicht van XAML