Integración de modelos mediante Visual Studio ModelBus

  • Artículo

Visual Studio ModelBus proporciona un método para crear vínculos entre modelos y desde otras herramientas a modelos. Por ejemplo, podría vincular modelos de lenguaje específico de dominio (DSL) y modelos UML. Puede crear un conjunto integrado de DSL.

Advertencia

La extensión Visual Studio ModelBus, descrita en este artículo, ya no está disponible para su descarga. Pero estas instrucciones siguen funcionando para los usuarios que ya tienen instalada esta extensión.

ModelBus permite crear una referencia única a un modelo o a un elemento específico dentro de un modelo. Esta referencia se puede almacenar fuera del modelo, por ejemplo, en un elemento en otro modelo. Más adelante, cuando una herramienta quiera obtener acceso al elemento, la infraestructura de ModelBus carga el modelo apropiado y devuelve el elemento. Si quiere, puede mostrar el modelo al usuario. Si no se puede acceder al archivo en su ubicación anterior, ModelBus pide al usuario que lo busque. Si el usuario encuentra el archivo, ModelBus actualiza todas las referencias a ese archivo.

Nota

En la implementación actual de ModelBus para Visual Studio, los modelos vinculados deben ser elementos de la misma solución de Visual Studio.

Para más información sobre la extensión ModelBus, vea los siguientes recursos:

Nota

El componente Transformación de plantilla de texto se instala de forma automática como parte de la carga de trabajo Desarrollo de extensiones de Visual Studio. También lo puede instalar desde la pestaña Componentes individuales del Instalador de Visual Studio, en la categoría SDK, bibliotecas y marcos. Instale el componente SDK de modelado desde la pestaña Componentes individuales.

Facilitación de acceso a un DSL

Antes de crear referencias de ModelBus a un modelo o a sus elementos, defina un elemento ModelBusAdapter para el DSL. La manera más fácil de hacerlo consiste en usar la extensión Visual Studio ModelBus, que agrega comandos al Diseñador DSL.

Para exponer una definición de DSL a ModelBus

  1. Abra el archivo de definición de DSL. Haga clic con el botón derecho en la superficie de diseño y, después, seleccione Enable ModelBus (Habilitar ModelBus).

  2. En el cuadro de diálogo, elija I want to expose this DSL to the ModelBus (Quiero exponer este DSL a ModelBus). Puede elegir ambas opciones si quiere que este DSL exponga sus modelos y use referencias a otros DSL.

  3. Seleccione Aceptar. Se agrega un nuevo proyecto ModelBusAdapter a la solución de DSL.

  4. Si quiere acceder al DSL desde una plantilla de texto, debe modificar AdapterManager.tt en el nuevo proyecto. Omita este paso si quiere acceder al DSL desde otro código, como comandos y controladores de eventos. Para más información, vea Uso de Visual Studio ModelBus en una plantilla de texto.

    1. Cambie la clase base de AdapterManagerBase a VsTextTemplatingModelingAdapterManager.

    2. Cerca del final del archivo, inserte este atributo delate de la clase AdapterManager:

      [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]

    3. En el Administrador de paquetes NuGet del proyecto ModelBusAdapter, agregue un elemento packageReference de NuGet a Microsoft.VisualStudio.TextTemplating.Modeling.

      Si quiere acceder al DSL desde las plantillas de texto y desde otro código, necesita dos adaptadores, uno modificado y otro sin modificar.

  5. Seleccione Transformar todas las plantillas.

  6. Recompilar la solución.

    Ahora ModelBus puede abrir instancias de este DSL.

    La carpeta ModelBusAdapters\bin* contiene los ensamblados compilados por el proyecto Dsl y el proyecto ModelBusAdapters. Para hacer referencia a este DSL desde otro, importe estos ensamblados.

Garantía de que se puede hacer referencia a los elementos

De manera predeterminada, los adaptadores de Visual Studio ModelBus usan el GUID de un elemento para identificarlo. Estos identificadores se deben conservar en el archivo del modelo.

Para asegurarse de que los identificadores de elemento se conservan:

  1. Abra DslDefinition.dsl.

  2. En Explorador de DSL, expanda Comportamiento de serialización XML y, después, Datos de clase.

  3. Para cada clase para la que quiera crear referencias de ModelBus:

    Seleccione el nodo de clase y, en la ventana Propiedades, asegúrese de que el valor Serialize ID (Serializar id.) está establecido en true.

Como alternativa, si en lugar de GUID quiere usar nombres de elemento para identificar los elementos, puede reemplazar las partes de los adaptadores generados. Invalide los siguientes métodos en la clase de adaptador:

  • Invalide GetElementId para devolver el identificador que quiere usar. Se llama a este método cuando se crean referencias.
  • Reemplace ResolveElementReference para buscar el elemento correcto en una referencia de ModelBus.

Acceso a un DSL desde otro DSL

Puede almacenar referencias de ModelBus en una propiedad de dominio de un DSL y escribir código personalizado para usarlas. También puede permitir que el usuario cree una referencia de ModelBus mediante la selección de un archivo de modelo y un elemento dentro de él.

Para que un DSL pueda usar referencias a otro DSL, primero debe convertirlo en consumidor de referencias de ModelBus.

Para que un DSL pueda consumir referencias a un DSL expuesto

  1. En el diagrama DSL Definition (Definición de DSL), haga clic con el botón derecho en la parte principal del diagrama y, después, seleccione Enable ModelBus (Habilitar ModelBus).

  2. En el cuadro de diálogo, seleccione I want to enable this model to consume model bus references (Quiero que este modelo consuma referencias de ModelBus).

  3. En el proyecto Dsl del DSL de consumo, agregue los ensamblados siguientes a las referencias del proyecto. Estos ensamblados (archivos .dll) están en el directorio ModelBusAdapter\bin\* del DSL expuesto.

    • El ensamblado de DSL expuesto, por ejemplo, Fabrikam.FamilyTree.Dsl.dll

    • El ensamblado del adaptador de ModelBus expuesto, por ejemplo, Fabrikam.FamilyTree.ModelBusAdapter.dll

  4. Agregue los siguientes ensamblados .NET a las referencias del proyecto de DSL de consumo.

    • Microsoft.VisualStudio.Modeling.Sdk.Integration.dll
    • Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.dll

Para almacenar una referencia de ModelBus en una propiedad de dominio

  1. En DSL Definition (Definición de DSL) del DSL de consumo, agregue una propiedad de dominio a una clase de dominio y establezca su nombre.

  2. En la ventana Propiedades, con la propiedad de dominio seleccionada, establezca Tipo en ModelBusReference.

    En esta fase, el código de programa puede establecer el valor de la propiedad. El valor es de solo lectura en la ventana Propiedades.

    Puede permitir que los usuarios establezcan la propiedad con un editor de referencias de ModelBus especializado. Hay dos versiones de este editor o selector. Uno permite a los usuarios elegir un archivo de modelo y, el otro, un archivo de modelo y un elemento dentro del modelo.

Para que el usuario pueda establecer una referencia de ModelBus en una propiedad de dominio

  1. Haga clic con el botón derecho en la propiedad de dominio y, después, seleccione Edit ModelBusReference specific properties (Editar las propiedades específicas de ModelBusReference). Se abre el cuadro de diálogo Selector de ModelBus.

  2. Establezca el tipo de ModelBusReference adecuado en un modelo o en un elemento dentro de un modelo.

  3. En la cadena de filtro del cuadro de diálogo de archivos, especifique una cadena como Family Tree files |*.ftree. Sustituya la extensión de archivo del DSL expuesto.

  4. Si ha elegido hacer referencia a un elemento en un modelo, puede agregar una lista de tipos que el usuario puede seleccionar, por ejemplo, Company.FamilyTree.Person.

  5. Seleccione Aceptar y después Transformar todas las plantillas en la barra de herramientas del Explorador de soluciones.

    Advertencia

    Si no ha seleccionado un modelo o entidad válidos, el botón Aceptar no tendrá efecto aunque aparezca habilitado.

  6. Si ha especificado una lista de tipos de destino, como Company.FamilyTree.Person, debe agregar una referencia de ensamblado al proyecto de DSL, y hacer referencia al archivo DLL del DSL de destino, por ejemplo, Company.FamilyTree.Dsl.dll.

Para probar una instancia de ModelBusReference

  1. Compile los DSL expuestos y de consumo.

  2. Presione F5 o CTRL+F5 para ejecutar uno de los DSL en modo experimental.

  3. En el proyecto de depuración, en la instancia experimental de Visual Studio, agregue archivos que sean instancias de cada DSL.

    Nota

    Visual Studio ModelBus solo puede resolver referencias a modelos que son elementos de la misma solución de Visual Studio. Por ejemplo, no puede crear una referencia a un archivo de modelo que esté en otra parte del sistema de archivos.

  4. Cree algunos elementos y vínculos en la instancia del DSL expuesto, y guárdelo.

  5. Abra una instancia del DSL de consumo y seleccione un elemento de modelo que tenga una propiedad de referencia de ModelBus.

  6. En la ventana Propiedades, haga doble clic en la propiedad de la referencia de ModelBus. Se abre el cuadro de diálogo del selector.

  7. Seleccione Examinar y seleccione la instancia del DSL expuesto.

    Si ha especificado la referencia de ModelBus específica del elemento, el selector también le permite elegir un elemento del modelo.

Creación de referencias en el código de programa

Si quiere almacenar una referencia a un modelo o a un elemento dentro de un modelo, cree una instancia de ModelBusReference. Hay dos tipos de ModelBusReference: referencias de modelo y referencias de elementos.

Para crear una referencia de modelo, necesita el elemento AdapterManager del DSL donde el modelo es una instancia, y el nombre de archivo o elemento de proyecto de Visual Studio del modelo.

Para crear una referencia de elemento, necesita un adaptador para el archivo de modelo, y el elemento al que quiere hacer referencia.

Nota

Con Visual Studio ModelBus, solo puede crear referencias a elementos de la misma solución de Visual Studio.

Importar los ensamblados de DSL expuestos

En el proyecto de consumo, agregue referencias de proyecto al DSL y a los ensamblados ModelBusAdapter del DSL expuesto.

Por ejemplo, imagine que quiere almacenar referencias de ModelBus en elementos de un DSL MusicLibrary. Las referencias de ModelBus hacen referencia a elementos del DSL FamilyTree. En el proyecto Dsl de la solución MusicLibrary, en el nodo Referencias, agregue referencias a los ensamblados siguientes:

  • Fabrikam.FamilyTree.Dsl.dll. El DSL expuesto.

  • Fabrikam.FamilyTree.ModelBusAdapters.dll El adaptador de ModelBus del DSL expuesto.

  • Microsoft.VisualStudio.Modeling.Sdk.Integration

  • Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell

    Estos ensamblados se encuentran en el proyecto ModelBusAdapters del DSL expuesto, en *bin\**.

    En el archivo de código donde crea las referencias, normalmente tiene que importar estos espacios de nombres:

// The namespace of the DSL you want to reference:
using Fabrikam.FamilyTree;  // Exposed DSL
using Fabrikam.FamilyTree.ModelBusAdapters;
using Microsoft.VisualStudio.Modeling.Integration;
using System.Linq;
...

Para crear una referencia a un modelo

Para crear una referencia de modelo, acceda al AdapterManager del DSL expuesto y úselo para crear una referencia al modelo. Puede especificar una ruta de acceso al archivo o un EnvDTE.ProjectItem.

Desde el AdapterManager, puede obtener un Adapter, que proporciona acceso a los elementos individuales del modelo.

Nota

Cuando haya terminado con un Adapter, deséchelo. La manera más conveniente de hacerlo es con una instrucción using. Esto se ilustra en el siguiente ejemplo:

// The file path of a model instance of the FamilyTree DSL:
string targetModelFile = "TudorFamilyTree.ftree";
// Get the ModelBus service:
IModelBus modelBus =
    this.Store.GetService(typeof(SModelBus)) as IModelBus;
// Get an adapterManager for the target DSL:
FamilyTreeAdapterManager manager =
    (modelbus.GetAdapterManager(FamilyTreeAdapter.AdapterId)
     as FamilyTreeAdapterManager;
// or: (modelBus.FindAdapterManagers(targetModelFile).First())
// or could provide an EnvDTE.ProjectItem

// Create a reference to the target model:
// NOTE: the target model must be a file in this project.
ModelBusReference modelReference =
     manager.CreateReference(targetModelFile);
// or can use an EnvDTE.ProjectItem instead of the filename

// Get the root element of this model:
using (FamilyTreeAdapter adapter =
     modelBus.CreateAdapter(modelReference) as FamilyTreeAdapter)
{
  FamilyTree modelRoot = adapter.ModelRoot;
  // Access elements under the root in the usual way:
  foreach (Person p in modelRoot.Persons) {...}
  // You can create adapters for individual elements:
  ModelBusReference elementReference =
     adapter.GetElementReference(person);
  ...
} // Dispose adapter

Si quiere poder usar modelReference más adelante, puede almacenarla en una propiedad de dominio que tenga el tipo externo ModelBusReference:

using Transaction t = this.Store.TransactionManager
    .BeginTransaction("keep reference"))
{
  artist.FamilyTreeReference = modelReference;
  t.Commit();
}

Para que los usuarios puedan editar esta propiedad de dominio, use ModelReferenceEditor como parámetro en el atributo Editor. Para más información, vea Permiso para que el usuario edite una referencia.

Para crear una referencia a un elemento

El adaptador que creó para el modelo se puede usar para crear y resolver referencias.

// person is an element in the FamilyTree model:
ModelBusReference personReference =
  adapter.GetElementReference(person);

Si quiere poder usar elementReference más adelante, puede almacenarla en una propiedad de dominio que tenga el tipo externo ModelBusReference. Para que los usuarios puedan editarla, use ModelElementReferenceEditor como parámetro en el atributo Editor. Para más información, vea Permiso para que el usuario edite una referencia.

Resolver referencias

Si tiene una ModelBusReference (MBR), puede obtener el modelo o el elemento de modelo al que hace referencia. Si el elemento está presente en un diagrama o en otra vista, puede abrir la vista y seleccionar el elemento.

Puede crear un adaptador desde una MBR. En el adaptador, puede obtener la raíz del modelo. También puede resolver las MBR que hacen referencia a elementos específicos dentro del modelo.

using Microsoft.VisualStudio.Modeling.Integration; ...
ModelBusReference elementReference = ...;

// Get the ModelBus service:
IModelBus modelBus =
    this.Store.GetService(typeof(SModelBus)) as IModelBus;
// Use a model reference or an element reference
// to obtain an adapter for the target model:
using (FamilyTreeAdapter adapter =
   modelBus.CreateAdapter(elementReference) as FamilyTreeAdapter)
   // or CreateAdapter(modelReference)
{
  // Get the root of the model:
  FamilyTree tree = adapter.ModelRoot;

  // Get a model element:
  MyDomainClass mel =
    adapter.ResolveElementReference<MyDomainClass>(elementReference);
  if (mel != null) {...}

  // Get the diagram or other view, if there is one:
  ModelBusView view = adapter.GetDefaultView();
  if (view != null)
  {
   view.Open();
   // Display the diagram:
   view.Show();
   // Attempt to select the shape that presents the element:
   view.SetSelection(elementReference);
  }
} // Dispose the adapter.

Para resolver las referencias de ModelBus en una plantilla de texto

El DSL al que quiere acceder debe tener un adaptador de ModelBus que se haya configurado para que las plantillas de texto puedan acceder. Para más información, vea Facilitación del acceso a un DSL.

Normalmente, se accede a un DSL de destino mediante una referencia de ModelBus (MBR) almacenada en un DSL de origen. Por lo tanto, la plantilla incluye la directiva del DSL de origen, además del código para resolver la MBR. Para más información sobre las plantillas de texto, vea Generación de código a partir de un lenguaje específico de dominio.

<#@ template debug="true" hostspecific="true"
inherits="Microsoft.VisualStudio.TextTemplating.Modeling.ModelBusEnabledTextTransformation" #>
<#@ SourceDsl processor="SourceDslDirectiveProcessor" requires="fileName='Sample.source'" #>
<#@ output extension=".txt" #>
<#@ assembly name = "Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0" #>
<#@ assembly name = "System.Core" #>
<#@ assembly name = "Company.CompartmentDragDrop.Dsl.dll" #>
<#@ assembly name = "Company.CompartmentDragDrop.ModelBusAdapter.dll" #>
<#@ import namespace="Microsoft.VisualStudio.Modeling.Integration" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="Company.CompartmentDragDrop" #>
<#@ import namespace="Company.CompartmentDragDrop.ModelBusAdapters" #>
<# // Get source root from directive processor:
  ExampleModel source = this.ExampleModel;
  // This DSL has an MBR in its root:
using (ModelBusAdapter adapter = this.ModelBus.CreateAdapter(source.ModelReference) as ModelBusAdapter)
  {
  ModelBusAdapterManager manager = this.ModelBus.FindAdapterManagers(this.Host.ResolvePath("Sample.compDD1")).FirstOrDefault();
  ModelBusReference modelReference =
    manager.CreateReference(this.Host.ResolvePath("Sample.compDD1"));

  // Get the root element of this model:
  using (CompartmentDragDropAdapter adapter =
     this.ModelBus.CreateAdapter(modelReference) as CompartmentDragDropAdapter)
  {
    ModelRoot root = adapter.ModelRoot;
#>
[[<#= root.Name #>]]
<#
  }
#>

Para más información y obtener un tutorial, vea Uso de Visual Studio ModelBus en una plantilla de texto

Serialización de una instancia de ModelBusReference

Si quiere almacenar una ModelBusReference (MBR) en forma de cadena, puede serializarla:

string serialized = modelBus.SerializeReference(elementReference);
// Store it anywhere, then get it back again:
ModelBusReference elementReferenceRestored =
    modelBus.DeserializeReference(serialized, null);

Una MBR que se serializa de esta manera es independiente del contexto. Si usa el adaptador de ModelBus simple basado en archivos, la MBR contiene una ruta de acceso absoluta al archivo. Si los archivos de modelo de instancia nunca se mueven, esta serialización es suficiente. Pero los archivos de modelo suelen ser elementos de un proyecto de Visual Studio. Los usuarios esperan poder mover todo el proyecto a diferentes partes del sistema de archivos. También esperan poder mantener el proyecto bajo el control del código fuente y abrirlo en diferentes equipos. Los nombres de las rutas de acceso deben serializarse con relación a la ubicación del proyecto que contiene los archivos.

Serialización con relación a una ruta de acceso de archivo especificada

Una ModelBusReference contiene un ReferenceContext, que es un diccionario en el que se puede almacenar información, como la ruta de acceso al archivo respecto a la cual debe serializarse.

Para serializar con relación a una ruta de acceso:

elementReference.ReferenceContext.Add(
   ModelBusReferencePropertySerializer.FilePathSaveContextKey,
   currentProjectFilePath);
string serialized = modelBus.SerializeReference(elementReference);

Para recuperar la referencia de la cadena:

ReferenceContext context = new ReferenceContext();
context.Add(ModelBusReferencePropertySerializer.FilePathLoadContextKey,
    currentProjectFilePath);
ModelBusReference elementReferenceRestored =
    modelBus.DeserializeReference(serialized, context);

Referencias de ModelBus creadas por otros adaptadores

La siguiente información resulta útil si quiere crear su propio adaptador.

Una ModelBusReference (MBR) consta de dos partes: el encabezado de la MBR, que el bus del modelo deserializa, y una parte específica del adaptador, que la controla el administrador del adaptador específico. Este enfoque permite proporcionar un formato propio de serialización de adaptadores. Por ejemplo, podría hacer referencia a una base de datos en lugar de a un archivo, o podría almacenar información adicional en la referencia del adaptador. Su propio adaptador puede colocar información adicional en el ReferenceContext.

Cuando se deserializa una MBR, se debe proporcionar un ReferenceContext, que se almacena en el objeto de MBR. Cuando se serializa una MBR, el adaptador usa el ReferenceContext almacenado para ayudar a generar la cadena. La cadena deserializada no contiene toda la información de ReferenceContext. Por ejemplo, en el adaptador simple basado en archivos, ReferenceContext contiene una ruta de acceso al archivo raíz. La ruta de acceso no se almacena en la cadena MBR serializada.

La MBR se deserializa en dos etapas:

  • ModelBusReferencePropertySerializer es el serializador estándar que controla el encabezado de la MBR. Usa el contenedor de propiedades SerializationContext estándar de DSL, que se almacena en el ReferenceContext usando la clave ModelBusReferencePropertySerializer.ModelBusLoadContextKey. En concreto, SerializationContext debería contener una instancia de ModelBus.

  • Su adaptador de ModelBus trata con la parte de la MBR específica del adaptador. Puede usar la información adicional almacenada en el ReferenceContext de la MBR. El adaptador simple basado en archivos guarda las rutas de acceso al archivo raíz mediante las claves FilePathLoadContextKey y FilePathSaveContextKey.

    En un archivo de modelo, la referencia de adaptador solo se deserializa cuando se usa.

Creación de un modelo

Creación, apertura y edición de un modelo

El siguiente fragmento se ha tomado de la muestra State Machine, en el sitio web de VMSDK. Muestra cómo usar referencias de ModelBus para crear y abrir un modelo, y para obtener el diagrama asociado al modelo.

En esta muestra, el nombre del DSL de destino es StateMachine. De él derivan varios nombres, como el nombre de la clase de modelo y el nombre del ModelBusAdapter.

using Fabrikam.StateMachine.ModelBusAdapters;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Integration;
using Microsoft.VisualStudio.Modeling.Integration.Shell;
using Microsoft.VisualStudio.Modeling.Shell;
...
// Create a new model.
ModelBusReference modelReference =
   StateMachineAdapterManager    .CreateStateMachineModel(modelName, fileName);
//Keep reference of new model in this model.
using (Transaction t = ...)
{
  myModelElement.ReferenceProperty = modelReference;
  t.Commit();
}
// Get the ModelBus service from Visual Studio.
IModelBus modelBus = Microsoft.VisualStudio.Shell.Package.
    GetGlobalService(typeof(SModelBus)) as IModelBus;
// Get a modelbus adapter on the new model.
ModelBusAdapter modelBusAdapter;
modelBus.TryCreateAdapter(modelReference,
    this.ServiceProvider, out modelBusAdapter);
using (StateMachineAdapter adapter =
      modelBusAdapter as StateMachineAdapter)
{
    if (adapter != null)
    {
        // Obtain a Diagram from the adapter.
        Diagram targetDiagram =
           ((StandardVsModelingDiagramView)
                 adapter.GetDefaultView()
            ).Diagram;

        using (Transaction t =
             targetDiagram.Store.TransactionManager
                .BeginTransaction("Update diagram"))
        {
            DoUpdates(targetDiagram);
            t.Commit();
        }

        // Display the new diagram.
        adapter.GetDefaultView().Show();
    }
}

Validación de referencias

BrokenReferenceDetector prueba todas las propiedades de dominio en un almacén que pueda almacenar referencias de ModelBus. Solicita que se lleve a cabo la acción cuando se encuentra una. Esta prueba es útil para los métodos de validación. El siguiente método de validación prueba el almacén en un intento de guardar el modelo, y notifica las referencias que no funcionan en la ventana de errores:

[ValidationMethod(ValidationCategories.Save)]
public void ValidateModelBusReferences(ValidationContext context)
{
  BrokenReferenceDetector.DetectBrokenReferences(this.Store,
    delegate(ModelElement element, // parent of property
             DomainPropertyInfo property, // identifies property
             ModelBusReference reference) // invalid reference
    {
      context.LogError(string.Format(INVALID_REF_FORMAT,
             property.Name,
             referenceState.Name,
             new ModelBusReferenceTypeConverter().
                 ConvertToInvariantString(reference)),
         "Reference",
         element);
    });
}
private const string INVALID_REF_FORMAT =
    "The '{0}' domain property of this ReferenceState instance "
  + "named '{1}' contains reference value '{2}' which is invalid";

Acciones realizadas por la extensión ModelBus

La información siguiente podría resultar útil si hace un uso intensivo de ModelBus.

La extensión ModelBus realiza los siguientes cambios en su solución de DSL.

Al hacer clic con el botón derecho en el diagrama de definición de DSL, seleccione Enable Modelbus (Habilitar ModelBus) y después Enable this DSL to Consume the ModelBus (Permitir que este DSL use ModelBus):

  • En el proyecto DSL, se debe agregar una referencia a Microsoft.VisualStudio.Modeling.Sdk.Integration.dll.

  • En la definición de DSL, se agrega una referencia de tipo externo: Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

    Puede ver la referencia en Explorador de DSL, en Tipos de dominio. Para agregar referencias de tipo externo manualmente, haga clic con el botón secundario en el nodo raíz.

  • Se agrega un nuevo archivo de plantilla, Dsl\GeneratedCode\ModelBusReferencesSerialization.tt.

Al establecer el tipo de una propiedad de dominio en ModelBusReference y, después, hacer clic con el botón derecho en la propiedad y seleccionar Enable ModelBusReference specific properties (Habilitar las propiedades específicas de ModelBusReference):

  • Se agregan varios atributos CLR a la propiedad de dominio. Puede verlos en el campo Atributos personalizados en la ventana Propiedades. En Dsl\GeneratedCode\DomainClasses.cs, puede ver los atributos en la declaración de la propiedad:

    [System.ComponentModel.TypeConverter(typeof(
Microsoft.VisualStudio.Modeling.Integration.ModelBusReferenceTypeConverter))]
[System.ComponentModel.Editor(typeof(
  Microsoft.VisualStudio.Modeling.Integration.Picker
  .ModelReferenceEditor // or ModelElementReferenceEditor
  ), typeof(System.Drawing.Design.UITypeEditor))]
[Microsoft.VisualStudio.Modeling.Integration.Picker
  .SupplyFileBasedBrowserConfiguration
  ("Choose a model file", "Target model|*.target")]

Al hacer clic con el botón derecho en el diagrama de definición de DSL, seleccione Enable ModelBus (Habilitar ModelBus) y después Expose this DSL to the ModelBus (Exponer este DSL a ModelBus):

  • Se agrega un proyecto ModelBusAdapter a la solución.

  • Se agrega una referencia a ModelBusAdapter al proyecto DslPackage. ModelBusAdapter tiene una referencia al proyecto Dsl.

  • En DslPackage\source.extention.tt, |ModelBusAdapter| se agrega como un componente de MEF.

Contenido relacionado