DependencyObject Classe

Définition

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

Héritage

Object Platform::Object IInspectable DependencyObject

Dérivé

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

Plus…

Attributs

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Configuration requise pour Windows

Exemples

Cet exemple définit une classe qui dérive de DependencyObject et définit une propriété jointe avec le champ d’identificateur. Le scénario de cette classe est qu’il s’agit d’une classe de service qui déclare une propriété jointe que d’autres éléments d’interface utilisateur peuvent définir en XAML Le service agit potentiellement sur les valeurs de propriété jointes sur ces éléments d’interface utilisateur au moment de l’exécution.

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

Cet exemple montre une déclaration de propriété de dépendance simple. Un appel à GetValue constitue l’intégralité de l’implémentation de l’accesseur get pour le wrapper de propriété de la nouvelle propriété de dépendance. Un appel à SetValue constitue l’intégralité de l’implémentation de l’accesseur set . Pour plus d’exemples, consultez les propriétés de dépendance personnalisées.

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

Remarques

La classe DependencyObject active les services de système de propriétés de dépendance sur ses nombreuses classes dérivées. Pour plus d’informations sur le concept de propriété de dépendance, consultez la vue d’ensemble des propriétés de dépendance.

La fonction principale du système de propriétés de dépendance consiste à calculer les valeurs des propriétés et à fournir une notification système sur les valeurs qui ont changé. Une autre classe clé qui participe au système de propriétés de dépendance est DependencyProperty. DependencyProperty active l’inscription des propriétés de dépendance dans le système de propriétés, tandis que DependencyObject en tant que classe de base permet aux objets d’utiliser et de définir les propriétés de dépendance.

Voici quelques services et caractéristiques notables que DependencyObject fournit ou prend en charge :

• Prise en charge de l’hébergement de propriétés de dépendance pour les propriétés de dépendance existantes Windows Runtime.
• Prise en charge de l’hébergement de propriétés de dépendance personnalisée. Vous inscrivez une propriété de dépendance en appelant la méthode Register et en stockant la valeur de retour de la méthode en tant que propriété statique publique dans votre classe DependencyObject.
• Prise en charge de l’hébergement de propriétés jointes pour les propriétés jointes existantes Windows Runtime.
• Prise en charge de l’hébergement de propriétés jointes personnalisées. Vous inscrivez une propriété de dépendance pour l’utilisation de la propriété jointe en appelant la méthode RegisterAttached et en stockant la valeur de retour de la méthode en tant que propriété statique publique dans votre classe.
• Obtenir et définir des méthodes utilitaires pour les valeurs de toutes les propriétés de dépendance qui existent sur un DependencyObject. Vous les utilisez lors de la définition de propriétés de dépendance personnalisées « wrappers » et pouvez également les utiliser à partir du code d’application comme alternative à l’utilisation des propriétés « wrapper » existantes.
• Utilitaire de scénario avancé pour examiner les métadonnées ou les valeurs de propriété (par exemple GetAnimationBaseValue).
• Application de l’affinité de thread au thread d’interface utilisateur principal de l’Windows Runtime pour toutes les instances DependencyObject.
• Propriété Dispatcher pour les scénarios avancés de threading. L’obtention de la valeur Dispatcher fournit une référence à un objet CoreDispatcher . Avec CoreDispatcher, un thread de travail peut exécuter du code qui utilise un DependencyObject, mais qui n’est pas sur le thread d’interface utilisateur, car CoreDispatcher peut différer l’exécution vers une opération asynchrone qui ne bloque pas ou n’interfère pas avec le thread d’interface utilisateur. Consultez la section « DependencyObject et threading » ci-dessous.
• Prise en charge de la liaison et du style de données de base, en permettant aux propriétés d’être définies en tant qu’expressions à évaluer ultérieurement dans la durée de vie d’un objet. Ces concepts sont expliqués plus en détail dans la vue d’ensemble des propriétés de dépendance. Voir également la liaison de données en profondeur.

DependencyObject et fil

Toutes les instances DependencyObject doivent être créées sur le thread d’interface utilisateur associé à la fenêtre active d’une application. Cela est appliqué par le système et il existe deux implications importantes pour votre code :

• Le code qui utilise l’API de deux instances DependencyObject est toujours exécuté sur le même thread, qui est toujours le thread d’interface utilisateur. En règle générale, vous ne rencontrez pas de problèmes de threading dans ce scénario.
• Le code qui n’est pas en cours d’exécution sur le thread d’interface utilisateur principal ne peut pas accéder directement à DependencyObject, car un DependencyObject a une affinité de thread avec le thread d’interface utilisateur uniquement. Seul le code qui s’exécute sur le thread d’interface utilisateur peut changer ou même lire la valeur d’une propriété de dépendance. Par exemple, un thread de travail que vous avez lancé avec une tâche .NET ou un thread ThreadPool explicite ne pourra pas lire les propriétés de dépendance ou appeler d'autres API.

Vous n’êtes pas complètement bloqué à l’aide d’un DependencyObject à partir d’un thread de travail. Toutefois, vous devez obtenir un objet CoreDispatcher (la valeur de DependencyObject.Dispatcher) à partir d’un DependencyObject afin d’atteindre la séparation délibérée entre le thread d’interface utilisateur de l’application et tous les autres threads exécutés sur le système. CoreDispatcher expose la méthode RunAsync. Appelez RunAsync pour exécuter votre code awaitable (un IAsyncAction). S’il s’agit d’un code simple, vous pouvez utiliser une expression lambda, sinon vous pouvez implémenter en tant que délégué (DispatchedHandler). Le système détermine une heure à laquelle votre code peut être exécuté. Étant donné qu’il active l’accès entre les threads, DependencyObject.Dispatcher est la seule API d’instance de DependencyObject ou l’une de ses sous-classes accessibles à partir d’un thread autre que l’interface utilisateur sans lever d’exception entre threads. Toutes les autres API DependencyObject lèvent une exception si vous tentez de les appeler à partir d’un thread de travail ou d’un autre thread autre que l’interface utilisateur.

Les problèmes de thread peuvent généralement être évités dans le code d’interface utilisateur classique. Toutefois, les appareils ne sont généralement pas associés au thread d’interface utilisateur. Si vous utilisez des informations obtenues à partir d’un appareil pour mettre à jour l’interface utilisateur en temps réel, vous devez souvent obtenir un CoreDispatcher pour pouvoir mettre à jour l’interface utilisateur. Les services sont un autre cas où le code que vous utilisez pour accéder au service peut ne pas s’exécuter sur le thread d’interface utilisateur.

Un scénario de code dans lequel vous pouvez rencontrer des problèmes de thread liés à DependencyObject si vous définissez vos propres types DependencyObject et que vous tentez de les utiliser pour les sources de données, ou d’autres scénarios où un DependencyObject n’est pas nécessairement approprié (car l’objet n’est pas directement lié à l’interface utilisateur). Par exemple, vous tentez peut-être d’optimiser les performances avec des threads d’arrière-plan ou d’autres threads de travail qui modifient les valeurs des objets avant la présentation, ou en réponse à un appareil, un service ou une autre entrée externe. Évaluez si vous avez vraiment besoin de propriétés de dépendance pour votre scénario ; peut-être que les propriétés standard sont adéquates.

Classes dérivées DependencyObject

DependencyObject est la classe parente pour plusieurs classes dérivées immédiatement qui sont toutes fondamentales pour le modèle de programmation que vous utilisez pour votre application et son interface utilisateur XAML. Voici quelques-unes des classes dérivées notables :

• UIElement : classe de base pour la plupart des objets visuels qui peuvent traiter les entrées dans l’interface utilisateur. FrameworkElement est plus loin dans cette hiérarchie, tel que Control, de sorte qu’il existe des centaines de contrôles et d’autres classes dans la Windows Runtime qui ont toutes la classe UIElement dans leurs hiérarchies de classe.
• Classes de prise en charge du système de style XAML : FrameworkTemplate (parent de ControlTemplate, DataTemplate, ItemsPanelTemplate), Style, SetterBase (parent de Setter), ToolTipTemplateSettings et autres *TemplateSettings.
• Modèle d’état visuel : Transition, VisualState,VisualStateGroup, VisualStateManager, VisualTransition.
• Prise en charge de la liaison de données : BindingBase (parent de Binding), CollectionViewSource, PropertyPath, RelativeSource.
• Animations storyboarded : Chronologie (parent de Storyboard, animations typées, animations de thème), images clés typées (comme ColorKeyFrame), KeySpline, EasingFunctionBase.
• Primitives de rendu et graphiques XAML : Brush, Geometry, GeneralTransform, GradientStop, PathFigure, PathSegment, Projection.
• Imagerie et interopérabilité de la surface de rendu : ImageSource (parent de BitmapSource, RenderTargetBitmap, SurfaceImageSource et autres).
• Fenêtre : représente la fenêtre principale de l’application.
• FlyoutBase (parent de Flyout et MenuFlyout).
• ResourceDictionary : définit des ressources clé en XAML.
• TextElement : parent de Block et Inline, il s’agit à son tour de classes de base pour les éléments de texte utilisés pour le contenu TextBlock ou les éléments de texte enrichi.
• AutomationPeer : classe de base pour Microsoft UI Automation homologues qui représentent des contrôles XAML à un écouteur Microsoft UI Automation. En outre, IRawElementProviderSimple.
• Divers : CacheMode, ColumnDefinition, DependencyObjectCollection, InputScope, InputScopeName, PageStackEntry, PrintDocument, RowDefinition, TimelineMarker, TriggerAction, TriggerBase.

Voir aussi

• DependencyProperty
• Vue d’ensemble des propriétés de dépendance
• Propriétés de dépendance personnalisées
• Propriétés jointes personnalisées
• Vue d’ensemble des propriétés jointes