DependencyObject Klasse

Definition

public ref class DependencyObject

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class DependencyObject

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public class DependencyObject

Public Class DependencyObject

Vererbung

Object Platform::Object IInspectable DependencyObject

Abgeleitet

Windows.UI.Xaml.Automation.AutomationAnnotation

Windows.UI.Xaml.Automation.Peers.AutomationPeer

Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation

Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple

Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs

Mehr…

Attribute

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Windows-Anforderungen

Beispiele

In diesem Beispiel wird eine Klasse definiert, die von DependencyObject abgeleitet wird, und eine angefügte Eigenschaft zusammen mit dem Bezeichnerfeld definiert. Das Szenario für diese Klasse besteht darin, dass es sich um eine Dienstklasse handelt, die eine angefügte Eigenschaft deklariert, die andere UI-Elemente in XAML festlegen können. Der Dienst wirkt möglicherweise zur Laufzeit auf die Werte der angefügten Eigenschaft für diese UI-Elemente.

public abstract class AquariumServices : DependencyObject
{
    public enum Buoyancy {Floats,Sinks,Drifts}

    public static readonly DependencyProperty BuoyancyProperty = DependencyProperty.RegisterAttached(
      "Buoyancy",
      typeof(Buoyancy),
      typeof(AquariumServices),
      new PropertyMetadata(Buoyancy.Floats)
    );
    public static void SetBuoyancy(DependencyObject element, Buoyancy value)
    {
        element.SetValue(BuoyancyProperty, value);
    }
    public static Buoyancy GetBuoyancy(DependencyObject element)
    {
        return (Buoyancy)element.GetValue(BuoyancyProperty);
    }
}

Public Class AquariumServices
    Inherits DependencyObject
    Public Enum Buoyancy
        Floats
        Sinks
        Drifts
    End Enum

    Public Shared ReadOnly BuoyancyProperty As DependencyProperty = _
          DependencyProperty.RegisterAttached(
          "Buoyancy", _
          GetType(Buoyancy), _
          GetType(AquariumServices), _
          New PropertyMetadata(Buoyancy.Floats))


    Public Sub SetBuoyancy(element As DependencyObject, value As Buoyancy)
        element.SetValue(BuoyancyProperty, value)
    End Sub
    Public Function GetBuoyancy(element As DependencyObject) As Buoyancy
        GetBuoyancy = CType(element.GetValue(BuoyancyProperty), Buoyancy)
    End Function
End Class

public static bool ClearSetProperty(DependencyObject targetObject, DependencyProperty targetDP)
{
    if (targetObject == null || targetDP == null)
    {
        throw new ArgumentNullException();
    }
    object localValue = targetObject.ReadLocalValue(targetDP);
    if (localValue == DependencyProperty.UnsetValue)
    {
        return false;
    }
    else
    {
        targetObject.ClearValue(targetDP);
        return true;
    }
}

Public Shared Function ClearSetProperty(targetObject As DependencyObject, targetDP As DependencyProperty) As Boolean
    If targetObject Is Nothing Or targetDP Is Nothing Then
        Throw New ArgumentNullException()
    End If
    Dim localValue As Object = targetObject.ReadLocalValue(targetDP)
    If localValue = DependencyProperty.UnsetValue Then
        ClearSetProperty = False
    Else
        targetObject.ClearValue(targetDP)
        ClearSetProperty = True
    End If
End Function

Dieses Beispiel zeigt eine einfache Deklaration der Abhängigkeitseigenschaft. Ein Aufruf von GetValue stellt die gesamte Implementierung des Get Accessor für den Eigenschaftenwrapper der neuen Abhängigkeitseigenschaft dar. Ein Aufruf von SetValue stellt die gesamte Implementierung des Set-Accessors dar. Weitere Beispiele finden Sie unter Benutzerdefinierte Abhängigkeitseigenschaften.

public class Fish : Control
{
    public static readonly DependencyProperty SpeciesProperty =
    DependencyProperty.Register(
    "Species",
    typeof(String),
    typeof(Fish), null
    );
    public string Species
    {
        get { return (string)GetValue(SpeciesProperty); }
        set { SetValue(SpeciesProperty, (string)value); }
    }
}

Public Class Fish
    Inherits Control

    Public Shared ReadOnly SpeciesProperty As DependencyProperty = _
    DependencyProperty.Register(
    "Species", _
    GetType(String), _
    GetType(Fish), _
    Nothing)
    Public Property Species As String
        Get
            Species = CType(GetValue(SpeciesProperty), String)
        End Get
        Set(value As String)
            SetValue(SpeciesProperty, value)
        End Set
    End Property
End Class

Hinweise

Die DependencyObject-Klasse ermöglicht Abhängigkeitseigenschaftensystemdienste für die vielen abgeleiteten Klassen. Weitere Informationen zum Konzept der Abhängigkeitseigenschaft finden Sie in der Übersicht über Abhängigkeitseigenschaften.

Die primäre Funktion des Abhängigkeitseigenschaftssystems besteht darin, die Werte von Eigenschaften zu berechnen und eine Systembenachrichtigung über geänderte Werte bereitzustellen. Eine weitere Schlüsselklasse, die am Abhängigkeitseigenschaftssystem teilnimmt, ist DependencyProperty. DependencyProperty ermöglicht die Registrierung von Abhängigkeitseigenschaften im Eigenschaftensystem, während DependencyObject als Basisklasse die Verwendung und Festlegung der Abhängigkeitseigenschaften ermöglicht.

Hier sind einige wichtige Dienste und Merkmale, die DependencyObject bereitstellt oder unterstützt:

• Unterstützung von Abhängigkeitseigenschaftshosting für die vorhandenen Windows-Runtime Abhängigkeitseigenschaften.
• Unterstützung für benutzerdefinierte Abhängigkeitseigenschaftshosting. Sie registrieren eine Abhängigkeitseigenschaft, indem Sie die Register-Methode aufrufen und den Rückgabewert der Methode als öffentliche statische Eigenschaft in Ihrer DependencyObject-Klasse speichern.
• Unterstützung für angefügte Eigenschaftenhosting für die vorhandenen Windows-Runtime angefügten Eigenschaften.
• Unterstützung für benutzerdefinierte angefügte Eigenschaftenhosting. Sie registrieren eine Abhängigkeitseigenschaft für die Verwendung der angefügten Eigenschaft, indem Sie die RegisterAttached-Methode aufrufen und den Rückgabewert der Methode als öffentliche statische Eigenschaft in Ihrer Klasse speichern.
• Dient zum Abrufen und Festlegen von Hilfsprogrammmethoden für Werte aller Abhängigkeitseigenschaften, die für ein DependencyObject vorhanden sind. Sie verwenden diese beim Definieren von benutzerdefinierten Abhängigkeitseigenschaften "Wrappern" und können sie auch aus App-Code als Alternative zur Verwendung vorhandener "Wrapper"-Eigenschaften verwenden.
• Advanced-scenario utility for examining metadata or property values (for example GetAnimationBaseValue).
• Erzwingen der Threadaffinität zum Haupt-UI-Thread des Windows-Runtime für alle DependencyObject-Instanzen.
• Die Dispatcher-Eigenschaft für erweiterte Threadingszenarien. Das Abrufen des Dispatcher-Werts stellt einen Verweis auf ein CoreDispatcher-Objekt bereit. Mit dem CoreDispatcher kann ein Workerthread Code ausführen, der ein DependencyObject verwendet, sich aber nicht im UI-Thread befindet, da der CoreDispatcher die Ausführung auf einen asynchronen Vorgang zurückstellen kann, der den UI-Thread nicht blockiert oder anderweitig beeinträchtigt. Siehe Abschnitt "DependencyObject und Threading" weiter unten.
• Grundlegende Datenbindung und Formatierungsunterstützung, indem Eigenschaften als Ausdrücke festgelegt werden können, die zu einem späteren Zeitpunkt in der Lebensdauer eines Objekts ausgewertet werden. Diese Konzepte werden in der Übersicht über Abhängigkeitseigenschaften ausführlicher erläutert. Siehe auch Datenbindung im Detail.

DependencyObject und Threading

Alle DependencyObject-Instanzen müssen im UI-Thread erstellt werden, der dem aktuellen Fenster für eine App zugeordnet ist. Dies wird vom System erzwungen, und für Ihren Code gibt es zwei wichtige Auswirkungen:

• Code, der API aus zwei DependencyObject-Instanzen verwendet, wird immer im selben Thread ausgeführt, was immer der UI-Thread ist. In diesem Szenario treten in der Regel keine Threadingprobleme auf.
• Code, der nicht im Haupt-UI-Thread ausgeführt wird, kann nicht direkt auf ein DependencyObject zugreifen, da ein DependencyObject nur Threadaffinität zum UI-Thread hat. Nur Code, der im UI-Thread ausgeführt wird, kann den Wert einer Abhängigkeitseigenschaft ändern oder sogar lesen. Beispielsweise kann ein Arbeitsthread, den Sie mit einer .NET Aufgabe oder einem expliziten ThreadPool-Thread initiiert haben, keine Abhängigkeitseigenschaften lesen oder andere APIs aufrufen.

Sie sind nicht vollständig daran gehindert, ein DependencyObject aus einem Arbeitsthread zu verwenden. Sie müssen jedoch ein CoreDispatcher-Objekt (den Wert von DependencyObject.Dispatcher) aus einem DependencyObject abrufen, um die bewusste Trennung zwischen dem App-UI-Thread und allen anderen Threads, die auf dem System ausgeführt werden, zu durchlaufen. Der CoreDispatcher macht die RunAsync-Methode verfügbar. Rufen Sie RunAsync auf, um Den erwarteten Code (eine IAsyncAction) auszuführen. Wenn es sich um einfachen Code handelt, können Sie einen Lambda-Ausdruck verwenden, andernfalls können Sie als Stellvertretung (DispatchedHandler) implementieren. Das System bestimmt eine Zeit, zu der Ihr Code ausgeführt werden kann. Da es den Zugriff über Threads hinweg ermöglicht, ist DependencyObject.Dispatcher die einzige Instanz-API von DependencyObject oder einer seiner Unterklassen, auf die über einen Nicht-UI-Thread zugegriffen werden kann, ohne eine Threadübergreifende Ausnahme zu auslösen. Alle anderen DependencyObject-APIs lösen eine Ausnahme aus, wenn Sie versuchen, sie aus einem Arbeitsthread oder einem anderen Nicht-UI-Thread aufzurufen.

Threadingprobleme können in der Regel im typischen UI-Code vermieden werden. Geräte sind jedoch in der Regel nicht mit dem UI-Thread verknüpft. Wenn Sie Informationen verwenden, die von einem Gerät abgerufen wurden, um die Benutzeroberfläche in Echtzeit zu aktualisieren, müssen Sie häufig einen CoreDispatcher abrufen, damit Sie die Benutzeroberfläche aktualisieren können. Dienste sind ein weiterer Fall, in dem der Code, den Sie für den Zugriff auf den Dienst verwenden, möglicherweise nicht im UI-Thread ausgeführt wird.

Ein Codeszenario, in dem DependencyObject-bezogene Threadingprobleme auftreten können, wenn Sie ihre eigenen DependencyObject-Typen definieren und versuchen, sie für Datenquellen zu verwenden, oder andere Szenarien, in denen ein DependencyObject nicht notwendigerweise geeignet ist (da das Objekt nicht direkt mit der Benutzeroberfläche verknüpft ist). Beispielsweise können Sie perf-Optimierungen mit Hintergrundthreads oder anderen Arbeitsthreads versuchen, die Werte der Objekte vor der Präsentation oder als Reaktion auf ein Gerät, einen Dienst oder eine andere externe Eingabe ändern. Bewerten Sie, ob Sie Abhängigkeitseigenschaften für Ihr Szenario wirklich benötigen. vielleicht sind Standardeigenschaften ausreichend.

Abgeleitete DependencyObject-Klassen

DependencyObject ist die übergeordnete Klasse für mehrere sofort abgeleitete Klassen, die für das Programmiermodell, das Sie für Ihre App und ihre XAML-UI verwenden, grundlegend sind. Hier sind einige der wichtigen abgeleiteten Klassen:

• UIElement: Die Basisklasse für die meisten visuellen Objekte, die Eingaben in der Benutzeroberfläche verarbeiten können. FrameworkElement befindet sich weiter in dieser Hierarchie, wie "Control", daher gibt es Hunderte von Steuerelementen und anderen Klassen in der Windows-Runtime, die alle über die UIElement-Klasse in ihren Klassenhierarchien verfügen.
• Unterstützungsklassen des XAML-Stilsystems: FrameworkTemplate (übergeordnetes Element von ControlTemplate, DataTemplate, ItemsPanelTemplate), Style, SetterBase (übergeordnetes Element von Setter), ToolTipTemplateSettings und andere *TemplateSettings.
• Visuelles Zustandsmodell: Transition, VisualState, VisualStateGroup, VisualStateManager, VisualTransition.
• Unterstützung der Datenbindung: BindingBase (übergeordnetes Element von Binding), CollectionViewSource, PropertyPath, RelativeSource.
• Storyboardanimationen: Zeitachse (übergeordnetes Element von Storyboard, eingegebene Animationen, Designanimationen), eingegebene Keyframes (wie ColorKeyFrame), KeySpline, EasingFunctionBase.
• XAML-Grafiken und Rendergrundtypen: Brush, Geometry, GeneralTransform, GradientStop, PathFigure, PathSegment, Projection.
• ImageSource (übergeordnetes Element von BitmapSource, RenderTargetBitmap, SurfaceImageSource und anderen).
• Fenster: stellt das Hauptfenster der App dar.
• FlyoutBase (übergeordnetes Element von Flyout und MenuFlyout).
• ResourceDictionary: definiert Schlüsselressourcen in XAML.
• TextElement: Übergeordnetes Element von Block und Inline sind diese wiederum Basisklassen für Textelemente, die für TextBlock-Inhalte oder die Rich-Text-Elemente verwendet werden.
• AutomationPeer: Basisklasse für Microsoft Benutzeroberflächenautomatisierung Peers, die XAML-Steuerelemente für einen Microsoft Benutzeroberflächenautomatisierung Listener darstellen. Außerdem : IRawElementProviderSimple.
• Sonstiges: CacheMode, ColumnDefinition, DependencyObjectCollection, InputScope, InputScopeName, PageStackEntry, PrintDocument, RowDefinition, TimelineMarker, TriggerAction, TriggerBase.

Siehe auch

• DependencyProperty
• Übersicht über Abhängigkeitseigenschaften
• Benutzerdefinierte Abhängigkeitseigenschaften
• Benutzerdefinierte angefügte Eigenschaften
• Übersicht über angefügte Eigenschaften