Integrar modelos utilizando Modelbus de Visual Studio
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.
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 cargará el modelo apropiado y devolverá el elemento. Si quiere, puede mostrar el modelo al usuario. Si no se puede acceder al archivo en su ubicación anterior, ModelBus pedirá al usuario que lo busque. Si el usuario encuentra el archivo, ModelBus corregirá 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 obtener información y ejemplos de código, vea:
Sitio web del SDK de Visual Studio de visualización y modelado (VMSDK)
Proporcionar acceso a un DSL
Antes de crear referencias de ModelBus a un modelo o a sus elementos, debe definir un ModelBusAdapter para el DSL. La manera más fácil de hacerlo es usar la extensión Visual Studio ModelBus, que agrega comandos a DSL Designer (Diseñador de DSL).
Para exponer una definición de DSL a ModelBus
Si aún no lo ha hecho, descargue e instale la extensión Visual Studio ModelBus. Para obtener más información, vea SDK de visualización y modelado.
Abra el archivo de definición de DSL. Haga clic con el botón secundario en la superficie de diseño y, después, haga clic en Enable Modelbus (Habilitar ModelBus).
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.
Haga clic en Aceptar. Se agrega un nuevo proyecto "ModelBusAdapter" a la solución de DSL.
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 obtener más información, vea Usar ModelBus de Visual Studio en plantillas de texto.
Cambie la clase base de AdapterManagerBase por VsTextTemplatingModelingAdapterManager.
Cerca del final del archivo, inserte este atributo adicional frente a la clase AdapterManager:
[Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
En el proyecto References of ModelBusAdapter (Referencias de ModelBusAdapter), agregue Microsoft.VisualStudio.TextTemplating.Modeling.11.0.
Si quiere acceder al DSL desde las plantillas de texto y desde otro código, necesita dos adaptadores, uno modificado y otro sin modificar.
Haga clic en Transformar todas las plantillas.
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 DSL, debe importar estos ensamblados.
Asegurarse de que se puede hacer referencia a los elementos
De forma predeterminada, los adaptadores de ModelBus de Visual Studio usan el GUID de un elemento para identificarlo. Estos identificadores deben conservarse en el archivo del modelo.
Para asegurarse de que los identificadores de elemento se conservan
Abra DslDefinition.dsl.
En DSL Explorer (Explorador de DSL), expanda Xml Serialization Behavior (Comportamiento de la serialización de XML) y, después, Class Data (Datos de clase).
Para cada clase para la que quiera crear referencias de ModelBus:
Haga clic en el nodo de clase y, en la ventana Properties (Propiedades), asegúrese de que el valor de Serialize Id (Serializar id.) es true.
O bien, si en lugar de GUID quiere usar nombres de elemento para identificar los elementos, puede invalidar 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.
Invalide ResolveElementReference para buscar el elemento correcto en una referencia de ModelBus.
Acceder a un DSL desde otro DSL
Puede almacenar referencias de ModelBus en una propiedad de dominio de un DSL, y puede escribir código personalizado para usarlas. También puede permitir que el usuario cree una referencia de ModelBus seleccionando 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
En el diagrama DSL Definition (Definición de DSL), haga clic con el botón secundario en la parte principal del diagrama y, después, haga clic en Enable Modelbus (Habilitar ModelBus).
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).
En el proyecto del DSL de consumo, agregue los siguientes ensamblados a las referencias del proyecto. Encontrará estas referencias (archivos .dll) en el directorio ModelBusAdapter\bin\* del DSL expuesto.
El ensamblado del DSL expuesto, por ejemplo, Fabrikam.FamilyTree.Dsl.dll.
El ensamblado del adaptador de ModelBus expuesto, por ejemplo, Fabrikam.FamilyTree.ModelBusAdapter.dll.
Agregue los siguientes ensamblados .NET a las referencias del proyecto de DSL de consumo.
Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll
Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0.dll
Para almacenar una referencia de ModelBus en una propiedad de dominio
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.
En la ventana Properties (Propiedades), con la propiedad de dominio seleccionada, establezca Type (Tipo) en ModelBusReference.
En esta etapa, el código de programa puede establecer el valor de la propiedad, pero es de solo lectura en la ventana Properties (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 permite a los usuarios elegir 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
Haga clic con el botón secundario en la propiedad de dominio y, después, haga clic en Edit ModelBusReference specific properties (Editar las propiedades específicas de ModelBusReference). Se abre un cuadro de diálogo. Este es el selector de ModelBus.
En Kind of ModelBusReference (Tipo de ModelBusReference), seleccione el tipo de referencia de ModelBus: a un modelo o a un elemento dentro de un modelo.
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 de su DSL expuesto.
Si eligió hacer referencia a un elemento en un modelo, puede agregar una lista de tipos que el usuario puede seleccionar, por ejemplo, Company.FamilyTree.Person.
Haga clic en Aceptar y en 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.
Si especificó una lista de tipos de destino, como Company.FamilyTree.Person, debe agregar una referencia de ensamblado a su proyecto de DSL, haciendo referencia al archivo DLL del DSL de destino, por ejemplo, Company.FamilyTree.Dsl.dll
Para probar una referencia de ModelBus
Compile los DSL expuestos y de consumo.
Presione F5 o CTRL+F5 para ejecutar uno de los DSL en modo experimental.
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.
Cree algunos elementos y vínculos en la instancia del DSL expuesto, y guárdelo.
Abra una instancia del DSL de consumo y seleccione un elemento de modelo que tenga una propiedad de referencia de ModelBus.
En la ventana Propiedades, haga doble clic en la propiedad de referencia de ModelBus. Se abre el cuadro de diálogo del selector.
Haga clic en Browse (Examinar) y seleccione la instancia del DSL expuesto.
El selector también le permitirá elegir un elemento del modelo, si especificó el tipo de referencia de ModelBus específica del elemento.
Crear referencias en código de programa
Si quiere almacenar una referencia a un modelo o a un elemento dentro de un modelo, cree una ModelBusReference. Hay dos tipos de ModelBusReference: referencias de modelo y referencias de elemento.
Para crear una referencia de modelo, necesita el 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 que estén en la misma solución de Visual Studio.
Importar los ensamblados de DSL expuestos
En el proyecto de consumo, agregue referencias de proyecto a los ensamblados de DSL y ModelBusAdapter del DSL expuesto.
Por ejemplo, supongamos que quiere almacenar referencias de ModelBus en elementos de un DSL MusicLibrary. Las referencias de ModelBus harán referencia a elementos del DSL FamilyTree. En el proyecto Dsl de la solución MusicLibrary, en el nodo Referencias, agregue referencias a los siguientes ensamblados:
Fabrikam.FamilyTree.Dsl.dll: el DSL expuesto.
Fabrikam.FamilyTree.ModelBusAdapters.dll: el adaptador de ModelBus del DSL expuesto.
Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0
Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0
Estos ensamblados se encuentran en el proyecto ModelBusAdapters del DSL expuesto, en bin\*.
En el archivo de código donde creará las referencias, normalmente tendrá 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 obtener más información, vea Permitir 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 obtener más información, vea Permitir 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 obtener más información, vea To provide access to a DSL.
Normalmente, se accederá a un DSL de destino usando una 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 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.
Serializar una 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 al archivo absoluta. Esto es suficiente si los archivos de modelo de la instancia nunca se mueven. Sin embargo, los archivos de modelo normalmente serán elementos de 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 mantener el proyecto bajo 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.
Serializar con relación a una ruta de acceso al 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 es administrada por el administrador del adaptador específico. Esto permite proporcionar su propio formato 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 del ReferenceContext. Por ejemplo, en el adaptador simple basado en archivos, el ReferenceContext contiene una ruta de acceso al archivo raíz, que no se almacena en la cadena de la MBR serializada.
La MBR se deserializa en dos etapas:
ModelBusReferencePropertySerializer es el serializador estándar que trata con 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 usando las claves FilePathLoadContextKey y FilePathSaveContextKey.
En un archivo de modelo, las referencias de adaptador solo se deserializan cuando se usan.
Para crear un modelo
Crear, abrir y editar 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();
}
}
Validar 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. Esto resulta especialmente útil para 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 ths ReferenceState instance "
+ "named '{1}' contains reference value '{2}' which is invalid";
Acciones realizadas por la extensión ModelBus
La siguiente información no es esencial, pero 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.
Haga clic con el botón secundario en el diagrama DSL Definition (Definición de DSL), haga clic en Enable Modelbus (Habilitar ModelBus) y seleccione Enable this DSL to Consume the ModelBus (Permitir que este DSL use ModelBus). Después:
En el proyecto de DSL, 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 DSL Explorer (Explorador de DSL), en Domain Types (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.
Establezca el tipo de una propiedad de dominio en ModelBusReference, haga clic con el botón secundario en la propiedad y haga clic en Enable ModelBusReference specific properties (Habilitar las propiedades específicas de ModelBusReference). Después:
Se agregan varios atributos CLR a la propiedad de dominio. Puede verlos en el campo Custom Attributes (Atributos personalizados), en la ventana Properties (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")]
Haga clic con el botón secundario en el diagrama DSL Definition (Definición de DSL), haga clic en Enable Modelbus (Habilitar ModelBus) y seleccione Expose this DSL to the ModelBus (Exponer este DSL a ModelBus). Después:
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, se agrega |ModelBusAdapter| 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