Integrar modelos usando o Visual Studio ModelBus
O Visual Studio ModelBus fornece um método para criar vínculos entre modelos e de outras ferramentas para modelos. Por exemplo, é possível vincular modelos de linguagem específica de domínio (DSL) e modelos UML. É possível criar um conjunto integrado de DSLs.
Aviso
A Extensão de ModelBus do Visual Studio, descrita neste artigo, não está mais disponível para download. No entanto, essas instruções ainda funcionam para os usuários que já têm essa extensão instalada.
O ModelBus permite criar uma referência exclusiva para um modelo ou um elemento específico dentro de um modelo. Essa referência pode ser armazenada fora do modelo, por exemplo, em um elemento em outro modelo. Quando, em uma ocasião posterior, uma ferramenta desejar obter acesso ao elemento, a infraestrutura do Model Bus carrega o modelo adequado e retornará o elemento. Se desejar, é possível exibir o modelo ao usuário. Se não for possível acessar o arquivo em seu local anterior, o ModelBus pedirá ao usuário para encontrá-lo. Se o usuário encontrar o arquivo, o ModelBus atualizará todas as referências àquele arquivo.
Observação
Na implementação atual do Visual Studio do ModelBus, os modelos vinculados devem ser itens na mesma solução do Visual Studio.
Para saber mais sobre a Extensão ModelBus, consulte os seguintes recursos:
Observação
O componente Transformação de Modelo de Texto é instalado automaticamente como parte da carga de trabalho de Desenvolvimento de extensões do Visual Studio. Você também pode instalá-lo na guia Componentes individuais do Instalador do Visual Studio, na categoria SDKs, bibliotecas e estruturas. Instale o componente SDK de Modelagem na guia Componentes individuais.
Fornecer acesso a uma DSL
Antes de ser possível criar referências do ModelBus para um modelo ou seus elementos, defina um ModelBusAdapter para a DSL. A maneira mais fácil de fazer isso é definir um, é usar a extensão Visual Studio ModelBus, que inclui comandos ao Designer de DSL.
Para expor uma definição de DSL ao Model Bus
Abra o arquivo de definição de DSL. Clique com o botão direito do mouse na superfície de design e selecione Habilitar Modelbus.
Na caixa de diálogo, selecione Quero expor essa DSL ao ModelBus. É possível escolher as duas opções se desejar que essa DSL exponha seus modelos e consuma referências a outras DSLs.
Selecione OK. Um novo projeto
ModelBusAdapteré incluído na solução DSL.Se desejar acessar a DSL a partir de um modelo de texto, é necessário modificar o AdapterManager.tt no novo projeto. Ignore essa etapa se desejar acessar a DSL a partir de outro código como comandos e manipuladores de eventos. Para saber mais, confira Como usar o Visual Studio ModelBus em um modelo de texto.
Próximo à classe base do
AdapterManagerBasepara VsTextTemplatingModelingAdapterManager.Próximo ao final do arquivo, insira esse atributo adicional em frente à classe
AdapterManager:[Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]No Gerenciador de Pacotes NuGet do
ModelBusAdapterprojeto, adicione um Pacote NuGetReference aMicrosoft.VisualStudio.TextTemplating.Modeling.Se desejar acessar a DSL a partir de modelos de texto e de outro código, serão necessários dois adaptadores, um modificado e um não modificado.
Selecione Transformar Todos os Modelos.
Recriar a solução.
Agora, o ModelBus pode abrir instâncias dessa DSL.
A pasta ModelBusAdapters\bin* contém os assemblies compilados pelo projeto
Dsle o projetoModelBusAdapters. Para referenciar essa DSL a partir de outra DSL, importe esses assemblies.
Verifique se elementos podem ser referenciados
Por padrão, os adaptadores do ModelBus usam o GUID de um elemento para identificá-lo. Esses identificadores devem persistir no arquivo do modelo.
Para garantir que as IDs de elementos persistirão:
Abra DslDefinition.dsl.
No DSL Explorer, expanda Xml Serialization Behavior e Class Data.
Para cada classe para qual deseja criar referências do Model Bus:
Selecione o nó e na janela Propriedades verifique se Serialize ID está definido como
true.
Alternativamente, se desejar usar nomes de elemento para identificar elementos ao invés de GUIDs, é possível substituir partes dos adaptadores gerados. Substituir os seguintes métodos na classe do adaptador:
- Substituir
GetElementIdpara retornar o identificador que deseja usar. Esse método é chamado ao criar referências. - Substituir
ResolveElementReferencepara localizar o elemento correto a partir de uma referência do ModelBus.
Acessar uma DSL a partir de outra DSL
É possível armazenar referências do ModelBus em uma propriedade de domínio em uma DSL e, é possível gerar código personalizado que as utiliza. Também é possível permitir ao usuário criar uma referência do ModelBus selecionando um arquivo de modelo e um elemento dentro dele.
Para permitir que uma DSL use referências para outra DSL, primeiro é necessário torná-la uma consumidora das referências do model bus.
Permitir a uma DSL consumir referências para uma DSL exposta
No diagrama Definição de DSL, clique com o botão direito na parte principal do diagrama e clique em Habilitar Modelbus.
Na caixa de diálogo, selecione Desejo habilitar este modelo para consumir referências do model bus.
No projeto
Dslda DSL consumidora, inclua os assemblies a seguir às referências do projeto. Esses assemblies (arquivos .dll) poderão ser encontrados no diretório ModelBusAdapter\bin\* da DSL exposta.O assembly DSL exposto, por exemplo, Fabrikam.FamilyTree.Dsl.dll
O assembly do adaptador de barramento de modelo exposto, por exemplo, Fabrikam.FamilyTree.ModelBusAdapter.dll
Inclua os assemblies .NET a seguir às referências de projeto do projeto DSL consumidor.
- Microsoft.VisualStudio.Modeling.Sdk.Integration.dll
- Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.dll
Armazenar uma Referência do ModelBus em uma propriedade de domínio
Na Definição de DSL da DSL consumidora, inclua uma propriedade de domínio a uma classe de domínio e defina seu nome.
Na janela Propriedades, com a propriedade de domínio selecionada, defina Tipo como
ModelBusReference.Neste estágio, o código do programa pode definir o valor da propriedade. O valor é somente leitura na janela Propriedades.
É possível permitir aos usuários definirem a propriedade com um editor de ModelBusReference especializado. Há duas versões deste editor ou seletor. Uma permite aos usuários escolher um arquivo de modelo e a outra permite aos usuários escolher um arquivo de modelo e um elemento dentro do modelo.
Permitir ao usuário definir uma Referência do Model Bus em uma propriedade de domínio
Clique com o botão direito na propriedade de domínio e selecione Editar propriedades específicas do ModelBusReference. A caixa de diálogo Seletor de Barramento de Modelo é aberta.
Defina o Tipo de ModelBusReference adequado para um modelo ou para um elemento dentro de um modelo.
Na cadeia de caracteres de filtro do diálogo do arquivo, insira uma cadeia como
Family Tree files |*.ftree. Substitua a extensão de arquivo da DSL exposta.Ao escolher referenciar um elemento em um modelo, é possível incluir uma lista de tipos que o usuário pode selecionar, por exemplo,
Company.FamilyTree.Person.Clique em OK e em Transformar todos os modelos na barra de ferramentas do Gerenciador de soluções.
Aviso
Se nenhum modelo ou entidade válida estiver selecionada, o botão OK não tem efeito, mesmo se parecer estar habilitado.
Se uma lista de tipos de destino como
Company.FamilyTree.Persontiver sido especificada, será necessário incluir uma referência de assembly para o projeto DSL, referenciando o DLL da DSL de destino, por exemplo, Company.FamilyTree.Dsl.dll.
Para testar um ModelBusReference
Compile a DSL exposta e a consumidora.
Execute uma das DSLs em modo experimental pressionando F5 ou CTRL+F5.
Em Depuração de projeto na instância experimental do Visual Studio, inclua arquivos que são instâncias de cada DSL.
Observação
O Visual Studio ModelBus pode resolver apenas referências para modelos que são itens na mesma solução do Visual Studio. Por exemplo, não é possível criar uma referência para um arquivo de modelo em outra parte do sistema de arquivos.
Crie alguns elementos e vínculos na instância da DSL exposta e salve.
Abra uma instância da DSL consumidora e selecione um elemento de modelo que possui uma propriedade de referência do Model Bus.
Na janela Propriedades, clique duas vezes na propriedade de referência do ModelBus. O diálogo do seletor é exibido.
Selecione Navegar e escolha a instância da DSL exposta.
Se você especificou o tipo específico de elemento da referência do Model Bus, o seletor também permitirá a escolha de uma item no modelo.
Criar Referências no código do programa
Quando desejar armazenar uma referência para um modelo ou um elemento dentro de um modelo, crie uma ModelBusReference. Existem dois tipos de ModelBusReference: referências de modelo e referências de elemento.
Para criar uma referência de modelo, é necessário o AdapterManager da DSL cujo modelo é uma instância e o nome do arquivo ou item de projeto Visual Studio do modelo.
Para criar uma referência de elemento, é necessário um adaptador para o arquivo de modelo e o elemento ao qual deseja referir.
Observação
Com o Visual Studio ModelBus, você pode criar referências somente a itens na mesma solução do Visual Studio.
Importe os assemblies da DSL exposta
No projeto consumidor, inclua referências de projeto para a DSL e os assemblies ModelBusAdapter da DSL exposta.
Por exemplo, suponha que deseja armazenar referências do ModelBus em elementos de uma DSL de MusicLibrary. As Referências do ModelBus indicam elementos da DSL de FamilyTree. No nó de Referências, o projeto de Dsl da solução de MusicLibrary, inclua referências para os seguintes assemblies:
Fabrikam.FamilyTree.Dsl.dll. O DSL exposto.
Fabrikam.FamilyTree.ModelBusAdapters.dll O adaptador do ModelBus da DSL exposta.
Microsoft.VisualStudio.Modeling.Sdk.Integration
Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell
Esses assemblies podem ser encontrados no projeto do
ModelBusAdaptersda DSL exposta, em *bin\**.No arquivo de código onde as referências são criadas, geralmente é necessário importar esses namespaces:
// 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;
...
Criar uma referência para um modelo
Para criar uma referência de modelo, acesse o AdapterManager da DSL exposta e use-o para criar uma referência para o modelo. É possível especificar um caminho de arquivo ou um EnvDTE.ProjectItem.
No AdapterManager, é possível obter um Adaptador, que fornece acesso a elementos individuais no modelo.
Observação
É necessário descartar um Adaptador após usá-lo. A maneira mais conveniente de fazer isso é com uma instrução using. O exemplo a seguir ilustra essa situação.
// 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
Se desejar ser capaz de usar a modelReference posteriormente, é possível armazená-la em uma propriedade de domínio que possui o Tipo Externo ModelBusReference:
using Transaction t = this.Store.TransactionManager
.BeginTransaction("keep reference"))
{
artist.FamilyTreeReference = modelReference;
t.Commit();
}
Para permitir aos usuários editar essa propriedade de domínio, use ModelReferenceEditor como o parâmetro no atributo Editor. Para obter mais informações, consulte Permitir ao usuário editar uma referência.
Criar uma referência para um elemento
O adaptador criado para o modelo pode ser usado para criar e resolver referências.
// person is an element in the FamilyTree model:
ModelBusReference personReference =
adapter.GetElementReference(person);
Se desejar ser capaz de usar a elementReference posteriormente, é possível armazená-la em uma propriedade de domínio que possui o Tipo Externo ModelBusReference. Para permitir aos usuários editá-la, use ModelElementReferenceEditor como o parâmetro no atributo Editor. Para obter mais informações, consulte Permitir ao usuário editar uma referência.
Resolvendo referências
Se possuir uma ModelBusReference (MBR) é possível obter o modelo ou o elemento do modelo ao qual se refere. Se o elemento for apresentado em um diagrama ou em outra visualização, é possível abrir a visualização e selecionar o elemento.
É possível criar um adaptador a partir de uma MBR. A partir do adaptador, é possível obter a raiz do modelo. Também é possível resolver MBRs que referem a elementos específicos dentro do 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 Referências do ModelBus em um Modelo de Texto
A DSL que deseja acessar deve possuir um Adaptador do ModelBus configurado para acesso por modelos de texto. Para obter mais informações, consulte Fornecendo acesso a uma DSL.
Geralmente, uma DSL de destino é acessada usando uma Referência do Model Bus (MBR) armazenada em uma DSL de origem. O modelo, portanto, inclui a diretiva da DSL de origem, mais o código para resolver a MBR. Para obter mais informações sobre modelos de texto, confira Gerar código de uma linguagem específica de domínio.
<#@ 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 saber mais e consultar um passo a passo, confira Como usar o Visual Studio ModelBus em um modelo de texto
Serializar uma ModelBusReference
Se desejar armazenar uma ModelBusReference (MBR) na forma de uma cadeia de caracteres, é possível serializá-la:
string serialized = modelBus.SerializeReference(elementReference);
// Store it anywhere, then get it back again:
ModelBusReference elementReferenceRestored =
modelBus.DeserializeReference(serialized, null);
Uma MBR serializada dessa maneira é independente de contexto. Ao usar o Adaptador do Model Bus baseado em arquivo simples, a MBR contém um caminho de arquivo absoluto. Se os arquivos de modelo de instância nunca se moverem, essa serialização será suficiente. No entanto, os arquivos de modelo normalmente são itens em um projeto do Visual Studio. A expectativa dos usuários é a de poder mover o projeto inteiro para diferentes partes do sistema de arquivos. Eles também esperam poder manter o projeto sob algum controle de origem e abri-lo em diferentes computadores. Os nomes de caminhos devem, portanto, ser serializados em relação ao local do projeto que contém os arquivos.
Serialização relativa a um caminho de arquivo especificado
Uma ModelBusReference contém um ReferenceContext, que é um dicionário no qual é possível armazenar informações como o caminho de arquivo relativo ao qual deve ser serializado.
Serialização relativa a um caminho:
elementReference.ReferenceContext.Add(
ModelBusReferencePropertySerializer.FilePathSaveContextKey,
currentProjectFilePath);
string serialized = modelBus.SerializeReference(elementReference);
Para recuperar a referência da cadeia de caracteres:
ReferenceContext context = new ReferenceContext();
context.Add(ModelBusReferencePropertySerializer.FilePathLoadContextKey,
currentProjectFilePath);
ModelBusReference elementReferenceRestored =
modelBus.DeserializeReference(serialized, context);
Referências ModelBus criadas por outros adaptadores
As informações a seguir são úteis caso desejar criar seu próprio adaptador.
Uma ModelBusReference (MBR) consiste em duas partes: o cabeçalho da MBR, que é desserializado pelo Model Bus e um adaptador específico que é manipulado pelo gerenciador de adaptador específico. Essa abordagem permite fornecer seu próprio formato de serialização de adaptador. Por exemplo, é possível referenciar um banco de dados ao invés de um arquivo ou é possível armazenar informações adicionais na referência do adaptador. Seu próprio adaptador pode inserir informações adicionais no ReferenceContext.
Ao desserializar uma MBR, é necessário fornecer um ReferenceContext, que é armazenado no objeto da MBR. Ao serializar uma MBR, o ReferenceContext armazenado é usado pelo adaptador para ajudar a gerar a cadeia de caracteres. A cadeia de caracteres desserializada não contém todas as informações do ReferenceContext. Por exemplo, no adaptador baseado em arquivo simples, o ReferenceContext contém um caminho de arquivo raiz. O caminho não é armazenado na cadeia de caracteres MBR serializada.
A MBR é desserializada em dois estágios:
ModelBusReferencePropertySerializeré o serializador padrão que lida com o cabeçalho da MBR. Utiliza o recipiente de propriedades doSerializationContextda DSL, que é armazenado noReferenceContextusando a chaveModelBusReferencePropertySerializer.ModelBusLoadContextKey. Em específico, oSerializationContextdeverá conter uma instância doModelBus.O Adaptador do ModelBus lida com a parte específica do adaptador da MBR. Poderá usar informações adicionais armazenadas no ReferenceContext da MBR. O adaptador baseado em arquivo simples mantém os caminhos de arquivo raiz usando as chaves
FilePathLoadContextKeyeFilePathSaveContextKey.Uma referência de adaptador em um arquivo de modelo é desserializada apenas quando é usada.
Criar um modelo
Criando, abrindo e editando um modelo
O fragmento a seguir foi retirado da amostra da Máquina de Estado no site do VMSDK. Ilustra o uso de ModelBusReferences para criar e abrir um modelo e para obter o diagrama associado com o modelo.
Nessa amostra, o nome da DSL de destino é StateMachine. Diversos nomes são derivados desse nome, como o nome da classe do modelo e o nome do 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 referências
O BrokenReferenceDetector testa todas as propriedades de domínio em um Armazenamento que pode conter ModelBusReferences. Ele chama a ação fornecida onde qualquer ação for encontrada. Esse teste é útil para métodos de validação. O método de validação a seguir testa o armazenamento em uma tentativa de salvar o modelo e relata referências quebradas na janela de erros:
[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";
Ações realizadas pela Extensão do ModelBus
As informações a seguir podem ser úteis caso faça uso extensivo do ModelBus.
A Extensão do ModelBus realiza as alterações a seguir na solução de DSL.
Ao clicar com o botão direito no diagrama da Definição de DSL, escolha Habilitar Modelbus e selecione Habilitar esta DSL para consumir o ModelBus:
No projeto DSL, uma referência deve ser adicionada ao Microsoft.VisualStudio.Modeling.Sdk.Integration.dll.
Na Definição de DSL, uma referência de Tipo Externo é incluída:
Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.É possível visualizar a referência no DSL Explorer, sob Tipos de Domínio. Para incluir referências de tipo externo manualmente, clique com o botão direito no nó raiz.
Um novo arquivo de modelo é adicionado, Dsl\GeneratedCode\ModelBusReferencesSerialization.tt.
Ao definir o tipo de uma propriedade de domínio para ModelBusReference e clicar com o botão direito na propriedade e selecione em Habilitar propriedades específicas da ModelBusReference:
Diversos atributos de CLR são incluídos na propriedade do domínio. É possível visualizá-los no campo Atributos Personalizados na janela Propriedades. Em Dsl\GeneratedCode\DomainClasses.cs, você pode ver os atributos na declaração de propriedade:
[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")]
Ao clicar com o botão direito no Diagrama da Definição de DSL, clique em Habilitar ModelBus e selecione Expor esta DSL ao ModelBus:
Um novo projeto
ModelBusAdapteré incluído na solução.Uma referência para o
ModelBusAdapteré incluída no projeto doDslPackage. OModelBusAdapterpossui uma referência para o projetoDsl.No DslPackage\source.extention.tt,
|ModelBusAdapter|é adicionado como um componente MEF.
Conteúdo relacionado
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de