Partage via

DependencyObject Classe

  • Référence

Définition

Espace de noms:
Windows.UI.Xaml
Modifier

Représente un objet qui participe au système des propriétés de dépendance. DependencyObject est la classe de base immédiate de nombreuses classes importantes liées à l’interface utilisateur, telles que UIElement, Geometry, FrameworkTemplate, Style et ResourceDictionary. Pour plus d’informations sur la façon dont DependencyObject prend en charge les propriétés de dépendance, consultez Vue d’ensemble des propriétés de dépendance.

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é
Attributs
ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Configuration requise pour Windows

Famille d’appareils
Windows 10 (introduit dans 10.0.10240.0)
API contract
Windows.Foundation.UniversalApiContract (introduit dans v1.0)

Exemples

Cet exemple définit une classe qui dérive de DependencyObject et définit une propriété jointe avec le champ 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 dans XAML Le service agit potentiellement sur les valeurs de propriété attachées 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és 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 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 système de propriété de dépendance sur ses nombreuses classes dérivées. Pour plus d’informations sur le concept de propriété de dépendance, consultez Vue d’ensemble des propriétés de dépendance.

La fonction principale du système de propriétés de dépendance est de calculer les valeurs des propriétés et de fournir une notification système sur les valeurs qui ont changé. Une autre classe de clé qui participe au système de propriétés de dépendance est DependencyProperty. DependencyProperty permet 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 Windows Runtime existantes.
  • Prise en charge de l’hébergement de propriétés de dépendance personnalisées. 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 Windows Runtime existantes.
  • 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.
  • Méthodes d’utilitaire Get et Set 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 la propriété de dépendance personnalisée « wrappers » et vous 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 l’examen des métadonnées ou des valeurs de propriété (par exemple , GetAnimationBaseValue).
  • Application de l’affinité de thread au thread d’interface utilisateur main du Windows Runtime pour toutes les instances DependencyObject.
  • Propriété Dispatcher pour les scénarios de thread avancés. 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 de données et du style 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 Vue d’ensemble des propriétés de dépendance. Voir aussi Liaison de données en détail.

DependencyObject et threading

Toutes les instances DependencyObject doivent être créées sur le thread d’interface utilisateur associé à la fenêtre actuelle pour une application. Ceci est appliqué par le système, et cela a 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. Vous ne rencontrez généralement pas de problèmes de thread dans ce scénario.
  • Le code qui ne s’exécute pas sur le thread d’interface utilisateur main ne peut pas accéder directement à un DependencyObject, car un DependencyObject a une affinité de thread uniquement avec le thread d’interface utilisateur. Seul le code qui s’exécute sur le thread d’interface utilisateur peut modifier ou même lire la valeur d’une propriété de dépendance. Par exemple, un thread de travail que vous avez initié avec une tâche .NET ou un thread ThreadPool explicite ne peut pas lire les propriétés de dépendance ou appeler d’autres API.

Vous n’êtes pas complètement empêché d’utiliser 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’obtenir la séparation délibérée entre le thread d’interface utilisateur de l’application et les autres threads en cours d’exécution 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 l’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 instance de DependencyObject ou de l’une de ses sous-classes accessibles à partir d’un thread autre que l’interface utilisateur sans lever d’exception de thread croisé. Toutes les autres API DependencyObject lèvent une exception si vous tentez de les appeler à partir d’un thread de travail ou de tout autre thread non-interface utilisateur.

Les problèmes de threading peuvent généralement être évités dans le code d’interface utilisateur standard. Toutefois, les appareils ne sont généralement pas associés au thread d’interface utilisateur. Si vous utilisez les 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 où vous pouvez rencontrer des problèmes de thread liés à DependencyObject si vous définissez vos propres types DependencyObject et que vous essayez de les utiliser pour des 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 pouvez essayer 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 de DependencyObject

DependencyObject est la classe parente de 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 :

Constructeurs

DependencyObject()

Fournit le comportement d’initialisation de classe de base pour les classes dérivées de DependencyObject .

Propriétés

Dispatcher

Obtient le CoreDispatcher auquel cet objet est associé. CoreDispatcher représente une installation qui peut accéder à DependencyObject sur le thread d’interface utilisateur, même si le code est initié par un thread autre que l’interface utilisateur.

Méthodes

ClearValue(DependencyProperty)

Efface la valeur locale d’une propriété de dépendance.
GetAnimationBaseValue(DependencyProperty)

Retourne toute valeur de base établie pour une propriété de dépendance, qui s’applique dans les cas où une animation n’est pas active.
GetValue(DependencyProperty)

Retourne la valeur effective actuelle d’une propriété de dépendance à partir d’un objet DependencyObject.
ReadLocalValue(DependencyProperty)

Retourne la valeur locale d’une propriété de dépendance, si une valeur locale est définie.
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)

Inscrit une fonction de notification pour écouter les modifications apportées à un DependencyProperty spécifique sur ce instance DependencyObject.
SetValue(DependencyProperty, Object)

Définit la valeur locale d’une propriété de dépendance sur un DependencyObject.
UnregisterPropertyChangedCallback(DependencyProperty, Int64)

Annule une notification de modification précédemment inscrite en appelant RegisterPropertyChangedCallback.

S’applique à

Voir aussi