Freigeben über

Benutzerdefinierte Abhängigkeitseigenschaften

Entwickler und Komponentenautoren von Windows Presentation Foundation (WPF) können benutzerdefinierte Abhängigkeitseigenschaften erstellen, um die Funktionalität ihrer Eigenschaften zu erweitern. Im Gegensatz zu einer CLR-Eigenschaft (Common Language Runtime) bietet eine Abhängigkeitseigenschaft Unterstützung für Formatierung, Datenbindung, Vererbung, Animationen und Standardwerte. Background, Widthund Text sind Beispiele für vorhandene Abhängigkeitseigenschaften in WPF-Klassen. In diesem Artikel wird beschrieben, wie Sie benutzerdefinierte Abhängigkeitseigenschaften implementieren und Optionen zur Verbesserung der Leistung, Benutzerfreundlichkeit und Vielseitigkeit darstellen.

Voraussetzungen

In diesem Artikel wird davon ausgegangen, dass Sie über grundlegende Kenntnisse von Abhängigkeitseigenschaften verfügen und eine Übersicht über Abhängigkeitseigenschaften gelesen haben. Um den Beispielen in diesem Artikel zu folgen, hilft es Ihnen, wenn Sie mit Extensible Application Markup Language (XAML) vertraut sind und wissen, wie WPF-Anwendungen geschrieben werden.

Bezeichner der Abhängigkeitseigenschaft

Abhängigkeitseigenschaften sind Eigenschaften, die beim WPF-Eigenschaftensystem durch Register- oder RegisterReadOnly-Aufrufe registriert sind. Die Register Methode gibt eine DependencyProperty Instanz zurück, die den registrierten Namen und die Merkmale einer Abhängigkeitseigenschaft enthält. Sie weisen die DependencyProperty Instanz einem statischen Readonly-Feld zu, das als Abhängigkeitseigenschaftsbezeichner bezeichnet wird, der nach Konvention benannt <property name>Propertywird. Beispielsweise ist das Bezeichnerfeld für die Background Eigenschaft immer BackgroundProperty.

Der Bezeichner der Abhängigkeitseigenschaft wird als Hintergrundfeld zum Abrufen oder Festlegen von Eigenschaftswerten verwendet, anstatt das Standardmuster zu verwenden, bei dem eine Eigenschaft mit einem privaten Feld gesichert wird. Das Eigenschaftensystem verwendet nicht nur den Bezeichner, XAML-Prozessoren können ihn verwenden, und Ihr Code (und möglicherweise externer Code) kann über ihre Bezeichner auf Abhängigkeitseigenschaften zugreifen.

Abhängigkeitseigenschaften können nur auf Klassen angewendet werden, die von DependencyObject Typen abgeleitet sind. Die meisten WPF-Klassen unterstützen Abhängigkeitseigenschaften, da DependencyObject nah am Stamm der WPF-Klassenhierarchie liegt. Weitere Informationen zu Abhängigkeitseigenschaften und der Terminologie und Konventionen, die zum Beschreiben verwendet werden, finden Sie in der Übersicht über Abhängigkeitseigenschaften.

Wrapper für Abhängigkeitseigenschaften

WPF-Abhängigkeitseigenschaften, die keine angefügten Eigenschaften sind, werden von einem CLR-Wrapper verfügbar gemacht, der get und set Accessoren implementiert. Mithilfe eines Eigenschaftenwrappers können Nutzer von Abhängigkeitseigenschaften diese abrufen oder festlegen, genau wie jede andere CLR-Eigenschaft. Die get- und set-Accessoren kommunizieren über DependencyObject.GetValue- und DependencyObject.SetValue-Aufrufe mit dem zugrunde liegenden Eigenschaftensystem, indem sie den Bezeichner der Abhängigkeitseigenschaft als Parameter übergeben. Verbraucher von Abhängigkeitseigenschaften rufen in der Regel nicht direkt oder SetValue nicht direkt aufGetValue, aber wenn Sie eine benutzerdefinierte Abhängigkeitseigenschaft implementieren, verwenden Sie diese Methoden im Wrapper.

Wann eine Abhängigkeitseigenschaft implementiert werden soll

Wenn Sie eine Eigenschaft für eine Klasse implementieren, die von DependencyObjectdieser abgeleitet wird, machen Sie sie zu einer Abhängigkeitseigenschaft, indem Sie Ihre Eigenschaft mit einem DependencyProperty Bezeichner sichern. Ob es vorteilhaft ist, eine Eigenschaft für Abhängigkeiten zu erstellen, hängt von Ihrem Szenario ab. Obwohl die Absicherung Ihrer Eigenschaft mithilfe eines privaten Feldes für einige Szenarien ausreichend ist, sollten Sie eine Dependency Property implementieren, wenn Ihre Eigenschaft eine oder mehrere der folgenden WPF-Fähigkeiten unterstützen soll.

  • Eigenschaften, die innerhalb einer Formatvorlage festgelegt werden können. Weitere Informationen finden Sie unter "Formatvorlagen und Vorlagen".

  • Eigenschaften, die die Datenbindung unterstützen. Weitere Informationen zu Abhängigkeitseigenschaften für die Datenbindung finden Sie unter Binden der Eigenschaften von zwei Steuerelementen

  • Eigenschaften, die über dynamische Ressourcenverweise festgelegt werden können. Weitere Informationen finden Sie unter XAML-Ressourcen.

  • Eigenschaften, die ihren Wert automatisch von einem übergeordneten Element in der Elementstruktur erben. Dazu müssen Sie die Verwendung registrieren RegisterAttached, auch wenn Sie auch einen Eigenschaftswrapper für den CLR-Zugriff erstellen. Weitere Informationen finden Sie unter Eigenschaftswertvererbung.

  • Eigenschaften, die animierbar sind. Weitere Informationen finden Sie unter "Animationsübersicht"

  • Benachrichtigung durch das WPF-Eigenschaftensystem, wenn sich ein Eigenschaftswert ändert. Änderungen können auf Aktionen durch das Eigenschaftensystem, die Umgebung, den Benutzer oder die Stile zurückzuführen sein. Ihre Eigenschaft kann eine Rückrufmethode in Eigenschaftsmetadaten angeben, die jedes Mal aufgerufen wird, wenn das Eigenschaftensystem bestimmt, dass der Eigenschaftswert geändert wurde. Ein verwandtes Konzept ist die Koersion des Eigenschaftswerts. Weitere Informationen finden Sie unter Rückrufe und Validierung von Abhängigkeitseigenschaften.

  • Zugriff auf Metadaten von Abhängigkeitseigenschaften, die von WPF-Prozessen gelesen werden. Sie können beispielsweise Eigenschaftsmetadaten verwenden, um:

    • Geben Sie an, ob ein geänderter Abhängigkeitseigenschaftswert das Layoutsystem dazu veranlassen soll, die visuellen Elemente eines Elements neu zusammenzusetzen.

    • Legen Sie den Standardwert einer Abhängigkeitseigenschaft fest, indem Sie Metadaten für abgeleitete Klassen überschreiben.

  • Visual Studio WPF-Designerunterstützung, z. B. das Bearbeiten der Eigenschaften eines benutzerdefinierten Steuerelements im Eigenschaftenfenster . Weitere Informationen finden Sie unter Übersicht über die Steuerelementerstellung

Für einige Szenarien ist das Überschreiben der Metadaten einer vorhandenen Abhängigkeitseigenschaft eine bessere Option als die Implementierung einer neuen Abhängigkeitseigenschaft. Ob eine Außerkraftsetzung von Metadaten praktisch ist, hängt von Ihrem Szenario ab und wie genau das Szenario der Implementierung vorhandener WPF-Abhängigkeitseigenschaften und -klassen ähnelt. Weitere Informationen zum Überschreiben von Metadaten für vorhandene Abhängigkeitseigenschaften finden Sie unter Abhängigkeitseigenschaftsmetadaten.

Prüfliste zum Erstellen einer Abhängigkeitseigenschaft

Führen Sie die folgenden Schritte aus, um eine Abhängigkeitseigenschaft zu erstellen. Einige der Schritte können in einer einzigen Codezeile kombiniert und implementiert werden.

  1. (Optional) Metadaten für Abhängigkeitseigenschaften erstellen.

  2. Registrieren Sie die Abhängigkeitseigenschaft beim Eigenschaftensystem, geben Sie einen Eigenschaftsnamen, einen Besitzertyp, den Eigenschaftswerttyp und optional Eigenschaftenmetadaten an.

  3. Definieren Sie einen DependencyProperty Bezeichner als public static readonly Feld für den Besitzertyp. Der Name des Bezeichnerfelds ist der Eigenschaftsname mit dem angefügten Suffix Property .

  4. Definieren Sie eine CLR-Wrappereigenschaft mit demselben Namen wie der Name der Abhängigkeitseigenschaft. Implementieren Sie im CLR-Wrapper die Accessoren get und set, die eine Verbindung mit der Abhängigkeitseigenschaft herstellen, welche den Wrapper unterstützt.

Registrierung des Eigentums

Damit Ihre Eigenschaft eine Abhängigkeitseigenschaft sein kann, müssen Sie sie beim Eigenschaftensystem registrieren. Um Ihr Eigentum zu registrieren, rufen Sie die Register Methode innerhalb des Klassenkörpers, aber außerhalb von Memberdefinitionen auf. Die Register Methode gibt einen eindeutigen Abhängigkeitseigenschaftsbezeichner zurück, den Sie beim Aufrufen der Eigenschaftensystem-API verwenden werden. Der Grund dafür, dass der Register Aufruf außerhalb von Memberdefinitionen erfolgt, liegt darin, dass Sie einem Feld vom Typ DependencyPropertyden Rückgabewert public static readonly zuweisen. Dieses Feld, das Sie in Ihrer Klasse erstellen, ist der Bezeichner für Ihre Abhängigkeitseigenschaft. Im folgenden Beispiel benennt das erste Argument der Register die Abhängigkeitseigenschaft AquariumGraphic.

// Register a dependency property with the specified property name,
// property type, owner type, and property metadata. Store the dependency
// property identifier as a public static readonly member of the class.
public static readonly DependencyProperty AquariumGraphicProperty =
    DependencyProperty.Register(
      name: "AquariumGraphic",
      propertyType: typeof(Uri),
      ownerType: typeof(Aquarium),
      typeMetadata: new FrameworkPropertyMetadata(
          defaultValue: new Uri("http://www.contoso.com/aquarium-graphic.jpg"),
          flags: FrameworkPropertyMetadataOptions.AffectsRender,
          propertyChangedCallback: new PropertyChangedCallback(OnUriChanged))
    );

' Register a dependency property with the specified property name,
' property type, owner type, and property metadata. Store the dependency
' property identifier as a public static readonly member of the class.
Public Shared ReadOnly AquariumGraphicProperty As DependencyProperty =
    DependencyProperty.Register(
        name:="AquariumGraphic",
        propertyType:=GetType(Uri),
        ownerType:=GetType(Aquarium),
        typeMetadata:=New FrameworkPropertyMetadata(
            defaultValue:=New Uri("http://www.contoso.com/aquarium-graphic.jpg"),
            flags:=FrameworkPropertyMetadataOptions.AffectsRender,
            propertyChangedCallback:=New PropertyChangedCallback(AddressOf OnUriChanged)))

Hinweis

Das Definieren der Abhängigkeitseigenschaft im Klassentext ist die typische Implementierung, aber es ist auch möglich, eine Abhängigkeitseigenschaft im statischen Klassenkonstruktor zu definieren. Dieser Ansatz kann sinnvoll sein, wenn Sie mehr als eine Codezeile zum Initialisieren der Abhängigkeitseigenschaft benötigen.

Benennung von Abhängigkeitseigenschaften

Die festgelegte Benennungskonvention für Abhängigkeitseigenschaften ist für das normale Verhalten des Eigenschaftensystems obligatorisch. Der Name des bezeichnerfelds, das Sie erstellen, muss der registrierte Name der Eigenschaft mit dem Suffix Propertysein.

Ein Abhängigkeitseigenschaftsname muss innerhalb der registrierenden Klasse eindeutig sein. Abhängigkeitseigenschaften, die über einen Basistyp geerbt werden, wurden bereits registriert und können nicht von einem abgeleiteten Typ registriert werden. Sie können jedoch eine Abhängigkeitseigenschaft verwenden, die von einem anderen Typ registriert wurde, auch einem Typ, von dem Ihre Klasse nicht erbt, indem Sie Ihre Klasse als Eigentümer der Abhängigkeitseigenschaft hinzufügen. Weitere Informationen zum Hinzufügen einer Klasse als Besitzer finden Sie unter Dependency-Eigenschaftsmetadaten.

Implementieren eines Eigenschaftenwrappers

Standardmäßig muss der Name der Wrappereigenschaft mit dem ersten Parameter des Register Aufrufs identisch sein, bei dem es sich um den Namen der Abhängigkeitseigenschaft handelt. Die Wrapper-Implementierung wird \GetValue im \get-Accessor aufrufen und \SetValue im \set-Accessor aufrufen (für Lese-/Schreibeigenschaften). Das folgende Beispiel zeigt einen Wrapper, zusammen mit dem Registrierungsaufruf und der Bezeichnerfeld-Deklaration. Alle öffentlichen Abhängigkeitseigenschaften für WPF-Klassen verwenden ein ähnliches Wrappermodell.

// Register a dependency property with the specified property name,
// property type, owner type, and property metadata. Store the dependency
// property identifier as a public static readonly member of the class.
public static readonly DependencyProperty AquariumGraphicProperty =
    DependencyProperty.Register(
      name: "AquariumGraphic",
      propertyType: typeof(Uri),
      ownerType: typeof(Aquarium),
      typeMetadata: new FrameworkPropertyMetadata(
          defaultValue: new Uri("http://www.contoso.com/aquarium-graphic.jpg"),
          flags: FrameworkPropertyMetadataOptions.AffectsRender,
          propertyChangedCallback: new PropertyChangedCallback(OnUriChanged))
    );

// Declare a read-write property wrapper.
public Uri AquariumGraphic
{
    get => (Uri)GetValue(AquariumGraphicProperty);
    set => SetValue(AquariumGraphicProperty, value);
}

' Register a dependency property with the specified property name,
' property type, owner type, and property metadata. Store the dependency
' property identifier as a public static readonly member of the class.
Public Shared ReadOnly AquariumGraphicProperty As DependencyProperty =
    DependencyProperty.Register(
        name:="AquariumGraphic",
        propertyType:=GetType(Uri),
        ownerType:=GetType(Aquarium),
        typeMetadata:=New FrameworkPropertyMetadata(
            defaultValue:=New Uri("http://www.contoso.com/aquarium-graphic.jpg"),
            flags:=FrameworkPropertyMetadataOptions.AffectsRender,
            propertyChangedCallback:=New PropertyChangedCallback(AddressOf OnUriChanged)))

' Declare a read-write property wrapper.
Public Property AquariumGraphic As Uri
    Get
        Return CType(GetValue(AquariumGraphicProperty), Uri)
    End Get
    Set
        SetValue(AquariumGraphicProperty, Value)
    End Set
End Property

Außer in seltenen Fällen sollte die Wrapperimplementierung nur GetValue und SetValue Code enthalten. Aus diesen Gründen finden Sie unter "Implikationen für benutzerdefinierte Abhängigkeitseigenschaften".

Wenn Ihre Immobilie nicht den etablierten Namensrichtlinien folgt, könnten die folgenden Probleme auftreten:

  • Einige Aspekte von Stilen und Vorlagen funktionieren nicht.

  • Die meisten Tools und Designer verwenden die Benennungskonventionen, um XAML ordnungsgemäß zu serialisieren und Unterstützung in der Designerumgebung auf Eigenschaftsebene bereitzustellen.

  • Die aktuelle Implementierung des WPF-XAML-Ladeprogramms umgeht die Wrapper vollständig und basiert auf der Benennungskonvention zum Verarbeiten von Attributwerten. Weitere Informationen finden Sie unter XAML-Lade- und Abhängigkeitseigenschaften.

Metadaten der Abhängigkeitseigenschaft

Wenn Sie eine Abhängigkeitseigenschaft registrieren, erstellt das Eigenschaftensystem ein Metadatenobjekt zum Speichern von Eigenschaftenmerkmalen. Mit Überladungen der Methode können Sie während der Register Registrierung Eigenschaftsmetadaten angeben, z. B Register(String, Type, Type, PropertyMetadata). . Eine häufige Verwendung von Eigenschaftsmetadaten besteht darin, einen benutzerdefinierten Standardwert für neue Instanzen anzuwenden, die eine Abhängigkeitseigenschaft verwenden. Wenn Sie keine Eigenschaftenmetadaten bereitstellen, weist das Eigenschaftensystem vielen der Abhängigkeitseigenschaften Standardwerte zu.

Wenn Sie eine Abhängigkeitseigenschaft für eine von einer klasse abgeleitete FrameworkElementKlasse erstellen, können Sie die speziellere Metadatenklasse FrameworkPropertyMetadata anstelle der Basisklasse PropertyMetadataverwenden. Mit mehreren FrameworkPropertyMetadata Konstruktorsignaturen können Sie verschiedene Kombinationen von Metadatenmerkmalen angeben. Wenn Sie nur einen Standardwert angeben möchten, verwenden FrameworkPropertyMetadata(Object) Und übergeben Sie den Standardwert an den Object Parameter. Stellen Sie sicher, dass der Werttyp dem propertyType im Register Aufruf angegebenen Wert entspricht.

Einige FrameworkPropertyMetadata Überladungen ermöglichen Ihnen, Optionenkennzeichnungen für Metadaten für Ihre Eigenschaften anzugeben. Das Eigenschaftensystem konvertiert diese Flags in diskrete Eigenschaften, und die Flagwerte werden von WPF-Prozessen verwendet, z. B. das Layoutmodul.

Festlegen von Metadatenkennzeichnungen

Beachten Sie beim Festlegen von Metadatenkennzeichnungen Folgendes:

  • Wenn sich der Eigenschaftswert (oder die Änderungen daran) darauf auswirken, wie das Layoutsystem ein UI-Element rendert, legen Sie ein oder mehrere der folgenden Flags fest:

    • AffectsMeasure, der angibt, dass eine Änderung des Eigenschaftswerts eine Änderung des UI-Renderings erfordert, insbesondere den Von einem Objekt innerhalb des übergeordneten Objekts belegten Platz. Zum Beispiel legen Sie dieses Metadaten-Flag für eine Width Eigenschaft fest.

    • AffectsArrange, der angibt, dass eine Änderung des Eigenschaftswerts eine Änderung des UI-Renderings erfordert, insbesondere die Position eines Objekts innerhalb des übergeordneten Elements. In der Regel ändert sich die Größe des Objekts nicht. Legen Sie z. B. diese Metadatenkennzeichnung für eine Alignment-Eigenschaft fest.

    • AffectsRender, was angibt, dass eine Änderung aufgetreten ist, die sich nicht auf das Layout und die Messung auswirkt, aber dennoch ein weiteres Rendern erfordert. Legen Sie z. B. dieses Kennzeichen für eine Background Eigenschaft oder eine andere Eigenschaft fest, die sich auf die Farbe eines Elements auswirkt.

    Sie können auch diese Flags als Eingaben für Ihre Überschreib-Implementierungen des Eigenschaftensystems (oder Layouts) von Rückrufen verwenden. Sie können beispielsweise einen OnPropertyChanged Callback verwenden, um InvalidateArrange aufzurufen, wenn eine Eigenschaft der Instanz eine Wertänderung meldet und AffectsArrange in den Metadaten festgelegt ist.

  • Einige Eigenschaften wirken sich auf unterschiedliche Weise auf die Darstellungseigenschaften des übergeordneten Elements aus. Beispielsweise können Änderungen an der MinOrphanLines Eigenschaft das Gesamtrendering eines Flussdokuments ändern. Verwenden Sie AffectsParentArrange oder AffectsParentMeasure, um übergeordnete Aktionen in Ihren eigenen Eigenschaften zu signalisieren.

  • Abhängigkeitseigenschaften unterstützen standardmäßig die Datenbindung. Sie können jedoch verwenden IsDataBindingAllowed , um die Datenbindung zu deaktivieren, wenn es kein realistisches Szenario dafür gibt oder wenn die Leistung der Datenbindung problematisch ist, z. B. für große Objekte.

  • Obwohl der Standarddatenbindungsmodus für Abhängigkeitseigenschaften lautetOneWay, können Sie den Bindungsmodus einer bestimmten Bindung ändern.TwoWay Weitere Informationen finden Sie unter Bindungsrichtung. Als Autor einer Abhängigkeitseigenschaft können Sie sogar die bidirektionale Bindung als Standardmodus festlegen. Ein Beispiel für eine vorhandene Abhängigkeitseigenschaft, die bidirektionale Datenbindung verwendet, ist MenuItem.IsSubmenuOpen, das einen Zustand hat, der auf anderen Eigenschaften und Methodenaufrufen basiert. Das Szenario für IsSubmenuOpen ist, dass seine Einstellungslogik und das Compositing von MenuItem mit dem Standard-Theme-Stil interagieren. TextBox.Text ist eine weitere WPF-Abhängigkeitseigenschaft, die standardmäßig bidirektionale Bindung verwendet.

  • Sie können die Eigenschaftsvererbung für Ihre Abhängigkeitseigenschaft aktivieren, indem Sie das Inherits Kennzeichen festlegen. Die Eigenschaftsvererbung ist nützlich für Szenarien, in denen übergeordnete und untergeordnete Elemente gemeinsam eine Eigenschaft aufweisen, und es ist sinnvoll, dass das untergeordnete Element den übergeordneten Wert für die gemeinsame Eigenschaft erbt. Ein Beispiel für eine vererbbare Eigenschaft ist DataContext, die Bindungsvorgänge unterstützt, die das Master-Detail-Szenario verwenden

  • Legen Sie das Journal Kennzeichen fest, um anzugeben, dass Ihre Abhängigkeitseigenschaft von Navigationsjournaldiensten erkannt oder verwendet werden soll. Die SelectedIndex Eigenschaft setzt das Journal Kennzeichen, um zu empfehlen, dass Anwendungen einen Journalverlauf der ausgewählten Elemente führen.

Schreibgeschützte Abhängigkeitseigenschaften

Sie können eine Abhängigkeitseigenschaft definieren, die schreibgeschützt ist. Ein typisches Szenario ist eine Abhängigkeitseigenschaft, die den internen Zustand speichert. IsMouseOver ist schreibgeschützt, weil sein Zustand nur durch Mauseingaben bestimmt werden sollte. Weitere Informationen finden Sie in Schreibgeschützte Abhängigkeitseigenschaften.

Abhängigkeitseigenschaften vom Sammlungstyp

Abhängigkeitseigenschaften vom Sammlungstyp weisen zusätzliche Implementierungsprobleme auf, z. B. festlegen eines Standardwerts für Referenztypen und Datenbindungsunterstützung für Sammlungselemente. Weitere Informationen finden Sie unter Abhängigkeitseigenschaften des Sammlungstyps.

Sicherheit von Abhängigkeitseigenschaften

In der Regel deklarieren Sie Abhängigkeitseigenschaften als öffentliche Eigenschaften und DependencyProperty Bezeichnerfelder als public static readonly Felder. Wenn Sie eine restriktivere Zugriffsebene angeben, wie protected, kann auf eine Abhängigkeitseigenschaft weiterhin über ihren Bezeichner in Kombination mit den APIs des Eigenschaftensystems zugegriffen werden. Auch ein geschütztes Bezeichnerfeld kann über WPF-Metadatenberichterstellungs- oder Wertermittlungs-APIs wie LocalValueEnumerator potenziell zugänglich sein. Weitere Informationen finden Sie unter Dependency Property Security.

Bei schreibgeschützten Abhängigkeitseigenschaften ist der Wert, der von RegisterReadOnly zurückgegeben wird, DependencyPropertyKey. In der Regel werden Sie DependencyPropertyKey nicht als public Mitglied Ihrer Klasse machen. Da das WPF-Eigenschaftensystem den DependencyPropertyKey nicht außerhalb deines Codes weiterverbreitet, bietet eine schreibgeschützte Abhängigkeitseigenschaft eine bessere setSicherheit als eine les- und schreibbare Abhängigkeitseigenschaft.

Abhängigkeitseigenschaften und Klassenkonstruktoren

Es gibt ein allgemeines Prinzip bei der Programmierung von verwaltetem Code, die häufig von Codeanalysetools erzwungen wird, dass Klassenkonstruktoren keine virtuellen Methoden aufrufen sollten. Dies liegt daran, dass Basiskonstruktoren während der Initialisierung eines abgeleiteten Klassenkonstruktors aufgerufen werden können, und eine virtuelle Methode, die von einem Basiskonstruktor aufgerufen wird, kann vor abschluss der Initialisierung der abgeleiteten Klasse ausgeführt werden. Wenn Sie von einer Klasse ableiten, die bereits von DependencyObject abgeleitet ist, ruft das Eigenschaftssystem selbst intern virtuelle Methoden auf und stellt sie zur Verfügung. Diese virtuellen Methoden sind Teil der Dienste des WPF-Eigenschaftensystems. Durch das Überschreiben der Methoden können abgeleitete Klassen an der Wertermittlung teilnehmen. Um potenzielle Probleme mit der Laufzeitinitialisierung zu vermeiden, sollten Sie abhängigkeitseigenschaftswerte nicht innerhalb von Konstruktoren von Klassen festlegen, es sei denn, Sie folgen einem bestimmten Konstruktormuster. Weitere Informationen finden Sie unter "Sichere Konstruktormuster für DependencyObjects".

Siehe auch