Freigeben über

Übersicht über Abhängigkeitseigenschaften

Windows Presentation Foundation (WPF) stellt eine Reihe von Diensten bereit, mit denen die Funktionalität der Eigenschaft eines Typs erweitert werden kann. Zusammenfassend werden diese Dienste als WPF-Eigenschaftensystem bezeichnet. Eine Eigenschaft, die vom WPF-Eigenschaftensystem unterstützt wird, wird als eine Abhängigkeitseigenschaft bezeichnet. Diese Übersicht beschreibt das WPF-Eigenschaftensystem und die Funktionen einer Abhängigkeitseigenschaft, einschließlich der Verwendung vorhandener Abhängigkeitseigenschaften in XAML und im Code. In dieser Übersicht werden auch spezielle Aspekte von Abhängigkeitseigenschaften wie Abhängigkeitseigenschaftsmetadaten und das Erstellen eigener Abhängigkeitseigenschaften in einer benutzerdefinierten Klasse vorgestellt.

Voraussetzungen

In diesem Artikel wird davon ausgegangen, dass Sie grundlegende Kenntnisse des .NET-Typsystems und der objektorientierten Programmierung kennen. Um den Beispielen in diesem Artikel zu folgen, hilft es ihnen, XAML zu verstehen und zu wissen, wie WPF-Anwendungen geschrieben werden. Weitere Informationen finden Sie im Lernprogramm: Erstellen einer neuen WPF-App mit .NET.

Abhängigkeitseigenschaften und CLR-Eigenschaften

WPF-Eigenschaften werden in der Regel als . NET-Standardeigenschaften verfügbar gemacht. Möglicherweise interagieren Sie mit diesen Eigenschaften auf einer grundlegenden Ebene und wissen nie, dass sie als Abhängigkeitseigenschaft implementiert sind. Wenn Sie jedoch mit einigen oder allen Features des WPF-Eigenschaftensystems vertraut sind, können Sie diese Features nutzen.

Der Zweck von Abhängigkeitseigenschaften besteht darin, den Wert einer Eigenschaft basierend auf dem Wert anderer Eingaben zu berechnen, z. B.:

  • Systemeigenschaften, z. B. Designs und Benutzereinstellungen.
  • Just-in-Time-Mechanismen zur Ermittlung von Eigenschaften, z. B. Datenbindung und Animationen/Storyboards.
  • Vorlagen zur Mehrfachverwendung, wie Ressourcen und Stile.
  • Werte, die durch Beziehungen zwischen übergeordneten und untergeordneten Elementen sowie weiteren Elementen in der Elementstruktur bekannt sind.

Außerdem kann eine Abhängigkeitseigenschaft Folgendes bereitstellen:

  • In sich geschlossene Validierung.
  • Standardwerte.
  • Callbacks, die Veränderungen an anderen Eigenschaften überwachen.
  • Ein System, das Eigenschaftswerte basierend auf Laufzeitinformationen erzwingen kann.

Abgeleitete Klassen können einige Merkmale einer vorhandenen Eigenschaft ändern, indem die Metadaten einer Abhängigkeitseigenschaft außer Kraft gesetzt werden, anstatt die tatsächliche Implementierung vorhandener Eigenschaften zu überschreiben oder neue Eigenschaften zu erstellen.

In der SDK-Referenz können Sie eine Abhängigkeitseigenschaft anhand des Vorhandenseins eines Abschnitts mit Abhängigkeitseigenschaften-Informationen auf der verwalteten Referenzseite für diese Eigenschaft identifizieren. Der Abschnitt "Dependency Property Information" enthält einen Link zum DependencyProperty Bezeichnerfeld für diese Abhängigkeitseigenschaft. Außerdem enthält sie die Liste der Metadatenoptionen für diese Eigenschaft, Informationen zur Außerkraftsetzung pro Klasse und weitere Details.

Abhängigkeitseigenschaften unterstützen CLR-Eigenschaften

Abhängigkeitseigenschaften und das WPF-Eigenschaftensystem erweitern die Eigenschaftsfunktionalität, indem ein Typ bereitgestellt wird, der eine Eigenschaft unterstützt, als Alternative zum Standardmuster der Sicherung einer Eigenschaft mit einem privaten Feld. Der Name dieses Typs lautet DependencyProperty. Der andere wichtige Typ, der das WPF-Eigenschaftensystem definiert, ist DependencyObject, das die Basisklasse definiert, die eine Abhängigkeitseigenschaft registrieren und besitzen kann.

Nachfolgend finden Sie einige häufig verwendete Terminologie:

  • Abhängigkeitseigenschaft, bei der es sich um eine Eigenschaft handelt, die von einem DependencyProperty unterstützt wird.

  • Bezeichner der Abhängigkeitseigenschaft, bei der es sich um eine DependencyProperty Instanz handelt, die beim Registrieren einer Abhängigkeitseigenschaft als Rückgabewert abgerufen und dann als statisches Element einer Klasse gespeichert wird. Viele der APIs, die mit dem WPF-Eigenschaftensystem interagieren, verwenden den Bezeichner der Abhängigkeitseigenschaft als Parameter.

  • CLR "wrapper", welche die Implementierungen von get und set für die Eigenschaft sind. Diese Implementierungen integrieren den Bezeichner der Abhängigkeitseigenschaft, indem er in den GetValue- und SetValue-Aufrufen verwendet wird. Auf diese Weise stellt das WPF-Eigenschaftensystem die Sicherung für die Eigenschaft bereit.

Im folgenden Beispiel wird die IsSpinning Abhängigkeitseigenschaft definiert, um die Beziehung des DependencyProperty Bezeichners zu der eigenschaft anzuzeigen, die sie zurückgibt.

public static readonly DependencyProperty IsSpinningProperty = DependencyProperty.Register(
    "IsSpinning", typeof(bool),
    typeof(MainWindow)
    );

public bool IsSpinning
{
    get => (bool)GetValue(IsSpinningProperty);
    set => SetValue(IsSpinningProperty, value);
}

Public Shared ReadOnly IsSpinningProperty As DependencyProperty =
    DependencyProperty.Register("IsSpinning", GetType(Boolean), GetType(MainWindow))

Public Property IsSpinning As Boolean
    Get
        Return GetValue(IsSpinningProperty)
    End Get
    Set(value As Boolean)
        SetValue(IsSpinningProperty, value)
    End Set
End Property

Die Benennungskonvention der Eigenschaft und des zugrunde liegenden DependencyProperty Felds ist wichtig. Der Name des Felds ist immer der Name der Eigenschaft, wobei das Suffix Property angefügt ist. Weitere Informationen zu dieser Konvention und den Gründen dafür finden Sie unter Benutzerdefinierte Abhängigkeitseigenschaften.

Festlegen von Eigenschaftswerten

Sie können Eigenschaften entweder im Code oder in XAML festlegen.

Festlegen von Eigenschaftswerten in XAML

Im folgenden XAML-Beispiel wird die Hintergrundfarbe einer Schaltfläche auf Rot festgelegt. Der Zeichenfolgenwert für das XAML-Attribut wird vom WPF-XAML-Parser in einen WPF-Typ konvertiert. Im generierten Code ist der WPF-Typ ein Color, mittels eines SolidColorBrush.

<Button Content="I am red" Background="Red"/>

XAML unterstützt mehrere Syntaxformulare zum Festlegen von Eigenschaften. Welche Syntax für eine bestimmte Eigenschaft verwendet werden soll, hängt vom Werttyp ab, den eine Eigenschaft verwendet, und anderen Faktoren, z. B. das Vorhandensein eines Typkonverters. Weitere Informationen zur XAML-Syntax zum Festlegen von Eigenschaften finden Sie unter XAML in WPF und XAML-Syntax im Detail

Das folgende XAML-Beispiel zeigt einen anderen Schaltflächenhintergrund, der anstelle der Attributsyntax eine Eigenschaftselementsyntax verwendet. Anstatt eine einfache Volltonfarbe festzulegen, legt der XAML-Code die Schaltflächeneigenschaft Background auf ein Bild fest. Ein Element stellt dieses Bild dar, und ein Attribut des geschachtelten Elements gibt die Quelle des Bilds an.

<Button Content="I have an image background">
    <Button.Background>
        <ImageBrush ImageSource="stripes.jpg"/>
    </Button.Background>
</Button>

Festlegen von Eigenschaften im Code

Das Festlegen von Abhängigkeitseigenschaftswerten im Code ist in der Regel nur ein Aufruf der Implementierung, die vom CLR-„Wrapper“ bereitgestellt wird:

Button myButton = new();
myButton.Width = 200.0;

Dim myButton As New Button With {
    .Width = 200.0
}

Das Abrufen eines Eigenschaftswerts ist im Wesentlichen ein Aufruf der get Wrapperimplementierung:

double whatWidth = myButton.Width;

Dim whatWidth As Double = myButton.Width

Sie können auch die Eigenschaftensystem-APIs GetValue und SetValue direkt aufrufen. Das direkte Aufrufen der APIs eignet sich für einige Szenarien, aber in der Regel nicht, wenn Sie vorhandene Eigenschaften verwenden. In der Regel sind Wrapper praktischer und bieten eine bessere Zugänglichkeit der Eigenschaft für Entwicklerwerkzeuge.

Eigenschaften können auch in XAML festgelegt und später im Code über CodeBehind aufgerufen werden. Ausführliche Informationen finden Sie unter Code-Behind und XAML in WPF

Eigenschaftsfunktionalität, die von einer Abhängigkeitseigenschaft bereitgestellt wird

Im Gegensatz zu einer Eigenschaft, die von einem Feld unterstützt wird, erweitert eine Abhängigkeitseigenschaft die Funktionalität einer Eigenschaft. Häufig stellt die hinzugefügte Funktionalität eines der folgenden Features dar oder unterstützt diese:

Ressourcen

Sie können einen Abhängigkeitseigenschaftswert festlegen, indem Sie auf eine Ressource verweisen. Ressourcen werden in der Resources Regel als Eigenschaftswert eines Seitenstammelements oder der Anwendung angegeben, da diese Speicherorte einen bequemen Zugriff auf die Ressource bieten. In diesem Beispiel definieren wir eine SolidColorBrush Ressource:

<StackPanel.Resources>
    <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
</StackPanel.Resources>

Nachdem die Ressource definiert ist, können wir auf die Ressource verweisen, um einen Wert für die Background Eigenschaft bereitzustellen:

<Button Background="{DynamicResource MyBrush}" Content="I am gold" />

In WPF-XAML können Sie entweder einen statischen oder dynamischen Ressourcenverweis verwenden. Auf diese spezielle Ressource wird als DynamicResource verwiesen.

Hinweis

Ressourcen werden als lokaler Wert behandelt. Wenn Sie einen anderen lokalen Wert festlegen, entfernen Sie den Ressourcenverweis. Weitere Informationen finden Sie unter Priorität von Abhängigkeitseigenschaftswerten.

Datenbindung

Eine Abhängigkeitseigenschaft kann über die Datenbindung auf einen Wert verweisen. Die Datenbindung funktioniert über eine bestimmte Markuperweiterungssyntax in XAML oder das Binding Objekt im Code. Bei der Datenbindung wird die Bestimmung des endgültigen Eigenschaftswerts bis zur Laufzeit zurückgestellt, zu dem der Wert aus einer Datenquelle abgerufen wird.

Im folgenden Beispiel wird die Content Eigenschaft für eine Button, mithilfe einer in XAML deklarierten Bindung festgelegt. Die Bindung verwendet einen geerbten Datenkontext und eine XmlDataProvider Datenquelle (nicht angezeigt). Die Bindung selbst gibt das Quellenelement innerhalb der Datenquelle durch XPath an.

<Button Content="{Binding Source={StaticResource TestData}, XPath=test[1]/@text}"/>

Hinweis

Bindungen werden als lokaler Wert behandelt. Wenn Sie einen anderen lokalen Wert festlegen, entfernen Sie die Bindung. Details können Sie unter Priorität der Abhängigkeitseigenschaft nachsehen.

Abhängigkeitseigenschaften oder die DependencyObject Klasse unterstützen nicht nativ INotifyPropertyChanged für Benachrichtigungen über Änderungen des DependencyObject Quelleigenschaftswertes für Datenbindungsvorgänge. Weitere Informationen zum Erstellen von Eigenschaften für die Verwendung in der Datenbindung, die Änderungen an einem Datenbindungsziel melden können, finden Sie in der Übersicht über die Datenbindung

Stile

Stile und Vorlagen sind überzeugende Gründe für die Verwendung von Abhängigkeitseigenschaften. Formatvorlagen eignen sich besonders zum Festlegen von Eigenschaften, die die Benutzeroberfläche der Anwendung definieren. Formatvorlagen werden in der Regel als Ressourcen in XAML definiert. Stile interagieren mit dem Eigenschaftensystem, da sie in der Regel "Setter" für bestimmte Eigenschaften enthalten, und "Trigger", die einen Eigenschaftswert basierend auf dem Laufzeitwert für eine andere Eigenschaft ändern.

Im folgenden Beispiel wird ein einfacher Stil erstellt, der innerhalb eines Resources Wörterbuchs definiert wird (nicht dargestellt). Dann wird die Formatvorlage direkt auf die Eigenschaft Style eines Button angewendet. Der Setter innerhalb des Stils setzt die Background Eigenschaft für ein gestyltes Button auf grün.

<Style x:Key="GreenButtonStyle">
    <Setter Property="Control.Background" Value="Green"/>
</Style>

<Button Style="{StaticResource GreenButtonStyle}" Content="I am green"/>

Weitere Informationen finden Sie unter "Formatieren und Vorlagen".

Animationen

Abhängigkeitseigenschaften können animiert werden. Wenn eine angewendete Animation ausgeführt wird, hat der animierte Wert eine höhere Priorität als jeder andere Eigenschaftswert, einschließlich eines lokalen Werts.

Im folgenden Beispiel wird die Background Eigenschaft eines Button animiert. Technisch setzt die Eigenschaftselementsyntax ein leeres SolidColorBrush als Background fest, und die Color-Eigenschaft des SolidColorBrush wird animiert.

<Button Content="I am animated">
    <Button.Background>
        <SolidColorBrush x:Name="AnimBrush"/>
    </Button.Background>
    <Button.Triggers>
        <EventTrigger RoutedEvent="FrameworkElement.Loaded">
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation
                        Storyboard.TargetName="AnimBrush" 
                        Storyboard.TargetProperty="(SolidColorBrush.Color)"
                        From="Blue" To="White" Duration="0:0:1" 
                        AutoReverse="True" RepeatBehavior="Forever" />
                </Storyboard>
            </BeginStoryboard>
        </EventTrigger>
    </Button.Triggers>
</Button>

Weitere Informationen zum Animieren von Eigenschaften finden Sie in der Übersicht über Animationen und Storyboards

Außerkraftsetzungen von Metadaten

Sie können bestimmte Verhaltensweisen einer Abhängigkeitseigenschaft ändern, indem Sie ihre Metadaten überschreiben, wenn Sie von der Klasse ableiten, die die Abhängigkeitseigenschaft ursprünglich registriert hat. Das Überschreiben von Metadaten basiert auf dem DependencyProperty Bezeichner und erfordert keine erneute Umsetzung der Eigenschaft. Die Metadatenänderung wird vom Eigenschaftensystem nativ behandelt. Jede Klasse enthält potenziell einzelne Metadaten für alle Eigenschaften, die von Basisklassen geerbt werden, pro Typ.

Im folgenden Beispiel werden Metadaten für eine DefaultStyleKey Abhängigkeitseigenschaft außer Kraft gesetzt. Das Überschreiben von Metadaten für diese bestimmte Abhängigkeitseigenschaft ist Teil eines Implementierungsmusters zum Erstellen von Steuerelementen, die Standardstile aus Themes verwenden können.

public class SpinnerControl : ItemsControl
{
    static SpinnerControl() => DefaultStyleKeyProperty.OverrideMetadata(
            typeof(SpinnerControl),
            new FrameworkPropertyMetadata(typeof(SpinnerControl))
        );
}

Public Class SpinnerControl
    Inherits ItemsControl
    Shared Sub New()
        DefaultStyleKeyProperty.OverrideMetadata(GetType(SpinnerControl), New FrameworkPropertyMetadata(GetType(SpinnerControl)))
    End Sub
End Class

Weitere Informationen zum Überschreiben oder Zugreifen auf Metadaten für Abhängigkeitseigenschaften finden Sie unter Überschreiben von Metadaten für eine Abhängigkeitseigenschaft.

Eigenschaftswertvererbung

Ein Element kann den Wert einer Abhängigkeitseigenschaft von seinem übergeordneten Element in der Objektstruktur erben.

Hinweis

Das Verhalten der Eigenschaftswertvererbung ist für alle Abhängigkeitseigenschaften nicht global aktiviert, da sich die Berechnungszeit für die Vererbung auf die Leistung auswirkt. Die Vererbung von Eigenschaftswerten wird normalerweise nur in Szenarien aktiviert, in denen sie anwendbar erscheint. Sie können überprüfen, ob eine Abhängigkeitseigenschaft erbt, indem Sie sich den Abschnitt "Informationen zur Abhängigkeitseigenschaft " für diese Abhängigkeitseigenschaft in der SDK-Referenz ansehen.

Das folgende Beispiel zeigt eine Bindung, die die DataContext Eigenschaft enthält, um die Quelle der Bindung anzugeben. Bindungen in untergeordneten Objekten müssen also nicht die Quelle angeben und können den geerbten Wert aus DataContext dem übergeordneten StackPanel Objekt verwenden. Oder ein untergeordnetes Objekt kann direkt einen eigenen Wert für DataContext oder Source im Binding festlegen, anstatt den geerbten Wert zu verwenden.

<StackPanel Canvas.Top="50" DataContext="{Binding Source={StaticResource TestData}}">
    <Button Content="{Binding XPath=test[2]/@text}"/>
</StackPanel>

Weitere Informationen finden Sie unter Eigenschaftswertvererbung.

WPF-Designerintegration

Benutzerdefinierte Steuerelemente mit Eigenschaften, die als Abhängigkeitseigenschaften implementiert wurden, sind gut in WPF Designer für Visual Studio integriert. Ein Beispiel ist die Möglichkeit, direkte und angefügte Abhängigkeitseigenschaften im Eigenschaftenfenster zu bearbeiten. Weitere Informationen finden Sie unter Übersicht über die Steuerelementerstellung

Rangfolge der Werte von Abhängigkeitseigenschaften

Jeder der eigenschaftenbasierten Eingaben im WPF-Eigenschaftensystem kann den Wert einer Abhängigkeitseigenschaft festlegen. Die Rangfolge der Abhängigkeitseigenschaft ist vorhanden, sodass die verschiedenen Szenarien, wie Eigenschaften ihre Werte erhalten, auf vorhersehbare Weise interagieren.

Hinweis

In der SDK-Dokumentation wird manchmal der Begriff "lokaler Wert" oder "lokal festgelegter Wert" verwendet, wenn Abhängigkeitseigenschaften erläutert werden. Ein lokal festgelegter Wert ist ein Eigenschaftswert, der direkt für eine Objektinstanz im Code oder als Elementattribute in XAML festgelegt wird.

Das nächste Beispiel enthält eine Formatvorlage, die auf die Background Eigenschaft einer beliebigen Schaltfläche angewendet wird, aber eine Schaltfläche mit einer lokal festgelegten Background Eigenschaft angibt. Technisch gesehen hat diese Schaltfläche ihre Background Eigenschaft zweimal zugewiesen bekommen, obwohl nur ein Wert angewendet wird – der Wert mit dem höchsten Vorrang. Ein lokal festgelegter Wert hat die höchste Priorität, mit Ausnahme einer ausgeführten Animation, die hier nicht vorhanden ist. Daher verwendet die zweite Schaltfläche den lokal festgelegten Wert für die Background Eigenschaft anstelle des Style setter-Werts. Die erste Schaltfläche hat keinen lokalen Wert oder einen anderen Wert mit höherer Priorität als einen Stilsetzer und verwendet daher den Stilsetzerwert für die Background-Eigenschaft.

<StackPanel>
    <StackPanel.Resources>
        <Style x:Key="{x:Type Button}" TargetType="{x:Type Button}">
            <Setter Property="Background" Value="Orange"/>
        </Style>
    </StackPanel.Resources>
    <Button>I am styled orange</Button>
    <Button Background="Pink">I am locally set to pink (not styled orange)</Button>
</StackPanel>

Warum existiert die Reihenfolge der Abhängigkeitseigenschaft?

Lokal festgelegte Werte haben Vorrang gegenüber Stilsetzerwerten, was die lokale Steuerung von Elementeigenschaften unterstützt. Details können Sie unter Priorität der Abhängigkeitseigenschaft nachsehen.

Hinweis

Eine Reihe von Eigenschaften, die für WPF-Elemente definiert sind, sind keine Abhängigkeitseigenschaften, da Abhängigkeitseigenschaften in der Regel nur implementiert wurden, wenn ein Feature des WPF-Eigenschaftensystems erforderlich war. Zu den Features gehören Datenbindung, Formatierung, Animation, Unterstützung von Standardwerten, Vererbung, angefügte Eigenschaften und Ungültigheit.

Weitere Informationen zu Abhängigkeitseigenschaften

  • Komponentenentwickler oder Anwendungsentwickler möchten möglicherweise ihre eigene Abhängigkeitseigenschaft erstellen, um Funktionen hinzuzufügen, z. B. Unterstützung für Datenbindung oder Formatvorlagen, oder Ungültigkeits- und Wertkoersionsunterstützung. Weitere Informationen finden Sie unter Benutzerdefinierte Abhängigkeitseigenschaften.

  • Betrachten Sie Abhängigkeitseigenschaften als öffentliche Eigenschaften, die für jeden Aufrufer mit Zugriff auf eine Instanz zugänglich oder auffindbar sind. Weitere Informationen finden Sie unter Dependency Property Security.

  • Eine angefügte Eigenschaft ist eine Art von Eigenschaft, die eine spezielle Syntax in XAML unterstützt. Eine angefügte Eigenschaft hat häufig keine 1:1-Entsprechung mit einer Common Language Runtime-Eigenschaft und ist nicht notwendigerweise eine abhängige Eigenschaft. Der Hauptzweck einer angefügten Eigenschaft besteht darin, untergeordneten Elementen das Melden von Eigenschaftswerten an ein übergeordnetes Element zu ermöglichen, auch wenn das übergeordnete Element und das untergeordnete Element diese Eigenschaft nicht als Teil der Klassenmemberauflistungen enthalten. Ein primäres Szenario besteht darin, einem untergeordneten Element zu ermöglichen, seinen übergeordneten Elementen mitzuteilen, wie sie in der Benutzeroberfläche präsentiert werden sollen. Beispiele finden Sie unter Dock und Left. Weitere Informationen finden Sie unter Übersicht über angefügte Eigenschaften.

Siehe auch