Métadonnées de propriété de dépendance

Le système de propriétés Windows Presentation Foundation (WPF) inclut un système de création de rapports de métadonnées qui va au-delà de ce qui peut être signalé à propos d’une propriété par le biais de caractéristiques clR (Common Language Runtime) générales ou de réflexion. Les métadonnées d’une propriété de dépendance peuvent également être affectées de manière unique par la classe qui définit une propriété de dépendance, peuvent être modifiées lorsque la propriété de dépendance est ajoutée à une autre classe et peut être spécifiquement remplacée par toutes les classes dérivées qui héritent de la propriété de dépendance de la classe de base définissante.

Conditions préalables

Cette rubrique part du principe que vous comprenez les propriétés de dépendance du point de vue d’un consommateur de propriétés de dépendance existantes sur les classes WPF et que vous avez lu la vue d’ensemble des propriétés de dépendance . Pour suivre les exemples de cette rubrique, vous devez également comprendre XAML et savoir comment écrire des applications WPF.

Utilisation des métadonnées de propriété de dépendance

Les métadonnées de propriété de dépendance existent en tant qu’objet qui peut être interrogé pour examiner les caractéristiques d’une propriété de dépendance. Ces métadonnées sont également consultées fréquemment par le système de propriétés, car elles traitent n’importe quelle propriété de dépendance donnée. L’objet de métadonnées d’une propriété de dépendance peut contenir les types d’informations suivants :

• Valeur par défaut de la propriété de dépendance, si aucune autre valeur ne peut être déterminée pour la propriété de dépendance par valeur locale, style, héritage, etc. Pour une discussion approfondie sur la façon dont les valeurs par défaut participent à la priorité utilisée par le système de propriétés lors de l’affectation de valeurs pour les propriétés de dépendance, consultez priorité de valeur de propriété de dépendance.

• Références aux implémentations de rappel qui affectent les comportements de contrainte ou de notification de modification en fonction de chaque type de propriétaire. Notez que ces rappels sont souvent définis avec un niveau d’accès non public. Par conséquent, l’obtention des références réelles à partir des métadonnées n’est généralement pas possible, sauf si les références se trouvent dans votre étendue d’accès autorisée. Pour plus d’informations sur les callbacks et la validation des propriétés de dépendance, consultez Callbacks de propriétés de dépendance et validation.

• Si la propriété de dépendance en question est considérée comme une propriété au niveau de l’infrastructure WPF, les métadonnées peuvent contenir des caractéristiques de propriété de dépendance au niveau de l’infrastructure WPF, qui signalent des informations et un état pour les services tels que le moteur de disposition au niveau du framework WPF et la logique d’héritage des propriétés. Pour plus d’informations sur cet aspect des métadonnées de propriété de dépendance, consultez Framework Property Metadata.

API de métadonnées

Le type qui signale la plupart des informations de métadonnées utilisées par le système de propriétés est la classe PropertyMetadata. Les instances de métadonnées sont éventuellement spécifiées lorsque les propriétés de dépendance sont inscrites auprès du système de propriétés et peuvent être spécifiées à nouveau pour des types supplémentaires qui s’ajoutent en tant que propriétaires ou remplacent les métadonnées qu’ils héritent de la définition de propriété de dépendance de la classe de base. (Dans les cas où une inscription de propriété ne spécifie pas de métadonnées, une PropertyMetadata par défaut est créée avec des valeurs par défaut pour cette classe.)Les métadonnées inscrites sont retournées en tant que PropertyMetadata lorsque vous appelez les différentes surcharges de GetMetadata qui obtiennent des métadonnées à partir d’une propriété de dépendance sur une instance de DependencyObject.

La classe PropertyMetadata est ensuite dérivée de pour fournir des métadonnées plus spécifiques pour les divisions architecturales telles que les classes au niveau du framework WPF. UIPropertyMetadata ajoute des rapports d’animation et FrameworkPropertyMetadata fournit les propriétés au niveau de l’infrastructure WPF mentionnées dans la section précédente. Lorsque les propriétés de dépendance sont inscrites, elles peuvent être inscrites auprès de ces classes dérivées PropertyMetadata. Lorsque les métadonnées sont examinées, le type de base PropertyMetadata peut potentiellement être converti en classes dérivées afin de pouvoir examiner les propriétés plus spécifiques.

Quand remplacer les métadonnées, Quand dériver une classe

Le système de propriétés WPF a établi des fonctionnalités permettant de modifier certaines caractéristiques des propriétés de dépendance sans les obliger à être entièrement réinscrites. Pour ce faire, construisez une autre instance de métadonnées de propriété pour la propriété de dépendance telle qu’elle existe sur un type particulier. Notez que la plupart des propriétés de dépendance existantes ne sont pas des propriétés virtuelles. Par conséquent, les « ré-implémentations » strictement parlant sur les classes héritées ne peuvent être effectuées qu’en omettant le membre existant.

Si le scénario que vous essayez d’activer pour une propriété de dépendance sur un type ne peut pas être accompli en modifiant les caractéristiques des propriétés de dépendance existantes, il peut être nécessaire de créer une classe dérivée, puis de déclarer une propriété de dépendance personnalisée sur votre classe dérivée. Une propriété de dépendance personnalisée se comporte de façon identique aux propriétés de dépendance définies par les API WPF. Pour plus d’informations sur les propriétés de dépendance personnalisées, consultez propriétés de dépendance personnalisées.

Une caractéristique notable d’une propriété de dépendance que vous ne pouvez pas remplacer est son type valeur. Si vous héritez d’une propriété de dépendance qui a le comportement approximatif dont vous avez besoin, mais que vous avez besoin d’un type différent pour celui-ci, vous devez implémenter une propriété de dépendance personnalisée et peut-être lier les propriétés par le biais de la conversion de type ou d’une autre implémentation sur votre classe personnalisée. En outre, vous ne pouvez pas remplacer un ValidateValueCallbackexistant, car ce rappel existe dans le champ d’inscription lui-même et non dans ses métadonnées.

Scénarios de modification des métadonnées existantes

Si vous utilisez des métadonnées d’une propriété de dépendance existante, un scénario courant de modification des métadonnées de propriété de dépendance consiste à modifier la valeur par défaut. La modification ou l’ajout de rappels de système de propriétés est un scénario plus avancé. Vous pouvez le faire si votre implémentation d’une classe dérivée comporte différentes interconnexions entre les propriétés de dépendance. L’une des conditions d’avoir un modèle de programmation qui prend en charge à la fois le code et l’utilisation déclarative est que les propriétés doivent être définies dans n’importe quel ordre. Par conséquent, toutes les propriétés dépendantes doivent être définies juste-à-temps sans contexte et ne peuvent pas compter sur la connaissance d’un ordre de paramètre tel que peut être trouvé dans un constructeur. Pour plus d’informations sur cet aspect du système de propriétés, consultez Propriétés de dépendance : rappels et validation. Notez que les rappels de validation ne font pas partie des métadonnées ; ils font partie de l’identificateur de propriété de dépendance. Par conséquent, les rappels de validation ne peuvent pas être modifiés en substituant les métadonnées.

Dans certains cas, vous pouvez également modifier les options de métadonnées de propriété au niveau de l’infrastructure WPF sur les propriétés de dépendance existantes. Ces options communiquent certaines conditionnelles connues concernant les propriétés au niveau du framework WPF à d'autres processus de niveau framework WPF, tels que le système de mise en page. La définition des options est généralement effectuée uniquement lors de l’inscription d’une nouvelle propriété de dépendance, mais il est également possible de modifier les métadonnées de propriété au niveau de l’infrastructure WPF dans le cadre d’un appel de OverrideMetadata ou de AddOwner. Pour connaître les valeurs spécifiques à utiliser et plus d’informations, consultez Framework Property Metadata. Pour plus d’informations sur la façon dont ces options doivent être définies pour une propriété de dépendance nouvellement inscrite, consultez Propriétés de dépendance personnalisées.

Remplacement des métadonnées

L’objectif de substitution des métadonnées est principalement de vous permettre de modifier les différents comportements dérivés des métadonnées qui sont appliqués à la propriété de dépendance telle qu’elle existe sur votre type. Les raisons de cela sont expliquées plus en détail dans la section Métadonnées. Pour plus d’informations, notamment quelques exemples de code, consultez le document intitulé "Remplacer les métadonnées pour une propriété de dépendance".

Les métadonnées de propriété peuvent être fournies pour une propriété de dépendance pendant l’appel d’inscription (Register). Toutefois, dans de nombreux cas, vous souhaiterez peut-être fournir des métadonnées spécifiques au type pour votre classe lorsqu’elle hérite de cette propriété de dépendance. Pour ce faire, appelez la méthode OverrideMetadata. Pour obtenir un exemple à partir des API WPF, la classe FrameworkElement est le type qui inscrit d’abord la propriété de dépendance Focusable. Toutefois, la classe Control remplace les métadonnées de la propriété de dépendance pour fournir sa propre valeur par défaut initiale, en la remplaçant de false par true, et utilise à nouveau l’implémentation de Focusable d’origine.

Lorsque vous remplacez les métadonnées, les différentes caractéristiques des métadonnées sont fusionnées ou remplacées.

• PropertyChangedCallback a été fusionné. Si vous ajoutez une nouvelle PropertyChangedCallback, ce callback est stocké dans les métadonnées. Si vous ne spécifiez pas de PropertyChangedCallback dans le remplacement, la valeur de PropertyChangedCallback est utilisée comme référence provenant de l’ancêtre le plus proche qui l’a spécifiée dans les métadonnées.

• Le comportement réel du système de propriétés pour PropertyChangedCallback est que les implémentations pour tous les propriétaires de métadonnées de la hiérarchie sont conservées et ajoutées à une table, avec l’ordre d’exécution par le système de propriétés étant que les rappels de la classe la plus dérivée sont appelés en premier.

• DefaultValue est remplacé. Si vous ne spécifiez pas de DefaultValue dans le remplacement, la valeur de DefaultValue provient de l’ancêtre le plus proche qui l’a spécifié dans les métadonnées.

• CoerceValueCallback implémentations sont remplacées. Si vous ajoutez une nouvelle CoerceValueCallback, ce callback est stocké dans les métadonnées. Si vous ne spécifiez pas de CoerceValueCallback dans le remplacement, la valeur de CoerceValueCallback est promue comme référence à partir de l’ancêtre le plus proche qui l’a spécifiée dans les métadonnées.

• Le comportement du système de propriétés est que seule la CoerceValueCallback dans les métadonnées immédiates est invoquée. Aucune référence à d’autres implémentations de CoerceValueCallback dans la hiérarchie n’est conservée.

Ce comportement est implémenté par Mergeet peut être substitué sur les classes de métadonnées dérivées.

Redéfinition des métadonnées de propriété jointe

Dans WPF, les propriétés jointes sont implémentées en tant que propriétés de dépendance. Cela signifie qu’ils ont également des métadonnées de propriété, que les classes individuelles peuvent remplacer. Les considérations exploratoires relatives à une propriété jointe dans WPF sont généralement que toutes les DependencyObject peuvent avoir une propriété jointe définie dessus. Par conséquent, toute classe dérivée DependencyObject peut remplacer les métadonnées pour n’importe quelle propriété jointe, car elle peut être définie sur une instance de la classe. Vous pouvez remplacer les valeurs par défaut, les rappels ou les propriétés de création de rapports caractéristiques au niveau de l’infrastructure WPF. Si la propriété attachée est définie sur une instance de votre classe, les caractéristiques de substitution des métadonnées de propriété s'appliquent. Par exemple, vous pouvez remplacer la valeur par défaut, de sorte que votre valeur de remplacement est signalée comme valeur de la propriété jointe sur les instances de votre classe, chaque fois que la propriété n’est pas définie autrement.

Ajout d’une classe en tant que propriétaire d’une propriété de dépendance existante

Une classe peut s’ajouter en tant que propriétaire d’une propriété de dépendance qui a déjà été inscrite, à l’aide de la méthode AddOwner. Cela permet à la classe d’utiliser une propriété de dépendance qui a été inscrite à l’origine pour un autre type. La classe d’ajout n’est généralement pas une classe dérivée du type qui a d’abord inscrit cette propriété de dépendance en tant que propriétaire. En effet, cela permet à votre classe et à ses classes dérivées d'« hériter » d’une implémentation de propriété de dépendance sans que la classe propriétaire d’origine et la classe ajoutante soient dans la même véritable hiérarchie de classes. En outre, l’ajout de la classe (et de toutes les classes dérivées) peut ensuite fournir des métadonnées spécifiques au type pour la propriété de dépendance d’origine.

En plus de s’ajouter en tant que propriétaire par le biais des méthodes utilitaires du système de propriétés, la classe d’ajout doit déclarer des membres publics supplémentaires sur elle-même afin de rendre la propriété de dépendance un acteur à part entière dans le système de propriétés, avec une exposition au code et au balisage. Une classe qui ajoute une propriété de dépendance existante a les mêmes responsabilités que pour exposer le modèle objet de cette propriété de dépendance, comme une classe qui définit une nouvelle propriété de dépendance personnalisée. Le premier membre à exposer est un champ d’identificateur de propriété de dépendance. Ce champ doit être un champ public static readonly de type DependencyProperty, qui est affecté à la valeur de retour de l’appel AddOwner. Le deuxième membre à définir est la propriété « wrapper » du Common Language Runtime (CLR). Le wrapper facilite considérablement la manipulation de votre propriété de dépendance dans le code (vous évitez les appels à SetValue chaque fois et ne pouvez effectuer cet appel qu’une seule fois dans le wrapper lui-même). Le wrapper est implémenté de façon identique à la façon dont il serait implémenté si vous inscrivez une propriété de dépendance personnalisée. Pour plus d’informations sur l’implémentation d’une propriété de dépendance, consultez propriétés de dépendance personnalisées et Ajouter un type de propriétaire pour une propriété de dépendance.

AddOwner et Propriétés Attachées

Vous pouvez appeler AddOwner pour une propriété de dépendance définie en tant que propriété jointe par la classe propriétaire. En règle générale, la raison de cette opération consiste à exposer la propriété précédemment attachée en tant que propriété de dépendance non attachée. Vous allez ensuite exposer la valeur de retour AddOwner en tant que champ public static readonly à utiliser comme identificateur de propriété de dépendance et définir les propriétés « wrapper » appropriées afin que la propriété apparaisse dans la table des membres et prenne en charge une utilisation des propriétés non jointes dans votre classe.

Voir aussi

• PropertyMetadata
• DependencyObject
• DependencyProperty
• GetMetadata
• Vue d’ensemble des propriétés de dépendance
• Métadonnées de propriété du framework