DesignModeValueProvider, classe

Article
08/10/2011

Capture les modifications de propriété apportées par l'utilisateur dans le concepteur et fournit de nouvelles valeurs au moment du design.

Hiérarchie d'héritage

System.Object
Microsoft.Windows.Design.Features.FeatureProvider
Microsoft.Windows.Design.Model.DesignModeValueProvider

Espace de noms : Microsoft.Windows.Design.Model
Assembly : Microsoft.Windows.Design.Interaction (dans Microsoft.Windows.Design.Interaction.dll)

Syntaxe

'Déclaration
Public Class DesignModeValueProvider _
    Inherits FeatureProvider

public class DesignModeValueProvider : FeatureProvider

public ref class DesignModeValueProvider : public FeatureProvider

type DesignModeValueProvider =  
    class
        inherit FeatureProvider
    end

public class DesignModeValueProvider extends FeatureProvider

Le type DesignModeValueProvider expose les membres suivants.

Constructeurs

	Nom	Description
	DesignModeValueProvider	Initialise une nouvelle instance de la classe DesignModeValueProvider.

Début

Propriétés

	Nom	Description
	Properties	Obtient le jeu de propriétés à capturer.

Début

Méthodes

	Nom	Description
	Equals	Détermine si l'Object spécifié est égal à l'Object en cours. (Hérité de Object.)
	Finalize	Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
	GetHashCode	Sert de fonction de hachage pour un type particulier. (Hérité de Object.)
	GetType	Obtient le Type de l'instance actuelle. (Hérité de Object.)
	InvalidateProperty	Invalide la propriété spécifiée.
	MemberwiseClone	Crée une copie superficielle de l'objet Object actif. (Hérité de Object.)
	ToString	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object.)
	TranslatePropertyValue	Capture les modifications de propriété effectuées par l'utilisateur dans le concepteur et utilise la logique personnalisée pour fournir de nouvelles valeurs au moment du design.

Début

Notes

Lorsqu'un utilisateur modifie une valeur de propriété d'un objet dans le concepteur, cette valeur est généralement définie sur l'objet dans le concepteur. Grâce à la classe DesignModeValueProvider, vous pouvez insérer votre propre logique dans ce processus. Par exemple, même si vous souhaitez que l'utilisateur puisse affecter la valeur false à la propriété visible d'un contrôle, celui-ci doit rester visible au moment du design.

Pour ce faire, vous créez un DesignModeValueProvider et l'attachez à votre contrôle personnalisé. DesignModeValueProvider capture les modifications de propriété apportées par l'utilisateur, vous insérez votre propre logique dans la méthode TranslatePropertyValue et DesignModeValueProvider passe les nouvelles valeurs au concepteur.

Important

Lorsque vous utilisez cette technique, le comportement d'une propriété dans le concepteur ne correspond pas à la valeur de la propriété en mode XAML. En effet, le mode XAML affiche la valeur que l'utilisateur a entrée au moment du design. La valeur en mode XAML représente le comportement de la propriété au moment de l'exécution.

Les restrictions suivantes s'appliquent lorsque vous utilisez la classe DesignModeValueProvider pour modifier une valeur de propriété au moment du design.

Vous pouvez définir un fournisseur de valeur au moment du design uniquement sur les types qui dérivent de la classe DependencyObject.
Vous pouvez définir un fournisseur de valeur au moment du design uniquement sur les propriétés de dépendance.
Votre implémentation de DesignModeValueProvider doit définir la valeur au moment du design sur une propriété de type de base. Vous pouvez implémenter votre fournisseur de valeur pour cibler le type dérivé spécifique. Par exemple, pour enregistrer un fournisseur de valeur pour la propriété Height de la classe Button, vous devez l'enregistrer sur la classe FrameworkElement et tester le type cible dans l'implémentation de fournisseur de valeur. Pour plus d'informations, consultez Procédure pas à pas : modification du comportement d'une propriété au moment du design.
Les fournisseurs de valeur sont exécutés dans l'ordre dans lequel ils sont enregistrés. Le fournisseur de valeur le plus récent enregistré pour une propriété est exécuté en dernier ; toutefois, tous les fournisseurs de valeur sont exécutés.
Si l'implémentation de TranslatePropertyValue de votre fournisseur de valeur retourne nullune référence null (Nothing en Visual Basic), la valeur au moment du design de la propriété est nullune référence null (Nothing en Visual Basic).
Si l'implémentation de TranslatePropertyValue de votre fournisseur de valeur retourne la valeur statique UnsetValue, le Concepteur WPF appelle la méthode ClearValue sur la propriété.

Notes

Si vous écrivez un fournisseur de valeur pour un contrôle Silverlight, vous devez utiliser la version WPF de UnsetValue. C'est une limitation de l'infrastructure Concepteur WPF.

Les fournisseurs de valeur ne fonctionnent pas avec les propriétés héritées WPF. Par exemple, enregistrer un fournisseur de valeur pour FlowDirection ne fonctionne pas comme prévu en mode Design.
Si la valeur de propriété est définie par une liaison, votre fournisseur de valeur doit retourner un Binding au lieu d'une valeur calculée.
Certains fournisseurs de valeur ne peuvent pas être honorés parce que le concepteur devra peut-être forcer une propriété afin qu'elle prenne une valeur spécifique au moment du design pour garantir une expérience de conception particulière. Par exemple, un fournisseur de valeur personnalisé pour les propriétés de police ne fonctionne pas comme prévu dans le Concepteur WPF.
Lorsque vous enregistrez un fournisseur de valeur à l'aide de TypeIdentifier, l'identificateur de type passé à votre implémentation de TranslatePropertyValue peut ne pas être identique à celui spécifié dans les métadonnées au moment du design. Il sera équivalent, mais il pourra ne pas s'agir de la même instance. Si votre fournisseur de valeur exécute la vérification de type, vous devez résoudre le composant de type de l'identificateur de propriété et exécuter un test d'équivalence des types sur le type résolu. Généralement, vous vérifiez simplement le nom de la propriété, mais si vous devez exécuter la logique sur le type, vous devez résoudre l'identificateur de type. Utilisez la méthode ResolveType pour obtenir le type correct.
L'infrastructure Concepteur WPF peut passer un identificateur dans tout format pris en charge. Si votre fournisseur de valeur effectue la comparaison de type, vous devez résoudre l'identificateur de type en type réel. Utilisez la méthode ResolveType pour obtenir le type correct.

Exemples

L'exemple suivant crée un DesignModeValueProvider personnalisé qui sera attaché à un contrôle bouton personnalisé. Dans la méthode TranslatePropertyValue, vous modifiez la propriété Content de Button afin qu'il s'affiche en majuscules dans le concepteur. Vous modifiez également la propriété Background de Button afin qu'il s'affiche avec la couleur système par défaut dans le concepteur. Ces modifications concernent le concepteur uniquement. Au moment de l'exécution, les propriétés Content et Background s'affichent avec les valeurs définies par l'utilisateur.

Pour plus d'informations, consultez Procédure pas à pas : modification du comportement d'une propriété au moment du design.



Imports System
Imports System.Windows                  'SystemColors
Imports System.Windows.Media            'SolidColorBrush
Imports System.Windows.Controls         'Button
Imports Microsoft.Windows.Design.Model  'DesignModeValueProvider
Imports Microsoft.Windows.Design.Metadata


Namespace CustomButton

    Public Class CustomButtonDesignModeValueProvider
        Inherits DesignModeValueProvider


        Public Sub New()
            Properties.Add(GetType(Button), "Content")
            Properties.Add(GetType(Button), "Background")
        End Sub



        Public Overrides Function TranslatePropertyValue( _
            ByVal item As ModelItem, _
            ByVal identifier As PropertyIdentifier, _
            ByVal value As Object) As Object

            If identifier.DeclaringType Is GetType(Button) And _
               identifier.Name = "Content" Then

                Return value.ToString().ToUpper()
            End If

            If identifier.DeclaringType Is GetType(Button) And _
               identifier.Name = "Background" Then

                Return New SolidColorBrush(SystemColors.ControlColor)
            End If

            Return MyBase.TranslatePropertyValue(item, identifier, value)
        End Function
    End Class
End Namespace



using System;
using System.Windows;                   //SystemColors
using System.Windows.Media;             //SolidColorBrush
using System.Windows.Controls;          //Button
using Microsoft.Windows.Design.Model;
using Microsoft.Windows.Design.Metadata;   //DesignModeValueProvider
namespace CustomButton
{
    class CustomButtonDesignModeValueProvider : DesignModeValueProvider
    {

        public CustomButtonDesignModeValueProvider()
        {
            Properties.Add( typeof(Button), "Content");
            Properties.Add(typeof(Button), "Background");
        }


        public override object TranslatePropertyValue(ModelItem item, PropertyIdentifier identifier, object value)
        {
            if (identifier.DeclaringType == typeof( Button ) &&
                identifier.Name == "Content" )
            {
                return ((string)value).ToUpper();
            }

            if (identifier.DeclaringType == typeof(Button) &&
                identifier.Name == "Background")
            {
                return new SolidColorBrush(SystemColors.ControlColor);
            }

            return base.TranslatePropertyValue(item, identifier, value);
        }
    }
}

Sécurité des threads

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.