Übersicht über Windows Presentation Foundation

Willkommen beim Desktophandbuch für Windows Presentation Foundation (WPF), einem Benutzeroberflächenframework, das auflösungsunabhängig ist und ein vektorbasiertes Renderingmodul verwendet, das für die Nutzung moderner Grafikhardware erstellt wurde. WPF bietet einen umfassenden Satz von Anwendungsentwicklungsfeatures, die Extensible Application Markup Language (XAML), Steuerelemente, Datenbindung, Layout, 2D- und 3D-Grafiken, Animationen, Stile, Vorlagen, Dokumente, Medien, Text und Typografie enthalten. WPF ist Teil von .NET. Sie können also Anwendungen erstellen, die andere Elemente der .NET-API beinhalten.

Es gibt zwei Implementierungen von WPF:

1. .NET-Version (dieses Handbuch):

   Eine Open-Source-Implementierung von WPF, die auf GitHub gehostet wird, die auf .NET ausgeführt wird. Der XAML-Designer erfordert mindestens Visual Studio 2019, Version 16.8. Je nach Ihrer Version von .NET müssen Sie jedoch möglicherweise eine neuere Version von Visual Studio verwenden.

   Obwohl .NET eine plattformübergreifende Technologie ist, wird WPF nur unter Windows ausgeführt.

2. .NET Framework 4-Version :

   Die .NET Framework-Implementierung von WPF, die von Visual Studio 2019 und Visual Studio 2017 unterstützt wird.

   .NET Framework 4 ist eine reine Windows-Version von .NET und wird als Komponente des Windows-Betriebssystems betrachtet. Diese Version von WPF wird mit .NET Framework verteilt.

Diese Übersicht richtet sich an Neulinge und deckt die wichtigsten Funktionen und Konzepte von WPF ab. Informationen zum Erstellen einer WPF-App finden Sie im Lernprogramm: Erstellen einer neuen WPF-App.

Gründe für das Upgrade von .NET Framework

Wenn Sie ihre Anwendung von .NET Framework auf .NET aktualisieren, profitieren Sie von folgenden Vorteilen:

• Bessere Leistung
• Neue .NET-APIs
• Die neuesten Sprachverbesserungen
• Verbesserte Barrierefreiheit und Zuverlässigkeit
• Aktualisierte Tools und vieles mehr

Informationen zum Upgrade Ihrer Anwendung finden Sie unter Aktualisieren einer WPF-Desktop-App auf .NET.

Programm mit WPF

WPF ist als Teilmenge von .NET-Typen vorhanden, die sich hauptsächlich im System.Windows Namespace befinden. Wenn Sie bereits Anwendungen mit .NET unter Verwendung von Frameworks wie ASP.NET und Windows Forms erstellt haben, sollte Ihnen die grundlegende WPF-Programmiererfahrung vertraut sein.

• Instanziieren von Klassen
• Eigenschaften festlegen
• Methoden aufrufen
• Behandeln von Ereignissen

WPF enthält weitere Programmierkonstrukte, die Eigenschaften und Ereignisse verbessern: Abhängigkeitseigenschaften und Routingereignisse.

Markup und Code-Behind

Mit WPF können Sie eine Anwendung mit Markup und CodeBehind entwickeln, einer Erfahrung, mit der ASP.NET Entwickler vertraut sein sollten. In der Regel verwenden Sie XAML-Markup, um die Darstellung einer Anwendung zu implementieren, während Sie verwaltete Programmiersprachen (CodeBehind) verwenden, um das Verhalten zu implementieren. Diese Trennung von Aussehen und Verhalten hat die folgenden Vorteile:

• Die Entwicklungs- und Wartungskosten werden reduziert, da das Erscheinungsbild-spezifisches Markup nicht eng mit verhaltensspezifischem Code gekoppelt ist.

• Die Entwicklung ist effizienter, da Designer die Darstellung einer Anwendung gleichzeitig mit Entwicklern implementieren können, die das Verhalten der Anwendung implementieren.

• Die Globalisierung und Lokalisierung für WPF-Anwendungen wird vereinfacht.

Preisaufschlag

XAML ist eine XML-basierte Markupsprache, die die Darstellung einer Anwendung deklarativ implementiert. In der Regel verwenden Sie sie zum Definieren von Fenstern, Dialogfeldern, Seiten und Benutzersteuerelementen und zum Ausfüllen mit Steuerelementen, Formen und Grafiken.

Im folgenden Beispiel wird XAML verwendet, um die Darstellung eines Fensters zu implementieren, das eine einzelne Schaltfläche enthält:

<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>

Insbesondere definiert dieser XAML ein Fenster und eine Schaltfläche durch die Verwendung der Elemente Window und Button. Jedes Element ist mit Attributen konfiguriert, wie zum Beispiel das Element Window mit dem Attribut Title, um den Text der Titelleiste des Fensters anzugeben. Zur Laufzeit konvertiert WPF die Elemente und Attribute, die im Markup definiert sind, in Instanzen von WPF-Klassen. Beispielsweise wird das Window Element in eine Instanz der Window Klasse konvertiert, deren Title Eigenschaft der Wert des Title Attributs ist.

Die folgende Abbildung zeigt die Benutzeroberfläche (UI), die vom XAML-Code im vorherigen Beispiel definiert wird:

Da XAML XML-basiert, wird die Benutzeroberfläche, mit der Sie verfassen, in einer Hierarchie von geschachtelten Elementen zusammengestellt, die als Elementstruktur bezeichnet wird. Die Elementstruktur bietet eine logische und intuitive Möglichkeit zum Erstellen und Verwalten von UIs.

CodeBehind

Das Hauptverhalten einer Anwendung besteht darin, die Funktionalität zu implementieren, die auf Benutzerinteraktionen reagiert. Klicken Sie beispielsweise auf ein Menü oder eine Schaltfläche, und rufen Sie Geschäftslogik und Datenzugriffslogik in Reaktion auf. In WPF wird dieses Verhalten in Code implementiert, der mit Markup verknüpft ist. Dieser Codetyp wird als CodeBehind bezeichnet. Das folgende Beispiel zeigt das aktualisierte Markup aus dem vorherigen Beispiel und den 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>

Das aktualisierte Markup definiert den xmlns:x Namespace und ordnet ihn dem Schema zu, das Unterstützung für die CodeBehind-Typen hinzufügt. Das x:Class Attribut wird verwendet, um diesem spezifischen XAML-Markup eine CodeBehind-Klasse zuzuordnen. Wenn dieses Attribut für das <Window> Element deklariert wird, muss die CodeBehind-Klasse von der Window Klasse erben.

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 wird vom CodeBehind-Klassenkonstruktor aufgerufen, um die benutzeroberfläche zusammenzuführen, die im Markup mit der CodeBehind-Klasse definiert ist. (InitializeComponent wird für Sie generiert, wenn Ihre Anwendung erstellt wird, weshalb Sie sie nicht manuell implementieren müssen.) Die Kombination aus x:Class und InitializeComponent stellen Sie sicher, dass Ihre Implementierung immer dann ordnungsgemäß initialisiert wird, wenn sie erstellt wird.

Beachten Sie, dass im Markup das <Button>-Element für das Click-Attribut einen Wert von button_Click definiert hat. Sobald Markup und CodeBehind initialisiert sind und zusammenarbeiten, wird das Click-Ereignis für die Schaltfläche automatisch der button_Click-Methode zugeordnet. Wenn auf die Schaltfläche geklickt wird, wird der Ereignishandler aufgerufen, und ein Meldungsfeld wird durch Aufrufen der System.Windows.MessageBox.Show Methode angezeigt.

Die folgende Abbildung zeigt das Ergebnis, wenn auf die Schaltfläche geklickt wird:

Eingaben und Befehle

Steuerelemente erkennen und reagieren am häufigsten auf Benutzereingaben. Das WPF-Eingabesystem verwendet sowohl direkte als auch routingfähige Ereignisse, um Texteingabe, Fokusverwaltung und Mauspositionierung zu unterstützen.

Anwendungen haben häufig komplexe Eingabeanforderungen. WPF stellt ein Befehlssystem bereit, das Benutzereingabeaktionen vom Code trennt, der auf diese Aktionen reagiert. Das Befehlssystem ermöglicht es mehreren Quellen, dieselbe Befehlslogik aufzurufen. Nehmen Sie beispielsweise die gängigen Bearbeitungsvorgänge, die von verschiedenen Anwendungen verwendet werden: Kopieren, Ausschneiden und Einfügen. Diese Vorgänge können mithilfe verschiedener Benutzeraktionen aufgerufen werden, wenn sie mithilfe von Befehlen implementiert werden.

Bedienelemente

Vom Anwendungsmodell bereitgestellte Benutzererfahrungen setzen sich aus konstruierten Steuerungen zusammen. In WPF ist das Steuerelement ein Dachbegriff, der für eine Kategorie von WPF-Klassen gilt, die die folgenden Merkmale aufweisen:

• In einem Fenster oder auf einer Seite gehostet.
• Verwenden Sie eine Benutzeroberfläche.
• Implementieren Sie ein bestimmtes Verhalten.

Weitere Informationen finden Sie unter Steuerelemente.

WPF-Steuerelemente nach Funktion

Die integrierten WPF-Steuerelemente sind hier aufgeführt:

• Schaltflächen: Button und RepeatButton.

• Datenanzeige: DataGrid, ListView, und TreeView.

• Datumsanzeige und Auswahl: Calendar und DatePicker.

• Dialogfelder: OpenFileDialog, PrintDialog, und SaveFileDialog.

• Digitale Tinte: InkCanvas und InkPresenter.

• Dokumente: DocumentViewer, , FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollViewerund StickyNoteControl.

• Eingabe: TextBox, RichTextBox, und PasswordBox.

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

• Medien: Image, MediaElement, und SoundPlayerAction.

• Menüs: ContextMenu, Menu, und ToolBar.

• Navigation: Frame, , Hyperlink, Page, NavigationWindowund TabControl.

• Auswahl: CheckBox, , ComboBox, ListBox, RadioButtonund Slider.

• Benutzerinformationen: AccessText, , Label, Popup, ProgressBar, StatusBar, , TextBlockund ToolTip.

Gestaltung

Wenn Sie eine Benutzeroberfläche erstellen, ordnen Sie Ihre Steuerelemente nach Position und Größe an, um ein Layout zu bilden. Eine wichtige Voraussetzung für jedes Layout ist die Anpassung an Änderungen der Fenstergröße und der Anzeigeeinstellungen. Anstatt sie zu zwingen, den Code zu schreiben, um ein Layout unter diesen Umständen anzupassen, stellt WPF ein erstklassiges, erweiterbares Layoutsystem für Sie bereit.

Der Eckpfeiler des Layoutsystems ist die relative Positionierung, wodurch sich die Anpassung an die Sich ändernden Fenster- und Anzeigebedingungen erhöht. Das Layoutsystem verwaltet auch die Aushandlung zwischen Steuerelementen, um das Layout zu bestimmen. Bei der Aushandlung handelt es sich um einen zweistufigen Prozess: Zuerst teilt ein Steuerelement dem übergeordneten Element mit, welcher Speicherort und welche Größe es benötigt. Zweitens teilt das übergeordnete Element dem Steuerelement mit, über welchen Platz es verfügen kann.

Das Layoutsystem wird für Kindersteuerungselemente über grundlegende WPF-Klassen verfügbar gemacht. Bei gängigen Layouts wie Rastern, Stapeln und Andocken umfasst WPF mehrere Layoutsteuerelemente:

• Canvas: Untergeordnete Steuerelemente stellen ein eigenes Layout bereit.

• DockPanel: Untergeordnete Steuerelemente werden an den Rändern des Panels ausgerichtet.

• Grid: Untergeordnete Steuerelemente werden durch Zeilen und Spalten positioniert.

• StackPanel: Untergeordnete Steuerelemente werden vertikal oder horizontal gestapelt.

• VirtualizingStackPanel: Untergeordnete Steuerelemente sind virtualisiert und auf einer einzelnen Linie angeordnet, die entweder horizontal oder vertikal ausgerichtet ist.

• WrapPanel: Untergeordnete Steuerelemente werden in der Reihenfolge von links nach rechts positioniert und in die nächste Zeile eingeschlossen, wenn nicht genügend Platz in der aktuellen Zeile vorhanden ist.

Im folgenden Beispiel wird ein DockPanel genutzt, um mehrere TextBox Steuerelemente anzuordnen.

<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>

Das DockPanel erlaubt es den untergeordneten TextBox Steuerelementen, ihm mitzuteilen, wie sie angeordnet werden sollen. Dazu implementiert DockPanel eine von Dock definierte angefügte Eigenschaft, die den untergeordneten Steuerelementen bereitgestellt wird, damit jedes von ihnen einen Dockstil angeben kann.

Hinweis

Eine Eigenschaft, die von einem übergeordneten Steuerelement für die Verwendung durch untergeordnete Steuerelemente implementiert wird, ist ein WPF-Konstrukt, das als angefügte Eigenschaft bezeichnet wird.

Die folgende Abbildung zeigt das Ergebnis des XAML-Markups im vorherigen Beispiel:

Datenbindung

Die meisten Anwendungen werden erstellt, um Benutzern die Möglichkeit zu bieten, Daten anzuzeigen und zu bearbeiten. Für WPF-Anwendungen wird die Arbeit zum Speichern und Zugreifen auf Daten bereits von vielen verschiedenen .NET-Datenzugriffsbibliotheken wie SQL und Entity Framework Core bereitgestellt. Nachdem auf die Daten zugegriffen und in die verwalteten Objekte einer Anwendung geladen wurde, beginnt die harte Arbeit für WPF-Anwendungen. Im Wesentlichen umfasst dies zwei Dinge:

1. Kopieren der Daten aus den verwalteten Objekten in Steuerelemente, in denen die Daten angezeigt und bearbeitet werden können.

2. Sicherstellen, dass Änderungen, die mithilfe von Steuerelementen an Daten vorgenommen wurden, wieder in die verwalteten Objekte kopiert werden.

Um die Anwendungsentwicklung zu vereinfachen, bietet WPF ein leistungsfähiges Datenbindungsmodul, das diese Schritte automatisch verarbeitet. Die Kerneinheit des Datenbindungsmoduls ist die Binding Klasse, deren Auftrag darin besteht, ein Steuerelement (das Bindungsziel) an ein Datenobjekt (die Bindungsquelle) zu binden. Diese Beziehung wird in der folgenden Abbildung veranschaulicht:

WPF unterstützt das direkte Deklarieren von Bindungen im XAML-Markup. Der folgende XAML-Code bindet z. B. die Text Eigenschaft des TextBox Objekts mithilfe der XAML-Syntax "{Binding ... }" an die Name Eigenschaft eines Objekts. Dabei wird davon ausgegangen, dass ein Datenobjekt der DataContext Eigenschaft des Window mit einer Name Eigenschaft zugewiesen ist.

<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>

Das WPF-Datenbindungsmodul bietet mehr als nur Bindung, bietet Validierung, Sortierung, Filterung und Gruppierung. Darüber hinaus unterstützt die Datenbindung die Verwendung von Datenvorlagen zum Erstellen einer benutzerdefinierten Benutzeroberfläche für gebundene Daten.

Weitere Informationen finden Sie in der Übersicht über die Datenbindung.

Grafiken und Animationen

WPF bietet einen umfangreichen und flexiblen Satz von Grafikfeatures, die die folgenden Vorteile haben:

• Auflösungsunabhängige und geräteunabhängige Grafiken. Die Grundlegende Maßeinheit im WPF-Grafiksystem ist das geräteunabhängige Pixel, das 1/96. Zoll beträgt und die Grundlage für auflösungsunabhängiges und geräteunabhängiges Rendering bietet. Jedes geräteunabhängige Pixel wird automatisch entsprechend der Dpi-Einstellung (Dots-per-Inch) des Systems skaliert, auf dem es gerendert wird.

• Verbesserte Präzision. Das WPF-Koordinatensystem wird mit Gleitkommazahlen mit doppelter Genauigkeit und nicht mit einfacher Genauigkeit gemessen. Transformationen und Deckkraftwerte werden auch mit doppelter Genauigkeit ausgedrückt. WPF unterstützt auch eine breite Farbskala (scRGB) und bietet integrierte Unterstützung für die Verwaltung von Eingaben aus verschiedenen Farbräumen.

• Erweiterte Grafik- und Animationsunterstützung. WPF vereinfacht die Grafikprogrammierung, indem es Animationsszenen für Sie verwaltet. Es ist nicht nötig, sich um die Szenenverarbeitung, Renderingschleifen und bilineare Interpolation zu kümmern. Darüber hinaus bietet WPF Unterstützung für Treffertests und vollständige Alpha-Compositing-Unterstützung.

• Hardwarebeschleunigung. Das WPF-Grafiksystem nutzt Grafikhardware, um die CPU-Auslastung zu minimieren.

2D-Grafiken

WPF stellt eine Bibliothek allgemeiner vektorgezeichneter 2D-Formen bereit, z. B. Rechtecke und Ellipsen. Die Shapes dienen nicht nur der Anzeige; Shapes implementieren viele der Features, die Sie von Steuerelementen erwarten, einschließlich Tastatur- und Mauseingabe.

Die von WPF bereitgestellten 2D-Shapes decken den Standardsatz von Basis-Shapes ab. Möglicherweise müssen Sie jedoch benutzerdefinierte Shapes erstellen, um das Entwerfen einer benutzerdefinierten Benutzeroberfläche zu unterstützen. WPF stellt Geometrien bereit, um ein benutzerdefiniertes Shape zu erstellen, das direkt gezeichnet werden kann, als Pinsel verwendet oder zum Abschneiden anderer Formen und Steuerelemente verwendet werden kann.

Weitere Informationen finden Sie in der Geometry-Übersicht.

Eine Teilmenge der WPF 2D-Funktionen umfasst visuelle Effekte wie Farbverläufe, Bitmaps, Zeichnungen, Gemälde mit Videos, Drehung, Skalierung und Skewing. Diese Effekte werden alle mit Pinsel erreicht. Die folgende Abbildung zeigt einige Beispiele:

Weitere Informationen finden Sie in der Übersicht über WPF-Pinsel.

3D-Rendering

WPF enthält auch 3D-Renderingfunktionen, die in 2D-Grafiken integriert werden, um die Erstellung spannenderer und interessanterer Benutzeroberflächen zu ermöglichen. Die folgende Abbildung zeigt beispielsweise 2D-Bilder, die in 3D-Formen gerendert werden:

Weitere Informationen finden Sie in der Übersicht über 3D-Grafiken.

Animation

Mit der WPF-Animationsunterstützung können Sie Steuerelemente vergrößern, schütteln, drehen und ausblenden, um interessante Seitenübergänge zu erstellen und vieles mehr. Sie können die meisten WPF-Klassen animieren, sogar benutzerdefinierte Klassen. Die folgende Abbildung zeigt eine einfache Animation in Aktion:

Weitere Informationen finden Sie unter "Animationsübersicht".

Text und Typografie

Um qualitativ hochwertiges Textrendering bereitzustellen, bietet WPF die folgenden Features:

• Unterstützung der OpenType-Schriftart.
• ClearType-Verbesserungen.
• Hohe Leistung, die die Hardwarebeschleunigung nutzt.
• Integration von Text in Medien, Grafiken und Animationen.
• Internationale Schriftartunterstützung und Fallbackmechanismen.

Als Demonstration der Textintegration in Grafiken zeigt die folgende Abbildung die Anwendung von Text-Dekorationen:

Weitere Informationen finden Sie unter Typografie in Windows Presentation Foundation.

Anpassen von WPF-Apps

Bis zu diesem Punkt haben Sie die wichtigsten WPF-Bausteine für die Entwicklung von Anwendungen gesehen:

• Sie verwenden das Anwendungsmodell zum Hosten und Bereitstellen von Anwendungsinhalten, die hauptsächlich aus Steuerelementen bestehen.
• Um die Anordnung von Steuerelementen in einer Benutzeroberfläche zu vereinfachen, verwenden Sie das WPF-Layoutsystem.
• Sie verwenden Datenbindung, um die Integration Ihrer Benutzeroberfläche mit Daten zu reduzieren.
• Um das visuelle Erscheinungsbild Ihrer Anwendung zu verbessern, verwenden Sie das umfassende Spektrum an Grafiken, Animationen und Medien, die von WPF bereitgestellt werden.

Häufig reichen die Grundlagen jedoch nicht aus, um eine wirklich eindeutige und visuell beeindruckende Benutzererfahrung zu erstellen und zu verwalten. Die standardmäßigen WPF-Steuerelemente können möglicherweise nicht in die gewünschte Darstellung Ihrer Anwendung integriert werden. Daten werden möglicherweise nicht auf die effektivste Weise angezeigt. Die allgemeine Benutzererfahrung Ihrer Anwendung eignet sich möglicherweise nicht für das Standardmäßige Erscheinungsbild von Windows-Designs.

Aus diesem Grund bietet WPF verschiedene Mechanismen zum Erstellen eindeutiger Benutzeroberflächen.

Inhaltsmodell

Der Hauptzweck der meisten WPF-Steuerelemente ist das Anzeigen von Inhalten. In WPF wird der Typ und die Anzahl der Elemente, die den Inhalt eines Steuerelements darstellen können, als Inhaltsmodell des Steuerelements bezeichnet. Einige Steuerelemente können ein einzelnes Element und einen Inhaltstyp enthalten. Der Inhalt einer TextBox Zeichenfolge ist beispielsweise ein Zeichenfolgenwert, der der Text Eigenschaft zugewiesen ist.

Andere Steuerelemente können jedoch mehrere Elemente unterschiedlicher Inhaltstypen enthalten; Der Inhalt eines Buttondurch die Content Eigenschaft angegebenen Inhalts kann verschiedene Elemente enthalten, darunter Layoutsteuerelemente, Text, Bilder und Formen.

Weitere Informationen zu den Arten von Inhalten, die von verschiedenen Steuerelementen unterstützt werden, finden Sie im WPF-Inhaltsmodell.

Auslöser

Obwohl der Hauptzweck des XAML-Markups darin besteht, die Darstellung einer Anwendung zu implementieren, können Sie auch XAML verwenden, um einige Aspekte des Verhaltens einer Anwendung zu implementieren. Ein Beispiel ist die Verwendung von Triggern, um die Darstellung einer Anwendung basierend auf Benutzerinteraktionen zu ändern. Weitere Informationen finden Sie unter "Formatvorlagen und Vorlagen".

Schablonen

Die Standardbenutzeroberflächen für WPF-Steuerelemente werden in der Regel aus anderen Steuerelementen und Shapes erstellt. Beispielsweise besteht ein Button Steuerelement aus beiden ButtonChrome und ContentPresenter Steuerelementen. Das ButtonChrome bietet eine standardmäßige Schaltflächendarstellung, während das ContentPresenter den Inhalt der Schaltfläche gemäß der Content-Eigenschaft darstellt.

Manchmal kann die Standarddarstellung eines Steuerelements mit der Gesamtdarstellung einer Anwendung in Konflikt treten. In diesem Fall können Sie ein ControlTemplate verwenden, um die Darstellung der Benutzeroberfläche des Steuerelements zu ändern, ohne dessen Inhalt und Verhalten zu verändern.

Beispielsweise löst ein Button das Ereignis Click aus, wenn darauf geklickt wird. Durch das Ändern der Vorlage einer Schaltfläche zur Anzeige einer Ellipse Form hat sich die visuelle Erscheinung des Steuerelements verändert, die Funktionalität jedoch nicht. Sie können weiterhin auf den visuellen Aspekt des Steuerelements klicken, damit das Click Ereignis wie erwartet ausgelöst wird.

Datenvorlagen

Mit einer Steuerelementvorlage können Sie zwar das Erscheinungsbild eines Steuerelements angeben, aber mit einer Datenvorlage können Sie die Darstellung des Inhalts eines Steuerelements angeben. Datenvorlagen werden häufig verwendet, um die Anzeige gebundener Daten zu verbessern. Die folgende Abbildung zeigt die Standarddarstellung für ein ListBox Objekt, das an eine Auflistung von Task Objekten gebunden ist, wobei jede Aufgabe einen Namen, eine Beschreibung und priorität hat:

Die Standarddarstellung ist das, was Sie von einer ListBox erwarten würden. Die Standarddarstellung jeder Aufgabe enthält jedoch nur den Aufgabennamen. Um den Aufgabennamen, die Beschreibung und die Priorität anzuzeigen, muss die Standarddarstellung der gebundenen Listenelemente des ListBox-Steuerelements mithilfe eines DataTemplate geändert werden. Nachfolgend sehen Sie ein Beispiel für das Anwenden einer Datenvorlage, die für das Task Objekt erstellt wurde.

Das ListBox Verhalten und die allgemeine Darstellung bleiben erhalten, und nur die Darstellung des Inhalts, der vom Listenfeld angezeigt wird, wurde geändert.

Weitere Informationen finden Sie unter Übersicht über Datenvorlagen.

Stile

Stile ermöglichen Entwicklern und Designern, ein bestimmtes Erscheinungsbild für ihr Produkt zu standardisieren. WPF stellt ein starkes Formatmodell bereit, dessen Grundlage das Style Element ist. Stile können Eigenschaftswerte auf Typen anwenden. Sie können automatisch auf alles angewendet werden, je nach Typ oder einzelnen Objekten, wenn auf sie verwiesen wird. Im folgenden Beispiel wird eine Formatvorlage erstellt, die die Hintergrundfarbe für jedes Button auf dem Fenster in Orange ändert.

<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>

Da diese Formatvorlage auf alle Button Steuerelemente ausgerichtet ist, wird die Formatvorlage automatisch auf alle Schaltflächen im Fenster angewendet, wie in der folgenden Abbildung dargestellt:

Weitere Informationen finden Sie unter "Formatvorlagen und Vorlagen".

Ressourcen

Steuerelemente in einer Anwendung sollten das gleiche Erscheinungsbild aufweisen, das alles aus Schriftarten und Hintergrundfarben bis hin zu Steuerelementvorlagen, Datenvorlagen und Formatvorlagen umfassen kann. Sie können die Unterstützung von WPF für Benutzeroberflächenressourcen verwenden, um diese Ressourcen an einem einzigen Speicherort für die Wiederverwendung zu kapseln.

Im folgenden Beispiel wird eine allgemeine Hintergrundfarbe definiert, die von einer Button und einer Labelfreigegeben wird:

<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>

Weitere Informationen finden Sie unter Definieren und Verweisen auf eine WPF-Ressource.

Benutzerdefinierte Steuerelemente

Obwohl WPF eine Vielzahl von Anpassungsmöglichkeiten bietet, können Sie in Situationen auftreten, in denen vorhandene WPF-Steuerelemente nicht den Anforderungen Ihrer Anwendung oder ihrer Benutzer entsprechen. Dies kann auftreten, wenn:

• Die von Ihnen benötigte Benutzeroberfläche kann nicht durch Anpassen des Erscheinungsbilds vorhandener WPF-Implementierungen erstellt werden.
• Das erforderliche Verhalten wird von vorhandenen WPF-Implementierungen nicht unterstützt (oder nicht leicht unterstützt).

An diesem Punkt können Sie jedoch eines von drei WPF-Modellen nutzen, um ein neues Steuerelement zu erstellen. Jedes Modell zielt auf ein bestimmtes Szenario ab und erfordert, dass Ihr benutzerdefiniertes Steuerelement von einer bestimmten WPF-Basisklasse abgeleitet wird. Die drei Modelle sind hier aufgeführt:

• Benutzersteuerungsmodell
  Ein benutzerdefiniertes Steuerelement leitet sich von UserControl ab und setzt sich aus einem oder mehreren anderen Steuerelementen zusammen.

• Steuerelementmodell Ein benutzerdefiniertes Steuerelement stammt von Control ab und wird verwendet, um Implementierungen zu erstellen, bei denen das Verhalten mithilfe von Vorlagen von der Darstellung getrennt wird, ähnlich wie bei den meisten WPF-Steuerelementen. Die Ableitung von Control bietet Ihnen mehr Freiheit bei der Erstellung einer benutzerdefinierten Benutzeroberfläche als Steuerungselemente, kann jedoch mehr Aufwand erfordern.

• Framework-Elementmodell.
  Ein benutzerdefiniertes Steuerelement wird abgeleitet, FrameworkElement wenn seine Darstellung durch benutzerdefinierte Renderinglogik (nicht durch Vorlagen) definiert wird.

Weitere Informationen zu benutzerdefinierten Steuerelementen finden Sie unter Übersicht über das Erstellen von Steuerelementen.

Siehe auch

• Lernprogramm: Erstellen einer neuen WPF-App
• Migrieren einer WPF-App zu .NET
• Übersicht über WPF-Fenster
• Übersicht über die Datenbindung
• XAML-Übersicht