Ajouter des propriétés personnalisées aux diagrammes de dépendanceAdd custom properties to dependency diagrams

Lorsque vous écrivez le code d’extension pour les diagrammes de dépendance, vous pouvez stocker des valeurs avec n’importe quel élément sur un diagramme de dépendances.When you write extension code for dependency diagrams, you can store values with any element on a dependency diagram. Les valeurs persisteront lorsque le diagramme est enregistré et rouvert.The values will persist when the diagram is saved and re-opened. Vous pouvez également avoir ces propriétés s’affichent dans le propriétés fenêtre afin que les utilisateurs peuvent voir et les modifier.You can also have these properties appear in the Properties window so that users can see and edit them. Par exemple, vous pouvez permettre aux utilisateurs de spécifier une expression régulière pour chaque couche, et écrire le code de validation pour vérifier que les noms de classes dans chaque couche sont conformes au modèle spécifié par l’utilisateur.For example, you could let users specify a regular expression for each layer, and write validation code to verify that the names of classes in each layer conform to the pattern specified by the user.

Propriétés non visibles par l'utilisateurProperties not visible to the user

Si vous souhaitez simplement votre code pour attacher des valeurs à un élément dans un diagramme de dépendances, vous n’avez pas besoin de définir un composant MEF.If you just want your code to attach values to any element in a dependency diagram, you don't need to define a MEF component. Il existe un dictionnaire nommé Properties dans ILayerElement.There is a dictionary named Properties in ILayerElement. Ajoutez simplement les valeurs marshalables au dictionnaire d’un élément de couche.Simply add marshalable values to the dictionary of any layer element. Elles seront enregistrées en tant que partie du diagramme de dépendance.They will be saved as part of the dependency diagram. Pour plus d’informations, consultez naviguer et mise à jour des modèles dans le code de programme de couche.For more information, see Navigate and update layer models in program code.

Propriétés que l'utilisateur peut modifierProperties that the user can edit

Préparation initialeInitial preparation

Important

Pour faire apparaître les propriétés, vous devez apporter la modification suivante sur chaque ordinateur où vous souhaitez que les propriétés de couche soient visibles.To make properties appear, you must make the following change on each computer where you want layer properties to be visible.

  1. Lancez le bloc-notes à l’aide de exécuter en tant qu’administrateur.Run Notepad by using Run as Administrator. Ouvrez %ProgramFiles%\Microsoft Visual Studio [version]\Common7\IDE\Extensions\Microsoft\Architecture Tools\ExtensibilityRuntime\extension.vsixmanifest.Open %ProgramFiles%\Microsoft Visual Studio [version]\Common7\IDE\Extensions\Microsoft\Architecture Tools\ExtensibilityRuntime\extension.vsixmanifest

    1. Dans l'élément Content, ajoutez :Inside the Content element, add:
    <MefComponent>Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.Provider.dll</MefComponent>
    
    1. Sous le Visual Studio Tools section du Visual Studio application menu Démarrer, ouvrez invite de commandes développeur.Under the Visual Studio Tools section of the Visual Studio application start menu, open Developer Command Prompt.

    Entrez :Enter:

    devenv /rootSuffix /updateConfiguration

    devenv /rootSuffix Exp /updateConfiguration

    1. Redémarrez Visual Studio.Restart Visual Studio.

Assurez-vous que votre code se trouve dans un projet VSIXMake sure your code is in a VSIX project

Si votre propriété fait partie d’un projet de validation, de mouvement ou de commande, vous ne devez rien à ajouter.If your property is part of a command, gesture, or validation project, you don't need to add anything. Le code de votre propriété personnalisée doit être défini dans un projet d'extensibilité Visual Studio défini en tant que composant MEF.The code for your custom property should be defined in a Visual Studio Extensibility project defined as a MEF component. Pour plus d’informations, consultez ajouter des commandes et des mouvements aux diagrammes de dépendance ou ajouter la validation d’architecture personnalisée aux diagrammes de dépendance.For more information, see Add commands and gestures to dependency diagrams or Add custom architecture validation to dependency diagrams.

Définir la propriété personnaliséeDefine the custom property

Pour créer une propriété personnalisée, définissez une classe comme suit :To create a custom property, define a class like this:

[Export(typeof(IPropertyExtension))]
public class MyProperty
      : PropertyExtension<ILayerElement>
{
  // Implement the interface.
}

Vous pouvez définir des propriétés sur ILayerElement ou l'une de ses classes dérivées, notamment :You can define properties on ILayerElement or any of its derived classes, which include:

  • ILayerModel : le modèleILayerModel - the model

  • ILayer : chaque coucheILayer - each layer

  • ILayerDependencyLink : les liens entre les couchesILayerDependencyLink - the links between layers

  • ILayerComment

  • ILayerCommentLink

ExempleExample

Le code suivant est un descripteur de propriété personnalisé classique.The following code is a typical custom property descriptor. Il définit une propriété booléenne sur le modèle de couche (ILayerModel) qui permet à l'utilisateur de fournir des valeurs pour une méthode de validation personnalisée.It defines a Boolean property on the layer model (ILayerModel) that lets the user provide values for a custom validation method.

using System;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;

namespace MyNamespace
{
  /// <summary>
  /// Custom properties are added to the Layer Designer via a custom
  /// Property Descriptor. We have to export this Property Descriptor
  /// using MEF to make it available in the Layer Designer.
  /// </summary>
  [Export(typeof(IPropertyExtension))]
  public class AllTypesMustBeReferencedProperty
      : PropertyExtension<ILayerModel>
  {
    /// <summary>
    /// Each custom property must have a unique name.
    /// Usually we use the full name of this class.
    /// </summary>
    public static readonly string FullName =
      typeof(AllTypesMustBeReferencedProperty).FullName;

    /// <summary>
    /// Construct the property. Notice the use of FullName.
    /// </summary>
    public AllTypesMustBeReferencedProperty()
            : base(FullName)
    {  }

    /// <summary>
    /// The display name is shown in the Properties window.
    /// We therefore use a localizable resource.
    /// </summary>
    public override string DisplayName
    {
      get { return Strings.AllTypesMustBeReferencedDisplayName; }
    }

    /// <summary>
    /// Description shown at the bottom of the Properties window.
    /// We use a resource string for easier localization.
    /// </summary>
    public override string Description
    {
      get { return Strings.AllTypesMustBeReferencedDescription; }
    }

    /// <summary>
    /// This is called to set a new value for this property. We must
    /// throw an exception if the value is invalid.
    /// </summary>
    /// <param name="component">The target ILayerElement</param>
    /// <param name="value">The new value</param>
    public override void SetValue(object component, object value)
    {
      ValidateValue(value);
      base.SetValue(component, value);
    }
    /// <summary>
    /// Helper to validate the value.
    /// </summary>
    /// <param name="value">The value to validate</param>
    private static void ValidateValue(object value)
    {  }

    public override Type PropertyType
    { get { return typeof(bool); } }

    /// <summary>
    /// The segment label of the properties window.
    /// </summary>
    public override string Category
    {
      get
      {
        return Strings.AllTypesMustBeReferencedCategory;
      }
    }
  }
}

Voir aussiSee Also