Integración de modelos mediante Visual Studio ModelBus
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
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).
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.
Seleccione 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 más información, vea Uso de Visual Studio ModelBus en una plantilla de texto.
Cambie la clase base de
AdapterManagerBase
a VsTextTemplatingModelingAdapterManager.Cerca del final del archivo, inserte este atributo delate de la clase
AdapterManager
:[Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
En el Administrador de paquetes NuGet del proyecto
ModelBusAdapter
, agregue un elemento packageReference de NuGet aMicrosoft.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.
Seleccione 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 proyectoModelBusAdapters
. 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:
Abra DslDefinition.dsl.
En Explorador de DSL, expanda Comportamiento de serialización XML y, después, Datos de clase.
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
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).
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
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
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
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 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
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.
Establezca el tipo de ModelBusReference adecuado en un modelo o en 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 del DSL expuesto.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
.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.
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
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 la referencia de ModelBus. Se abre el cuadro de diálogo del selector.
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 propiedadesSerializationContext
estándar de DSL, que se almacena en elReferenceContext
usando la claveModelBusReferencePropertySerializer.ModelBusLoadContextKey
. En concreto,SerializationContext
debería contener una instancia deModelBus
.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
yFilePathSaveContextKey
.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 proyectoDslPackage
.ModelBusAdapter
tiene una referencia al proyectoDsl
.En DslPackage\source.extention.tt,
|ModelBusAdapter|
se agrega como un componente de MEF.