Agregar propiedades personalizadas a diagramas de dependenciaAdd custom properties to dependency diagrams

Cuando se escribe código de extensión para los diagramas de dependencia, puede almacenar valores a cualquier elemento en un diagrama de dependencia.When you write extension code for dependency diagrams, you can store values with any element on a dependency diagram. Los valores se conservarán cuando el diagrama se guarde y se vuelva a abrir.The values will persist when the diagram is saved and re-opened. También puede hacer que estas propiedades aparecen en la propiedades ventana para que los usuarios pueden verlas y editarlas.You can also have these properties appear in the Properties window so that users can see and edit them. Por ejemplo, puede permitir que los usuarios especifiquen una expresión regular para cada capa y escriban código de validación para comprobar que los nombres de las clases de cada capa se ajustan al patrón especificado por el usuario.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.

Propiedades no visiblesNon-visible properties

Si desea que el código asocie valores a cualquier elemento de un diagrama de dependencia, no es necesario definir un componente 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. Hay un diccionario denominado Properties en ILayerElement.There is a dictionary named Properties in ILayerElement. Solo tiene que agregar valores que calculan referencias al diccionario de cualquier elemento de capa.Simply add marshalable values to the dictionary of any layer element. Se guardará como parte del diagrama de dependencia.They will be saved as part of the dependency diagram. Para obtener más información, consulte navegar y actualizar modelos en el código de programa de capas.For more information, see Navigate and update layer models in program code.

Propiedades editablesEditable properties

Preparación inicialInitial preparation

Importante

Para que las propiedades aparezcan, realice el siguiente cambio en cada equipo donde desea que esté visible de propiedades de capa:To make properties appear, make the following change on each computer where you want layer properties to be visible:

  1. Ejecutar el Bloc de notas mediante ejecutar como administrador.Run Notepad by using Run as Administrator. Abra %ProgramFiles%\Microsoft Visual Studio [versión] \Common7\IDE\Extensions\Microsoft\Architecture Tools\ExtensibilityRuntime\extension.vsixmanifest.Open %ProgramFiles%\Microsoft Visual Studio [version]\Common7\IDE\Extensions\Microsoft\Architecture Tools\ExtensibilityRuntime\extension.vsixmanifest.
  2. Dentro de la contenido elemento, agregar:Inside the Content element, add:

    <MefComponent>Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.Provider.dll</MefComponent>
    
  3. En el Visual Studio Tools sección del menú de inicio de aplicación de Visual Studio, abra símbolo.Under the Visual Studio Tools section of the Visual Studio application start menu, open Developer Command Prompt. Especifique:Enter:

    devenv /rootSuffix /updateConfiguration

    devenv /rootSuffix Exp /updateConfiguration

  4. Reinicie Visual Studio.Restart Visual Studio.

Asegúrese de que el código está en un proyecto VSIXMake sure your code is in a VSIX project

Si la propiedad forma parte de un proyecto de validación, gesto o comando, no es necesario agregar nada.If your property is part of a command, gesture, or validation project, you don't need to add anything. El código de la propiedad personalizada debe definirse en un proyecto de extensibilidad de Visual Studio definido como componente MEF.The code for your custom property should be defined in a Visual Studio Extensibility project defined as a MEF component. Para obtener más información, consulte agregar comandos y gestos a diagramas de dependencia o agregar validación de arquitectura personalizada a diagramas de dependencia.For more information, see Add commands and gestures to dependency diagrams or Add custom architecture validation to dependency diagrams.

Definir la propiedad personalizadaDefine the custom property

Para crear una propiedad personalizada, defina una clase como esta:To create a custom property, define a class like this:

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

Puede definir propiedades en ILayerElement o cualquiera de sus clases derivadas, entre las que se incluyen:You can define properties on ILayerElement or any of its derived classes, which include:

  • ILayerModel: el modeloILayerModel - the model

  • ILayer: cada capaILayer - each layer

  • ILayerDependencyLink: los vínculos entre las capasILayerDependencyLink - the links between layers

  • ILayerComment

  • ILayerCommentLink

EjemploExample

El siguiente código es un descriptor de propiedad personalizado típico.The following code is a typical custom property descriptor. Define una propiedad booleana en el modelo de capas (ILayerModel) que permite al usuario proporcionar valores para un método de validación personalizado.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;
      }
    }
  }
}

Vea tambiénSee also