Übersicht über AbhängigkeitseigenschaftenDependency properties overview

Windows Presentation Foundation (WPF) bietet eine Reihe von Diensten, die zum Erweitern der Funktionalität einer Eigenschaft eines Typs verwendet werden können.Windows Presentation Foundation (WPF) provides a set of services that can be used to extend the functionality of a type's property. Zusammen werden diese Dienste normalerweise als WPF-Eigenschaftensystem bezeichnet.Collectively, these services are typically referred to as the WPF property system. Eine Eigenschaft, die von der WPF-Eigenschaft unterstützt wird, wird als Abhängigkeitseigenschaft bezeichnet.A property that is backed by the WPF property system is known as a dependency property. In dieser Übersicht wird das WPF-Eigenschaftensystem und die Funktionen einer Abhängigkeitseigenschaft beschrieben.This overview describes the WPF property system and the capabilities of a dependency property. Dies schließt die Verwendung vorhandener Abhängigkeitseigenschaften in XAML und Code ein.This includes how to use existing dependency properties in XAML and in code. In dieser Übersicht werden auch spezielle Aspekte von Abhängigkeitseigenschaften wie die Metadaten von Abhängigkeitseigenschaften sowie die Erstellung einer eigenen Abhängigkeitseigenschaft in einer benutzerdefinierten Klasse eingeführt.This overview also introduces specialized aspects of dependency properties, such as dependency property metadata, and how to create your own dependency property in a custom class.

Erforderliche KomponentenPrerequisites

In diesem Thema wird vorausgesetzt, dass Sie über einige grundlegende Kenntnisse zum Typsystem von .NET und die objektorientierte Programmierung verfügen.This topic assumes that you have some basic knowledge of the .NET type system and object-oriented programming. Um den Beispielen in diesem Thema zu folgen, sollten Sie zudem XAML verstehen und wissen, wie WPF-Anwendungen geschrieben werden.In order to follow the examples in this topic, you should also understand XAML and know how to write WPF applications. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Meine erste WPF-Desktopanwendung.For more information, see Walkthrough: My first WPF desktop application.

Abhängigkeitseigenschaften und CLR-EigenschaftenDependency properties and CLR properties

Eigenschaften werden in der Regel als .NET-Standardeigenschaften verfügbar gemacht.In WPF, properties are typically exposed as standard .NET properties. Grundsätzlich können Sie direkt mit diesen Eigenschaften direkt interagieren, ohne zu wissen, dass sie als Abhängigkeitseigenschaft implementiert werden.At a basic level, you could interact with these properties directly and never know that they are implemented as a dependency property. Sie sollten aber mit einigen oder allen Funktionen des WPF-Eigenschaftensystems vertraut sein, damit Sie sie nutzen können.However, you should become familiar with some or all of the features of the WPF property system, so that you can take advantage of these features.

Abhängigkeitseigenschaften dienen der Berechnung des Werts einer Eigenschaft anhand des Werts von anderen Eingaben.The purpose of dependency properties is to provide a way to compute the value of a property based on the value of other inputs. Zu diese anderen Eingaben gehören Systemeigenschaften wie Designs und die Benutzervoreinstellung, Feststellungsmechanismen für Just-In-Time-Eigenschaft wie die Datenbindung und Animationen/Storyboards, mehrfach verwendbare Vorlagen, z.B. Ressourcen und Stile, oder Werte, die über übergeordnete und untergeordnete Beziehungen mit anderen Elementen in der Elementstruktur bekannt sind.These other inputs might include system properties such as themes and user preference, just-in-time property determination mechanisms such as data binding and animations/storyboards, multiple-use templates such as resources and styles, or values known through parent-child relationships with other elements in the element tree. Darüber hinaus kann eine Abhängigkeitseigenschaft implementiert werden, um ein selbstständige Überprüfung, Standardwerte, Rückrufe, die Änderungen an anderen Eigenschaften überwachen, sowie ein System bereitzustellen, das Eigenschaftswerte auf Grundlage potenzieller Laufzeitinformationen erzwingen kann.In addition, a dependency property can be implemented to provide self-contained validation, default values, callbacks that monitor changes to other properties, and a system that can coerce property values based on potentially runtime information. Abgeleitete Klassen können auch einige spezifische Merkmale einer vorhandenen Eigenschaft durch Überschreiben von Metadaten für Abhängigkeitseigenschaften ändern, anstatt die tatsächliche Implementierung der vorhandenen Eigenschaften zu überschreiben oder neue Eigenschaften zu erstellen.Derived classes can also change some specific characteristics of an existing property by overriding dependency property metadata, rather than overriding the actual implementation of existing properties or creating new properties.

Anhand der SDK-Referenz können Sie ermitteln, welche Eigenschaft eine Abhängigkeitseigenschaft ist, wenn diese im Abschnitt „Informationen zur Abhängigkeitseigenschaft“ auf der verwalteten Referenzseite für diese Eigenschaft vorhanden ist.In the SDK reference, you can identify which property is a dependency property by the presence of the Dependency Property Information section on the managed reference page for that property. Der Abschnitt mit den Informationen zur Abhängigkeitseigenschaft enthält einen Link zum DependencyProperty-Bezeichner für diese Abhängigkeitseigenschaft und eine Liste der Metadatenoptionen für diese Eigenschaft, der Informationen für das Überschreiben pro Klasse und anderer Details.The Dependency Property Information section includes a link to the DependencyProperty identifier field for that dependency property, and also includes a list of the metadata options that are set for that property, per-class override information, and other details.

Abhängigkeitseigenschaften unterstützen CLR-EigenschaftenDependency properties back CLR properties

Abhängigkeitseigenschaften und das WPF-Eigenschaftensystem erweitern die Funktionalität von Eigenschaften durch die Bereitstellung eines Typs, der eine Eigenschaft als eine alternative Implementierung zum Standardmuster unterstützt, bei dem die Eigenschaft mit einem privaten Feld unterstützt wird.Dependency properties and the WPF property system extend property functionality by providing a type that backs a property, as an alternative implementation to the standard pattern of backing the property with a private field. Der Name dieses Typs lautet DependencyProperty.The name of this type is DependencyProperty. Der andere wichtige Typ, der das WPF-Eigenschaftensystem definiert, ist DependencyObject.The other important type that defines the WPF property system is DependencyObject. DependencyObject definiert die Basisklasse, die eine Abhängigkeitseigenschaft registrieren und besitzen kann.DependencyObject defines the base class that can register and own a dependency property.

Nachfolgend ist die Terminologie aufgeführt, die mit Abhängigkeitseigenschaften verwendet wird:The following lists the terminology that is used with dependency properties:

  • Abhängigkeitseigenschaft: Eine Eigenschaft, die von unterstützt wird eine DependencyProperty.Dependency property: A property that is backed by a DependencyProperty.

  • Bezeichner der Abhängigkeitseigenschaft: Ein DependencyProperty -Instanz, die als Rückgabewert abgerufen werden, wenn Sie eine Abhängigkeitseigenschaft registrieren, und dann als ein statischer Member einer Klasse gespeichert.Dependency property identifier: A DependencyProperty instance, which is obtained as a return value when registering a dependency property, and then stored as a static member of a class. Dieser Bezeichner wird als Parameter für viele der APIs verwendet, die mit dem WPF-Eigenschaftenssystem interagieren.This identifier is used as a parameter for many of the APIs that interact with the WPF property system.

  • CLR "wrapper": Die tatsächliche Abrufen und Festlegen von Implementierungen für die Eigenschaft.CLR "wrapper": The actual get and set implementations for the property. Diese Implementierungen beinhalten den Abhängigkeitseigenschaftenbezeichner, indem sie diesen in den Aufrufen GetValue und SetValue verwenden und so die Sicherung für die Eigenschaft über das WPF-Eigenschaftensystem bereitstellen.These implementations incorporate the dependency property identifier by using it in the GetValue and SetValue calls, thus providing the backing for the property using the WPF property system.

Das folgende Beispiel definiert die IsSpinning-Abhängigkeitseigenschaft und zeigt die Beziehung zwischen dem DependencyProperty-Bezeichner zur Eigenschaft, die er unterstützt.The following example defines the IsSpinning dependency property, and shows the relationship of the DependencyProperty identifier to the property that it backs.

public static readonly DependencyProperty IsSpinningProperty = 
    DependencyProperty.Register(
    "IsSpinning", typeof(Boolean),
    typeof(MyCode)
    );
public bool IsSpinning
{
    get { return (bool)GetValue(IsSpinningProperty); }
    set { SetValue(IsSpinningProperty, value); }
}
Public Shared ReadOnly IsSpinningProperty As DependencyProperty =
    DependencyProperty.Register("IsSpinning",
                                GetType(Boolean),
                                GetType(MyCode))

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

Die Namenskonvention der Eigenschaft und ihres unterstützenden DependencyProperty-Feld ist wichtig.The naming convention of the property and its backing DependencyProperty field is important. Der Name des Felds ist immer der Name der Eigenschaft, die mit dem Suffix Property endet.The name of the field is always the name of the property, with the suffix Property appended. Weitere Informationen zu dieser Konvention und die Gründe dafür finden Sie unter Benutzerdefinierte Abhängigkeitseigenschaften.For more information about this convention and the reasons for it, see Custom Dependency Properties.

Festlegen von EigenschaftswertenSetting property values

Sie können Eigenschaften sowohl im Code als auch in XAML festlegen.You can set properties either in code or in XAML.

Festlegen von Eigenschaftswerten in XAMLSetting property values in XAML

Im folgende XAML-Beispiel wird die Hintergrundfarbe einer Schaltfläche als Rot dargestellt.The following XAML example specifies the background color of a button as red. Dieses Beispiel zeigt einen Fall, in dem der einfache Zeichenfolgenwert für ein XAML-Attribut vom WPF XAML-Parser im generierten Code in einen WPF-Typ typkonvertiert wird (ein Color mit einer SolidColorBrush).This example illustrates a case where the simple string value for a XAML attribute is type-converted by the WPF XAML parser into a WPF type (a Color, by way of a SolidColorBrush) in the generated code.

<Button Background="Red" Content="Button!"/>

XAML unterstützt eine Vielzahl an Syntaxformen zum Festlegen von Eigenschaften.XAML supports a variety of syntax forms for setting properties. Welche Syntax für eine bestimmte Eigenschaft verwendet wird, hängt vom Werttyp ab, den eine Eigenschaft verwendet, sowie von anderen Faktoren wie dem Vorhandensein eines Typkonverters.Which syntax to use for a particular property will depend on the value type that a property uses, as well as other factors such as the presence of a type converter. Weitere Informationen zur XAML-Syntax zum Festlegen von Eigenschaften finden Sie unter Übersicht über XAML (WPF) und Ausführliche Erläuterung der XAML-Syntax.For more information on XAML syntax for property setting, see XAML Overview (WPF) and XAML Syntax In Detail.

Im folgende XAML-Beispiel wird ein Beispiel für eine Syntax ohne Attribut und einen anderen Hintergrund für eine Schaltfläche.As an example of non-attribute syntax, the following XAML example shows another button background. Diesmal wird nicht einfach eine Volltonfarbe, sondern der Hintergrund auf ein Bild mit einem Element festgelegt, das dieses Bild und die Bildquelle angegeben als Attribut des geschachtelten Elements darstellt.This time rather than setting a simple solid color, the background is set to an image, with an element representing that image and the source of that image specified as an attribute of the nested element. Dies ist ein Beispiel für Eigenschaftenelementsyntax.This is an example of property element syntax.

<Button Content="Button!">
  <Button.Background>
    <ImageBrush ImageSource="wavy.jpg"/>
  </Button.Background>
</Button>

Festlegen von Eigenschaften im CodeSetting properties in code

Das Festlegen von Abhängigkeitseigenschaften im Code geschieht in der Regel über einen Aufruf der festgelegten Implementierung, die vom CLRCLR-Wrapper verfügbar gemacht wird.Setting dependency property values in code is typically just a call to the set implementation exposed by the CLRCLR "wrapper".

Button myButton = new Button();
myButton.Width = 200.0;
Dim myButton As New Button()
myButton.Width = 200.0

Das Abrufen eines Eigenschaftswerts besteht auch im Grunde aus einem Aufruf der Implementierung zum Abrufen des Wrappers:Getting a property value is also essentially a call to the get "wrapper" implementation:

double whatWidth;
whatWidth = myButton.Width;
Dim whatWidth As Double
whatWidth = myButton.Width

Sie können auch das Eigenschaftensystem APIs aufrufen GetValue und SetValue direkt.You can also call the property system APIs GetValue and SetValue directly. Dies ist nicht erforderlich, wenn Sie vorhandene Eigenschaften (die Wrapper sind besser geeignet und bieten bessere Offenlegung der Eigenschaft für die Entwicklertools) verwenden, aber die APIs direkt aufrufen eignet sich für bestimmte Szenarien.This is not typically necessary if you are using existing properties (the wrappers are more convenient, and provide better exposure of the property for developer tools), but calling the APIs directly is appropriate for certain scenarios.

Eigenschaften können auch in XAML festgelegt und später über den Code (über die CodeBehind-Datei) darauf zugegriffen werden.Properties can be also set in XAML and then accessed later in code, through code-behind. Weitere Informationen finden Sie unter CodeBehind und XAML in WPF.For details, see Code-Behind and XAML in WPF.

Von einer Abhängigkeitseigenschaft bereitgestellte EigenschaftenfunktionalitätProperty functionality provided by a dependency property

Eine Abhängigkeitseigenschaft stellt Funktionen bereit, die die Funktionalität einer Eigenschaft gegenüber einer Eigenschaft übertreffen, die durch ein Feld unterstützt wird.A dependency property provides functionality that extends the functionality of a property as opposed to a property that is backed by a field. Oft stellt eine solche Funktion eine der folgenden spezifischen Features dar bzw. unterstützt es:Often, such functionality represents or supports one of the following specific features:

RessourcenResources

Ein Wert einer Abhängigkeitseigenschaft kann durch Verweisen auf eine Ressource festgelegt werden.A dependency property value can be set by referencing a resource. Ressourcen werden in der Regel als der Resources-Eigenschaftswert eines Seitenstammelements oder der Anwendung angegeben (diese Positionen ermöglichen den einfachsten Zugriff auf die Ressource).Resources are typically specified as the Resources property value of a page root element, or of the application (these locations enable the most convenient access to the resource). Das folgende Beispiel veranschaulicht, wie Sie eine SolidColorBrush-Ressource definieren.The following example shows how to define a SolidColorBrush resource.

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

Nachdem die Ressource definiert wurde, können Sie auf die Ressource verweisen und einen Eigenschaftswert bereitstellen:Once the resource is defined, you can reference the resource and use it to provide a property value:

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

Auf diese spezielle Ressource wird als ein DynamicResource-Markuperweiterung verwiesen (in WPF-XAML können Sie entweder einen statischen oder dynamischen Ressourcenverweis verwenden).This particular resource is referenced as a DynamicResource Markup Extension (in WPF XAML, you can use either a static or dynamic resource reference). Um einen dynamischen Ressourcenverweis zu verwenden, müssen Sie die Ressource auf eine Abhängigkeitseigenschaft festlegen. Daher wird vom WPF-Eigenschaftensystem insbesondere die Verwendung dynamischer Ressourcenverweise ermöglicht.To use a dynamic resource reference, you must be setting to a dependency property, so it is specifically the dynamic resource reference usage that is enabled by the WPF property system. Weitere Informationen finden Sie unter XAML-Ressourcen.For more information, see XAML Resources.

Hinweis

Ressourcen werden als ein lokaler Wert behandelt. Wenn Sie also einen anderen lokalen Wert festgelegt haben, beseitigen Sie den Verweis auf die Ressource.Resources are treated as a local value, which means that if you set another local value, you will eliminate the resource reference. Weitere Informationen finden Sie unter Priorität von Abhängigkeitseigenschaftswerten.For more information, see Dependency Property Value Precedence.

DatenbindungData binding

Eine Abhängigkeitseigenschaft kann über die Datenbindung auf einen Wert verweisen.A dependency property can reference a value through data binding. Die Datenbindung funktioniert über eine bestimmte Markuperweiterungssyntax in XAML oder das Binding-Objekt im Code.Data binding works through a specific markup extension syntax in XAML, or the Binding object in code. Mit der Datenbindung wird die letzte Bestimmung des Eigenschaftswerts bis zur Laufzeit zurückgestellt. Zu diesem Zeitpunkt wird der Wert aus einer Datenquelle abgerufen.With data binding, the final property value determination is deferred until run time, at which time the value is obtained from a data source.

Das folgende Beispiel legt mithilfe einer in XAML deklarierten Bindung die Eigenschaft Content für eine Button-Klasse fest.The following example sets the Content property for a Button, using a binding declared in XAML. Die Bindung verwendet einen geerbten Datenkontext sowie eine XmlDataProvider-Datenquelle (hier nicht gezeigt).The binding uses an inherited data context and an XmlDataProvider data source (not shown). Die Bindung selbst gibt die gewünschte Quelleigenschaft mithilfe von XPath innerhalb der Datenquelle an.The binding itself specifies the desired source property by XPath within the data source.

<Button Content="{Binding XPath=Team/@TeamName}"/>

Hinweis

Bindungen werden als ein lokaler Wert behandelt. Wenn Sie also einen anderen lokalen Wert festgelegt haben, beseitigen Sie die Bindung.Bindings are treated as a local value, which means that if you set another local value, you will eliminate the binding. Weitere Informationen finden Sie unter Priorität von Abhängigkeitseigenschaftswerten.For details, see Dependency Property Value Precedence.

Die Abhängigkeitseigenschaften (oder die DependencyObject-Klasse) unterstützen INotifyPropertyChanged nicht nativ zu Zwecken der Erstellung von Benachrichtigungen von Änderungen im Wert DependencyObject für die Quelleigenschaft für Datenbindungsvorgänge.Dependency properties, or the DependencyObject class, do not natively support INotifyPropertyChanged for purposes of producing notifications of changes in DependencyObject source property value for data binding operations. Weitere Informationen zum Erstellen von Eigenschaften für die Datenbindung, die Änderungen an einem Datenbindungsziel melden können, finden Sie unter Übersicht über die Datenbindung.For more information on how to create properties for use in data binding that can report changes to a data binding target, see Data Binding Overview.

StileStyles

Stile und Vorlagen sind zwei Hauptgründe für die Verwendung von Abhängigkeitseigenschaften.Styles and templates are two of the chief motivating scenarios for using dependency properties. Stile eignen sich besonders für das Festlegen von Eigenschaften, die die Benutzeroberfläche (User Interface, UI)user interface (UI) der Anwendung definieren.Styles are particularly useful for setting properties that define application Benutzeroberfläche (User Interface, UI)user interface (UI). Stile werden in XAML in der Regel als Ressourcen definiert.Styles are typically defined as resources in XAML. Stile interagieren mit dem Eigenschaftensystem, weil sie normalerweise sowohl „Setter“ für bestimmte Eigenschaften als auch „Trigger“ enthalten, die einen Eigenschaftswert basierend auf dem Echtzeitwert einer anderen Eigenschaft ändern.Styles interact with the property system because they typically contain "setters" for particular properties, as well as "triggers" that change a property value based on the real-time value for another property.

Im folgenden Beispiel wird ein recht einfacher Stil erstellt, der in einem Resources-Wörterbuch definiert wird (hier nicht gezeigt). Dieser Stil wird direkt auf die Style-Eigenschaft für eine Button angewendet.The following example creates a very simple style (which would be defined inside a Resources dictionary, not shown), then applies that style directly to the Style property for a Button. Der Setter innerhalb des Stils legt die Eigenschaft Background für eine formatierte Button auf „green“ (grün) fest.The setter within the style sets the Background property for a styled Button to green.

<Style x:Key="GreenButtonStyle">
  <Setter Property="Control.Background" Value="Green"/>
</Style>
<Button Style="{StaticResource GreenButtonStyle}">I am green!</Button>

Weitere Informationen finden Sie unter Erstellen von Formaten und Vorlagen.For more information, see Styling and Templating.

AnimationenAnimations

Abhängigkeitseigenschaften können animiert werden.Dependency properties can be animated. Wenn eine Animation angewendet wurde und ausgeführt wird, verfügt der animierte Wert über eine höhere Priorität als alle anderen Werte (z.B. ein lokaler Wert), über die die Eigenschaft sonst verfügt.When an animation is applied and is running, the animated value operates at a higher precedence than any value (such as a local value) that the property otherwise has.

Im folgenden Beispiel wird die Background-Eigenschaft auf einer Button-Eigenschaft animiert (genau genommen wird Background über die Eigenschaftenelementsyntax animiert, um eine leere SolidColorBrush-Klasse als Background anzugeben. Die Color-Eigenschaft dieser SolidColorBrush ist somit die Eigenschaft, die direkt animiert wird).The following example animates the Background on a Button property (technically, the Background is animated by using property element syntax to specify a blank SolidColorBrush as the Background, then the Color property of that SolidColorBrush is the property that is directly animated).

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

Weitere Informationen zur Animation von Eigenschaften finden Sie unter Übersicht über Animationen und Übersicht über Storyboards.For more information on animating properties, see Animation Overview and Storyboards Overview.

Überschreiben von MetadatenMetadata overrides

Sie können bestimmte Verhaltensweisen einer Abhängigkeitseigenschaft ändern, indem Sie die Metadaten für diese Eigenschaft überschreiben, wenn Sie von der Klasse ableiten, die die Abhängigkeitseigenschaft ursprünglich registriert.You can change certain behaviors of a dependency property by overriding the metadata for that property when you derive from the class that originally registers the dependency property. Das Überschreiben von Metadaten basiert auf dem Bezeichner DependencyProperty.Overriding metadata relies on the DependencyProperty identifier. Das Überschreiben von Metadaten erfordert keine erneute Implementierung der Eigenschaft.Overriding metadata does not require re-implementing the property. Die Metadatenänderung wird vom Eigenschaftensystem nativ verarbeitet. Jede Klasse kann potenziell individuelle Metadaten für alle Eigenschaften enthalten, die von den Basisklassen jeweils pro Typ geerbt werden.The metadata change is handled natively by the property system; each class potentially holds individual metadata for all properties that are inherited from base classes, on a per-type basis.

Das folgende Beispiel überschreibt Metadaten für eine DefaultStyleKey-Abhängigkeitseigenschaft.The following example overrides metadata for a dependency property DefaultStyleKey. Das Überschreiben der Metadaten dieser Abhängigkeitseigenschaft ist Teil eines Implementierungsmusters, das Steuerelemente erstellt, die Standardstile aus Designs verwenden können.Overriding this particular dependency property metadata is part of an implementation pattern that creates controls that can use default styles from themes.

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 über das Überschreiben oder Abrufen von Eigenschaftenmetadaten finden Sie unter Metadaten für Abhängigkeitseigenschaften.For more information about overriding or obtaining property metadata, see Dependency Property Metadata.

Vererbung von EigenschaftswertenProperty value inheritance

Ein Element kann den Wert einer Abhängigkeitseigenschaft von seinem übergeordneten Element in der Objektstruktur erben.An element can inherit the value of a dependency property from its parent in the object tree.

Hinweis

Das Vererbungsverhalten von Eigenschaftswerten ist nicht global für alle Abhängigkeitseigenschaften aktiviert, da die Berechnungszeit für die Vererbung Leistungseinbußen mit sich bringt.Property value inheritance behavior is not globally enabled for all dependency properties, because the calculation time for inheritance does have some performance impact. Die Vererbung von Eigenschaftswerten ist normalerweise nur für Eigenschaften aktiviert, für die die Vererbung von Eigenschaftswerten in einem bestimmten Szenario sinnvoll ist.Property value inheritance is typically only enabled for properties where a particular scenario suggests that property value inheritance is appropriate. Anhand des Abschnitts Informationen zur Abhängigkeitseigenschaft zu der Abhängigkeitseigenschaft in der SDK-Referenz können Sie ermitteln, ob eine Abhängigkeitseigenschaft erbt.You can determine whether a dependency property inherits by looking at the Dependency Property Information section for that dependency property in the SDK reference.

Im folgenden Beispiel wird eine Bindung gezeigt und die DataContext-Eigenschaft festgelegt, die die Quelle der Bindung angibt, die im früheren Bindungsbeispiel nicht gezeigt wurde.The following example shows a binding, and sets the DataContext property that specifies the source of the binding, which was not shown in the earlier binding example. Alle nachfolgenden Bindungen in untergeordneten Objekt müssen die Quelle nicht angeben. Sie können den geerbten Wert von DataContext im übergeordneten StackPanel-Objekt verwenden.Any subsequent bindings in child objects do not need to specify the source, they can use the inherited value from DataContext in the parent StackPanel object. (Alternativ kann ein untergeordnetes Objekt stattdessen direkt seine eigene DataContext-Eigenschaft oder eine Source in der Binding angeben und so bewusst den geerbten Wert für den Datenkontext der Bindungen nicht verwenden.)(Alternatively, a child object could instead choose to directly specify its own DataContext or a Source in the Binding, and to deliberately not use the inherited value for data context of its bindings.)

<StackPanel Canvas.Top="50" DataContext="{Binding Source={StaticResource XmlTeamsSource}}">
  <Button Content="{Binding XPath=Team/@TeamName}"/>
</StackPanel>

Weitere Informationen finden Sie unter Vererbung von Eigenschaftswerten.For more information, see Property Value Inheritance.

WPF-Designer-IntegrationWPF designer integration

Ein benutzerdefiniertes Steuerelement mit Eigenschaften, die als Abhängigkeitseigenschaften implementiert werden, erhalten entsprechenden WPF-Designer für Visual StudioWPF Designer for Visual Studio-Support.A custom control with properties that are implemented as dependency properties will receive appropriate WPF-Designer für Visual StudioWPF Designer for Visual Studio support. Ein Beispiel hierfür ist die Fähigkeit, direkte und angefügte Abhängigkeitseigenschaften mit dem Eigenschaften-Fenster zu bearbeiten.One example is the ability to edit direct and attached dependency properties with the Properties window. Weitere Informationen finden Sie unter Übersicht über das Erstellen von Steuerelementen.For more information, see Control Authoring Overview.

Priorität von AbhängigkeitseigenschaftswertenDependency property value precedence

Wenn Sie den Wert einer Abhängigkeitseigenschaft abrufen, erhalten Sie möglicherweise einen Wert, der mithilfe einer der anderen auf Eigenschaften basierenden Eingaben, die Bestandteil des WPF-Systems sind, für die Eigenschaft festgelegt wurde.When you get the value of a dependency property, you are potentially obtaining a value that was set on that property through any one of the other property-based inputs that participate in the WPF property system. Abhängigkeitseigenschaftswerten werden Prioritäten zugewiesen, damit eine Vielzahl von Szenarios zur Art und Weise, wie Eigenschaften ihre Werte erhalten, in einer vorhersagbaren Weise interagieren können.Dependency property value precedence exists so that a variety of scenarios for how properties obtain their values can interact in a predictable way.

Betrachten Sie das folgende Beispiel.Consider the following example. Das Beispiel enthält einen Stil, der für alle Schaltflächen und deren Background-Eigenschaften gilt, aber ebenso eine Schaltfläche mit einem lokal festgelegten Background-Wert angibt.The example includes a style that applies to all buttons and their Background properties, but then also specifies one button with a locally set Background value.

Hinweis

In der SDK-Dokumentation werden gelegentlich im Zusammenhang mit Abhängigkeitseigenschaften die Begriffe „lokaler Wert“ oder „lokal festgelegter Wert“ verwendet.The SDK documentation uses the terms "local value" or "locally set value" occasionally when discussing dependency properties. Ein lokal festgelegter Wert ist ein Eigenschaftswert, der für eine Objektinstanz direkt im Code oder als Attribut für ein Element in XAML festgelegt wird.A locally set value is a property value that is set directly on an object instance in code, or as an attribute on an element in XAML.

Im Prinzip wird die Eigenschaft für die erste Schaltfläche zweimal festgelegt, wobei nur ein Wert angewendet wird: der Wert mit der höchsten Priorität.In principle, for the first button, the property is set twice, but only one value applies: the value with the highest precedence. Ein lokal festgelegter Wert hat die höchste Priorität (außer einer ausgeführte Animation, aber auf dieses Beispiel ist keine Animation anwendbar), und der lokal festgelegte Wert wird somit anstelle des Werts des Stilsetters für den Hintergrund der ersten Schaltfläche verwendet.A locally set value has the highest precedence (except for a running animation, but no animation applies in this example) and thus the locally set value is used instead of the style setter value for the background on the first button. Die zweite Schaltfläche weist keinen lokalen Wert auf (ebenso keinen anderen Wert mit höherer Priorität als ein Stilsetter), weswegen der Hintergrund der Schaltfläche dem Stilsetter entstammt.The second button has no local value (and no other value with higher precedence than a style setter) and thus the background in that button comes from the style setter.

<StackPanel>
  <StackPanel.Resources>
    <Style x:Key="{x:Type Button}" TargetType="{x:Type Button}">
     <Setter Property="Background" Value="Red"/>
    </Style>
  </StackPanel.Resources>
  <Button Background="Green">I am NOT red!</Button>
  <Button>I am styled red</Button>
</StackPanel>

Warum haben Abhängigkeitseigenschaften Prioritäten?Why does dependency property precedence exist?

In der Regel sollen Stile nicht immer gelten und sogar einen lokal festgelegten Wert eines einzelnen Elements verdecken (andernfalls wäre es sehr schwierig, Stile oder Elemente überhaupt zu verwenden).Typically, you would not want styles to always apply and to obscure even a locally set value of an individual element (otherwise, it would be very difficult to use either styles or elements in general). Aus diesem Grund operieren die Werte, die von Stilen abstammen, mit einer niedrigeren Priorität als lokal festgelegte Werte.Therefore, the values that come from styles operate at a lower precedent than a locally set value. Eine ausführliche Liste der Abhängigkeitseigenschaften und Angaben dazu, woher der effektive Wert einer Abhängigkeitseigenschaft möglicherweise stammt, finden Sie unter Priorität von Abhängigkeitseigenschaftswerten.For a more thorough listing of dependency properties and where a dependency property effective value might come from, see Dependency Property Value Precedence.

Hinweis

Es gibt eine Reihe von Eigenschaften, die für WPF-Elemente definiert sind, die keine Abhängigkeitseigenschaften sind.There are a number of properties defined on WPF elements that are not dependency properties. Im Großen und Ganzen wurden Eigenschaften nur als Abhängigkeitseigenschaften implementiert, wenn mindestens eines der Szenarios unterstützt werden musste, das vom Eigenschaftensystem aktiviert wurde: Datenbindungen, Stile, Animationen, die standardmäßige Wertunterstützung, die Vererbung, angefügte Eigenschaften oder Invalidierungen.By and large, properties were implemented as dependency properties only when there were needs to support at least one of the scenarios enabled by the property system: data binding, styling, animation, default value support, inheritance, attached properties, or invalidation.

Wissenswertes zu AbhängigkeitseigenschaftenLearning more about dependency properties

  • Eine angefügte Eigenschaft ist ein Eigenschaftstyp, die eine spezielle Syntax in XAML unterstützt.An attached property is a type of property that supports a specialized syntax in XAML. Eine angefügte Eigenschaft verfügt oft über keine 1:1-Entsprechung mit einer Common Language Runtime (CLR)common language runtime (CLR)-Eigenschaft und ist nicht unbedingt eine Abhängigkeitseigenschaft.An attached property often does not have a 1:1 correspondence with a Common Language Runtime (CLR)common language runtime (CLR) property, and is not necessarily a dependency property. Der Hauptzweck einer angefügten Eigenschaft ist es, den untergeordneten Elementen die Berichterstattung von Eigenschaftswerten an ein übergeordnetes Element zu ermöglichen, selbst wenn diese Eigenschaft in nicht den Klassenmemberlisten des übergeordneten und des untergeordneten Elements vorhanden ist.The typical purpose of a attached property is to allow child elements to report property values to a parent element, even if the parent element and child element do not both possess that property as part of the class members listings. Ein primäres Szenario ist das Aktivieren von untergeordneten Elementen, um das übergeordnete Element darüber zu informieren, wie die untergeordneten Elemente in UIUI dargestellt werden sollen. Ein Beispiel finden Sie unter Dock oder Left.One primary scenario is to enable child elements to inform the parent how they should be presented in UIUI; for an example, see Dock or Left. Weitere Informationen finden Sie unter Übersicht über angefügte Eigenschaften.For details, see Attached Properties Overview.

  • Komponenten- oder Anwendungsentwickler können ihre eigene Abhängigkeitseigenschaft erstellen, um Funktionen wie die Datenbindung oder die Unterstützung von Stilen oder die Invalidierung und die Erzwingung von Werten zu unterstützen.Component developers or application developers may wish to create their own dependency property, in order to enable capabilities such as data binding or styles support, or for invalidation and value coercion support. Weitere Informationen finden Sie unter Benutzerdefinierte Abhängigkeitseigenschaften.For details, see Custom Dependency Properties.

  • Abhängigkeitseigenschaften sollten im Allgemeinen als öffentliches Eigentum gelten, das zugänglich oder zumindest für alle Aufrufer mit Zugriff auf eine Instanz erkennbar sein.Dependency properties should generally be considered to be public properties, accessible or at least discoverable by any caller that has access to an instance. Weitere Informationen finden Sie unter Sicherheit von Abhängigkeitseigenschaften.For more information, see Dependency Property Security.

Siehe auchSee also