Integrar modelos utilizando Modelbus de Visual Studio

Artículo
02/19/2013

Visual Studio ModelBus proporciona un método para crear vínculos entre los modelos y otras herramientas de modelos.Por ejemplo, puede vincular modelos específicos (DSL) del lenguaje y los modelos UML.Puede crear un conjunto integrado del dominio (ADSL).

ModelBus permite crear una referencia única a un modelo o a un elemento específico dentro de un modelo.Esta referencia puede estar fuera de almacenar el modelo, por ejemplo, en un elemento de otro modelo.Cuando, en una ocasión posterior, una herramienta desea obtener acceso al elemento, la infraestructura modelo de bus cargará el modelo adecuado y devolverá el elemento.Si lo desea, puede mostrar el modelo al usuario.Si el archivo no se puede tener acceso en su ubicación anterior, ModelBus pedirá al usuario la encuentra.Si el usuario encuentre el archivo, ModelBus a todas las referencias a dicho archivo.

[!NOTA]

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

Para obtener información adicional y el código de ejemplo, vea:

Proporcionar acceso a ADSL

Antes de poder crear referencias de ModelBus a un modelo o sus elementos, debe definir un ModelBusAdapter para ADSL.La manera más fácil de hacerlo es utilizar la extensión de megabus del modelo de Visual Studio , que agrega comandos a ADSL Designer.

Para exponer una definición ADSL para modelar el bus

Descargar e instalar la extensión de megabus del modelo de Visual Studio, a menos que se haya instalado.Para obtener más información, vea El SDK de visualización y modelado.
Abra el archivo de definición de ADSL.Haga clic con el botón secundario en la superficie de diseño y haga clic en permiso Modelbus.
en el cuadro de diálogo, elija Deseo exponer este ADSL a ModelBus.Puede elegir ambas opciones si desea este ADSL para exponer los modelos y utilizar referencias al otro dominio (ADSL).
Haga clic en Aceptar.Un nuevo proyecto “ModelBusAdapter” se agrega a la solución ADSL.
Si desea tener acceso a ADSL de una plantilla de texto, debe modificar AdapterManager.tt en el nuevo proyecto.Omita este paso si desea tener acceso a ADSL de otro código como comandos y controladores de eventos.Para obtener más información, vea Usar ModelBus de Visual Studio en plantillas de texto.
1. cambie la clase base de AdapterManagerBase a VsTextTemplatingModelingAdapterManager.
2. Cerca del final del archivo, inserte este atributo adicional delante de la clase AdapterManager:
  
  [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
3. En las referencias del proyecto de ModelBusAdapter, agregue Microsoft.VisualStudio.TextTemplating.Modeling.11.0.
Si desea tener acceso a ADSL de plantillas de texto y de otro código, necesita dos adaptadores, uno modificado y otra sin modificar.
Haga clic en Transformar todas las plantillas.
Recompilar la solución.

Ahora es posible que ModelBus abra las instancias del ADSL.

La carpeta ModelBusAdapters\bin\* contiene ensamblados compilados por el proyecto de Dsl y el proyecto de ModelBusAdapters .Para hacer referencia a este ADSL de otro DSL, debe importar estos ensamblados.

Asegúrese de que los elementos pueden hacer referencia

los adaptadores deVisual Studio ModelBus utilizan el guid de un elemento para identificarlo, de forma predeterminada.Estos identificadores deben por consiguiente conservar en el archivo del modelo.

Para asegurarse de que se conserva los id. de elemento

DslDefinition.dsl abierto.
En el Explorador ADSL, expanda Comportamiento de serialización XML, entonces Datos de clase.
Para cada clase en la que se desea crear model bus hace referencia:

Haga clic en el nodo de clase y, en la ventana Propiedades, asegúrese de que serialice el id. está establecido en true.

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

Reemplazo GetElementId para devolver el identificador que desea utilizar.Se llama a este método para crear referencias.
Reemplace ResolveElementReference para buscar el elemento correcto de una referencia del modelo de bus.

Acceso ADSL de otro ADSL

Puede almacenar referencias pertenecen al bus en una propiedad de dominio en DSL, y puede escribir código personalizado que las utiliza.También puede permitir que el usuario crear una referencia del modelo de bus escogiendo un archivo modelo y un elemento dentro del.

Para permitir a ADSL para utilizar referencias a otro DSL, primero debe ser un consumidor de las referencias del modelo de bus.

Para permitir a ADSL para utilizar referencias a ADSL expuesto

En el diagrama de la definición de DSL, haga clic con el botón secundario en la parte principal del diagrama y haga clic en habilite Modelbus.
En el cuadro de diálogo, seleccione Deseo permitir que este modelo para utilizar referencias pertenecen al bus.
En el proyecto de ADSL ADSL utilizado, agregue los ensamblados siguientes a las referencias del proyecto.Encontrará estos ensamblados (archivos .dll) en el ModelBusAdapter \bin\* directory of the exposed DSL.
- El ensamblado expuesto ADSL, por ejemplo Fabrikam.FamilyTree.Dsl.dll
- El ensamblado modelo expuesto desde el adaptador de bus, por ejemplo Fabrikam.FamilyTree.ModelBusAdapter.dll
Agregue los siguientes ensamblados.NET a las referencias del proyecto ADSL utilizado.
1. Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll
2. Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0.dll

Para almacenar una referencia del modelo de bus en una propiedad de dominio

En la definición de ADSL ADSL utilizado, agregue una propiedad de dominio a una clase de dominio y establezca su nombre.
En la ventana Propiedades, con el dominio seleccionado, establezca tipo a ModelBusReference.

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

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

Para permitir que el usuario establezca una referencia del modelo de bus en una propiedad de dominio

Haga clic con el botón secundario en la propiedad del dominio y haga clic en Propiedades específicas de ModelBusReference de edición.Se abre el cuadro de diálogo.Éste es model bus Picker.
Seleccione clase de ModelBusReferenceadecuado: un modelo o a un elemento dentro de un modelo.
En cadena de filtro del cuadro de diálogo, escriba una cadena como Family Tree files |*.ftree.Subsitute la extensión de archivo ADSL expuesto.
Si decide hacer referencia a un elemento de un modelo, puede agregar una lista de tipos que el usuario puede seleccionar, por ejemplo Company.FamilyTree.Person.
Haga clic en Aceptar, y haga clic en Transformar todas las plantillas en la barra de herramientas del explorador de soluciones.

Precaución

Si no seleccionado un modelo o una entidad válido, el botón ACEPTAR no tendrá ningún efecto, aunque puede aparecer habilitado.
Si especificó una lista de tipos de destino como Company.FamilyTree.Person, debe agregar una referencia de ensamblado al proyecto ADSL, haciendo referencia a la DLL de destino DSL, por ejemplo Company.FamilyTree.Dsl.dll

Precaución
Si no seleccionado un modelo o una entidad válido, el botón ACEPTAR no tendrá ningún efecto, aunque puede aparecer habilitado.

Para probar una referencia del modelo de bus

Compile el dominio (ADSL) expuesto y utilizado.
Ejecute uno del dominio (ADSL) en modo experimental presionando F5 o CTRL+F5.
En el proyecto de depuración en la instancia experimental de Visual Studio, agregue los archivos que son instancias de cada ADSL.

[!NOTA]

Visual Studio ModelBus puede resolver solo referencias a los modelos que son elementos en la misma solución de Visual Studio .Por ejemplo, no puede crear una referencia a un archivo modelo en otra parte del sistema de archivos.
Establezca algunos elementos y relaciones en la instancia ADSL expuesto, y guárdelo.
Abre una instancia ADSL utilizado, y seleccione un elemento de modelo que tiene una propiedad de referencia del modelo de bus.
En la ventana Propiedades, haga doble clic en la propiedad de referencia del modelo de bus.El diálogo del selector se abre.
Haga clic en Examinar y seleccione la instancia ADSL expuesto.

El selector también permiten elegir un elemento del modelo, si especificó la clase elemento-específica de referencia del modelo de bus.

crear referencias en código de programa

Si se desea almacenar una referencia a un modelo o un elemento dentro de un modelo, se crea ModelBusReference.Hay dos tipos de ModelBusReference: referencias de modelo y referencias de elemento.

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

Para crear una referencia del elemento, necesita un adaptador para el archivo del modelo, y el elemento que desea consultar.

[!NOTA]

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

Importe los ensamblados expuestos ADSL

En el proyecto utilizado, agregue referencias a los ensamblados de ADSL y de ModelBusAdapter ADSL expuesto.

Por ejemplo, suponga que desea almacenar las referencias de ModelBus en elementos de un MusicLibrary ADSL.Las referencias de ModelBus referirán a los elementos de FamilyTree ADSL.En el proyecto de Dsl de solución de MusicLibrary, en el nodo references, agregue referencias a los ensamblados siguientes:

Fabrikam.FamilyTree.Dsl.dll - ADSL expuesto.
Fabrikam.FamilyTree.ModelBusAdapters.dll - el adaptador de ModelBus ADSL expuesto.
Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0
Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0

Estos ensamblados pueden encontrarse en el proyecto de ModelBusAdapters ADSL expuesto, en bin\*.

En el archivo de código donde creará referencias, tendrá que normalmente 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 del modelo, tiene acceso al AdapterManager para ADSL expuesto, y se utiliza para crear una referencia al modelo.Puede especificar una ruta de acceso, o EnvDTE.ProjectItem.

De AdapterManager, puede obtener un adaptador, que proporciona acceso a los elementos individuales en el modelo.

[!NOTA]

Debería eliminar un adaptador cuando termine con él.La manera más conveniente de conseguirlo es con una instrucción de 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 desea poder utilizar modelReference más adelante, puede guardarlo en una propiedad de dominio que tenga el tipo ModelBusReferenceexterno:

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

Para permitir que los usuarios editen esta propiedad de dominio, utilice ModelReferenceEditor como parámetro en el atributo del editor.Para obtener más información, vea Permite al usuario editar una referencia.

para crear una referencia a un elemento

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

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

Si desea poder utilizar elementReference más adelante, puede guardarlo en una propiedad de dominio que tenga el tipo ModelBusReferenceexterno.Para permitir que los usuarios se editen, utilice ModelElementReferenceEditor como parámetro en el atributo del editor.Para obtener más información, vea Permite al usuario editar una referencia.

resolver referencias

Si tiene ModelBusReference (MBR) puede obtener el modelo o el elemento de modelo a los que hace referencia.Si el elemento se muestra en el diagrama u otra vista, puede abrir la vista y seleccione el elemento.

Puede crear un adaptador de un MBR.El adaptador, puede obtener la raíz del modelo.También puede resolver MBRs que hace 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

ADSL que desea tener acceso debería tener un adaptador de ModelBus que se ha configurado para el acceso de las plantillas de texto.Para obtener más información, vea To provide access to a DSL.

Normalmente, tendrá acceso a un destino ADSL mediante una referencia del modelo de (MBR) bus almacenada en un origen ADSL.La plantilla por consiguiente incluye la directiva de origen DSL, más código para resolver el MBR.Para obtener más información acerca de las plantillas de texto, vea Generar código a partir de lenguajes específicos 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 a 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 obtener más información y un tutorial, vea Usar ModelBus de Visual Studio en plantillas de texto

Serialización de un ModelBusReference

Si desea almacenar 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);

Un MBR que es serializado de esta manera es independiente del contexto.Si usa el adaptador modelo basado en archivos simple de bus, el MBR contiene una ruta de acceso absoluta.Esto es suficiente si los archivos del modelo de instancia nunca se desplazan.Sin embargo, los archivos de modelo serán normalmente elementos en un proyecto de Visual Studio .Los usuarios esperarán poder mover todo el proyecto a diferentes partes del sistema de archivos.También esperarán poder conservar el proyecto bajo control de código fuente y abrirlo en equipos diferentes.Los nombres de ruta deben ser por consiguiente serializados en relación con la ubicación del proyecto que contiene los archivos.

Serializando Relativo A una ruta de acceso del archivo especificado

ModelBusReference contiene ReferenceContext, un diccionario en el que puede almacenar información como la ruta de acceso relativa a que debe ser serializado.

Para serializar en relación con 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);

ModelBusReferences creados por otros adaptadores

La siguiente información es útil si desea crear dispone del adaptador.

ModelBusReference (MBR) consta de dos partes: el encabezado de MBR, que es deserializado por model bus, y un adaptador-específico que es administrada por el administrador específico del adaptador.Esto permite proporcionar dispone de formato de serialización del adaptador.Por ejemplo, puede hacer referencia a una base de datos en lugar de un archivo, o podría almacenar información adicional en la referencia del adaptador.Propietario del adaptador puede colocar información adicional en ReferenceContext.

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

El MBR se deserializa en dos fases:

ModelBusReferencePropertySerializer es el serializador estándar que trata de encabezado de MBR.Utiliza el contenedor de propiedades estándar ADSL SerializationContext , que se almacena en ReferenceContext mediante ModelBusReferencePropertySerializer.ModelBusLoadContextKeyclave.En particular, SerializationContext debe contener una instancia de ModelBus.
El adaptador de ModelBus se ocupa de la parte adaptador-específica de MBR.Puede utilizar la información adicional almacenada en el ReferenceContext de MBR.El adaptador basado en archivos simple conserva las rutas de acceso de la raíz mediante las teclas FilePathLoadContextKeyy FilePathSaveContextKey.

Una referencia de adaptador en un archivo modelo se deserializa únicamente cuando se usa.

para crear un modelo

Crear, abrir y editar un modelo

El siguiente fragmento se toma del equipo de estado en el sitio Web de VMSDK.Muestra el uso de ModelBusReferences de crear y abrir un modelo, y obtener el diagrama asociado al modelo.

En este ejemplo, el nombre del destino DSL es StateMachine.Varios nombres son derivados de, como el nombre de la clase del modelo y el nombre de 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();
    }
}

validar referencias

El BrokenReferenceDetector prueba todas las propiedades de dominio en un almacén que puede contener ModelBusReferences.Se llama a la acción que proporciona donde se encuentra cualquier acción.Esto es especialmente ú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 referencias dividen los informes 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 ths ReferenceState instance "
  + "named '{1}' contains reference value '{2}' which is invalid";

Acciones que realizan la extensión de ModelBus

La siguiente información no es esencial, pero podría ser útil si crea un uso extensivo de ModelBus.

La extensión de ModelBus realiza los cambios siguientes en la solución ADSL.

Al hacer clic con el botón secundario en el diagrama de definición ADSL, haga clic en permiso Modelbusy, a continuación Permite a este ADSL para consumir el ModelBus:

En el proyecto ADSL, se agrega una referencia a Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.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 ADSL, 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 a ModelBusReference, haga clic con el botón secundario en la propiedad y haga clic Propiedades específicas de ModelBusReference de permiso:

Varios atributos CLR se agregan a la propiedad del dominio.Puede verlos en el campo de los atributos personalizados en la ventana Propiedades.En Dsl\GeneratedCode\DomainClasses.cs, puede ver los atributos de la declaración de 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 secundario en el diagrama de definición ADSL, haga clic en permiso ModelBus, y seleccione Expone este ADSL a ModelBus:

un nuevo proyecto ModelBusAdapter se agrega a la solución.
Una referencia a ModelBusAdapter se agrega al proyecto de DslPackage .ModelBusAdapter tiene una referencia al proyecto de Dsl .
En DslPackage\source.extention.tt, |ModelBusAdapter| se agrega como un componente MEF.

Vea también

Conceptos

Cómo: Abrir un modelo desde un archivo en el código del programa

Cómo: Integrar modelos UML con otros modelos y herramientas

Cómo: Agregar un controlador para arrastrar y colocar

Usar ModelBus de Visual Studio en plantillas de texto

Compartir a través de