Compartilhar via

A integração de modelos usando o Modelbus de Visual Studio

  • Artigo

Visual StudioModelBus fornece um método para criar links entre modelos e de outras ferramentas em modelos.Por exemplo, você pode vincular os modelos de linguagem específica de domínio (DSL) e modelos UML.Você pode criar um conjunto integrado de DSLs.

ModelBus permite que você criar uma referência exclusiva para um modelo ou a 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 obter acesso ao elemento, a infra-estrutura de barramento de modelo carregará o modelo apropriado e retornar o elemento.Se desejar, você pode exibir o modelo para o usuário.Se o arquivo não pode ser acessado no seu local anterior, ModelBus solicitará ao usuário para localizá-lo.Se o usuário não encontrar o arquivo, ModelBus irá corrigir todas as referências a esse arquivo.

ObservaçãoObservação

No atual Visual Studio a implementação de ModelBus, os modelos vinculados deve ser itens na mesma Visual Studio solução.

Para obter informações adicionais e código de exemplo, consulte:

Fornecendo acesso a uma DSL

Antes de criar referências de ModelBus a um modelo ou seus elementos, você deve definir um ModelBusAdapter para o DSL.A maneira mais fácil de fazer isso é usar o Visual Studio extensão de barramento de modelo, que adiciona comandos para o Designer de DSL.

Para expor uma definição de DSL ao barramento de modelo

  1. Baixe e instale a extensão de barramento de modelo de Visual Studio, a menos que você já o tenha instalado.Para obter mais informações, consulte SDK de modelagem e visualização.

  2. Abra o arquivo de definição de DSL.Clique com o botão direito na superfície de design e, em seguida, clique em Habilitar Modelbus.

  3. Na caixa de diálogo, escolha desejo expor essa DSL para o ModelBus.Você pode escolher as duas opções se desejar que essa DSL para expor seus modelos e consumir referências a outras DSLs.

  4. Clique em OK.Um novo projeto "ModelBusAdapter" é adicionado à solução DSL.

  5. Se você desejar acessar o DSL de um modelo de texto, você deve modificar o AdapterManager.tt no novo projeto.Pular essa etapa se quiser acessar o DSL de outros códigos como, por exemplo, comandos e manipuladores de eventos.Para obter mais informações, consulte Usando o ModelBus de Visual Studio em um modelo de texto.

    1. Alterar a classe base de AdapterManagerBase para VsTextTemplatingModelingAdapterManager.

    2. Próximo ao final do arquivo, insira esse atributo adicional na frente da classe AdapterManager:

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

    3. No projeto referências de ModelBusAdapter, adicione Microsoft.VisualStudio.TextTemplating.Modeling.11.0.

    Se você desejar acessar o DSL dos modelos de texto e do outro código, você precisa de dois adaptadores, sendo que um modificado e outro sem modificação.

  6. Clique em transformar todos os modelos de.

  7. Recrie a solução.

Agora é possível que ModelBus abrir ocorrências dessa DSL.

A pasta ModelBusAdapters\bin\* contém os assemblies criados pelo Dsl project e o ModelBusAdapters project.Para fazer referência a essa DSL de outro DSL, você deve importar esses assemblies.

Ff519531.collapse_all(pt-br,VS.110).gifCertificando-se de que os elementos podem ser referenciados

Visual StudioAdaptadores ModelBus usam o guid de um elemento para identificá-lo, por padrão.Esses identificadores, portanto, devem ser mantidos no arquivo do modelo.

Para garantir que esse elemento IDs são persistentes.

  1. Abra DslDefinition.dsl.

  2. No Explorer DSL, expanda Comportamento de serialização de Xml, em seguida, Dados de classe.

  3. Para cada classe à qual você deseja criar o modelo de barramento faz referência:

    Clique no nó de classe e, na janela Propriedades, certifique-se de que Id serializar for definido como true.

Como alternativa, se você quiser usar nomes de elemento para identificar elementos em vez de guids, você pode substituir partes dos adaptadores gerados.Substitua os seguintes métodos na classe adaptador:

  • Substituir GetElementId para retornar o identificador que você deseja usar.Esse método é chamado quando a criação de referências.

  • Substituir ResolveElementReference para localizar o elemento correto a partir de uma referência de barramento do modelo.

Acessando uma DSL de outro DSL

Você pode armazenar referências de barramento do modelo em uma propriedade de domínio em uma DSL e você pode escrever código personalizado que usa-los.Você também pode permitir que o usuário crie uma referência de barramento do modelo selecionando um arquivo de modelo e um elemento dentro dela.

Para habilitar uma DSL usar referências a outro DSL, você deve torná-la uma consumidor de referências de barramento do modelo.

Para habilitar uma DSL consumir referências a uma DSL exposto

  1. No diagrama de definição de DSL, clique com o botão direito na parte principal do diagrama e, em seguida, clique em Habilitar Modelbus.

  2. Na caixa de diálogo, selecione Desejo ativar este modelo consumir referências de barramento do modelo.

  3. No projeto Dsl de consumir DSL, adicione os seguintes assemblies as referências do projeto.Você encontrará esses assemblies (arquivos. dll) no diretório ModelBusAdapter\bin\ * de DSL exposto.

    • O assembly DSL exposto, por exemploFabrikam.FamilyTree.Dsl.dll

    • O conjunto do adaptador de barramento modelo exposto, por exemploFabrikam.FamilyTree.ModelBusAdapter.dll

  4. Adicione o seguinte.NET assemblies as referências de projeto do projeto consome DSL.

    1. Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll

    2. Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0.dll

Para armazenar uma referência de barramento do modelo em uma propriedade de domínio

  1. Na definição de DSL consumindo DSL, adicionar uma propriedade de domínio a uma classe de domínio e defina seu nome.

  2. Nas propriedades da janela, com a propriedade de domínio selecionada, defina tipo de para ModelBusReference.

Neste estágio, o código de programa pode definir o valor da propriedade, mas é somente leitura na janela Propriedades.

Você pode permitir que os usuários definam a propriedade com um editor de referência ModelBus especializados.Há duas versões desse editor ou seletor: um permite que os usuários escolham um arquivo de modelo e o outro permite que os usuários escolham um arquivo de modelo e um elemento dentro do modelo.

Para permitir ao usuário definir uma referência de barramento do modelo em uma propriedade de domínio

  1. A propriedade de domínio com o botão direito e, em seguida, clique em propriedades específicas de editar ModelBusReference.Uma caixa de diálogo é aberta.Este é o Selecionador de barramento do modelo de.

  2. Selecione o formato Tipo de ModelBusReference: a um modelo ou para um elemento dentro de um modelo.

  3. Na seqüência de filtro de caixa de diálogo de arquivo, inserir uma seqüência de caracteres, como Family Tree files |*.ftree.Substitua a extensão de arquivo de seu DSL exposto.

  4. Se você escolheu fazer referência a um elemento em um modelo, você pode adicionar uma lista dos tipos que o usuário pode selecionar, por exemplo Company.FamilyTree.Person.

  5. Clique em OKe, em seguida, clique em Transformar todos os modelos de da barra de ferramentas do solution explorer.

    Observação de cuidadoCuidado

    Se você não tiver selecionado um modelo válido ou uma entidade, no botão OK não terá nenhum efeito, mesmo que ele aparecer ativado.

  6. Se você especificou uma lista de tipos de destino como, por exemplo, Company.FamilyTree.Person, em seguida, você deve adicionar uma referência assembly ao projeto DSL, fazendo referência a DLL do destino DSL, por exemplo Company.FamilyTree.Dsl.dll

Para testar uma referência de barramento do modelo

  1. Construa DSLs expostas e consome.

  2. Execute uma das DSLs no modo experimental pressionando F5 ou CTRL + F5.

  3. No projeto de depuração na instância experimental do Visual Studio, adicionar arquivos que são instâncias de cada DSL.

    ObservaçãoObservação

    Visual StudioModelBus só pode resolver as referências a modelos que são os mesmos itens Visual Studio solução.Por exemplo, você não pode criar uma referência a um arquivo de modelo em outra parte do seu sistema de arquivos.

  4. Crie alguns elementos e links na instância do DSL exposto e salvá-lo.

  5. Abrir uma instância de DSL consumir e, em seguida, selecione um elemento de modelo que tenha uma propriedade de referência de barramento do modelo.

  6. Na janela Propriedades, clique duas vezes a propriedade de referência de barramento do modelo.Abre a caixa de diálogo da seletor.

  7. Clique em Procurar e selecione a instância de DSL exposto.

    O seletor também permitirá que você escolha um item no modelo, se você tiver especificado o tipo de elemento específico de referência de barramento do modelo.

A criação de referências no código de programa

Quando você deseja armazenar uma referência a um modelo ou um elemento dentro de um modelo, você cria um ModelBusReference.Há dois tipos de ModelBusReference: referências e referências de elemento de modelo.

Para criar uma referência de modelo, é necessário o AdapterManager de DSL da qual o modelo é uma instância e o nome do arquivo ou Visual Studio item de projeto do modelo.

Para criar uma referência de elemento, você precisa de um adaptador para o arquivo de modelo e o elemento que você deseja se referir.

ObservaçãoObservação

Com o Visual Studio ModelBus, você pode criar referências somente aos itens na mesma Visual Studio solução.

Ff519531.collapse_all(pt-br,VS.110).gifImportar os assemblies DSL expostos

No projeto consome, adicione referências de projeto para os assemblies DSL e ModelBusAdapter de DSL exposto.

Por exemplo, suponha que você deseja armazenar ModelBus referências em elementos de uma DSL de MusicLibrary.As referências de ModelBus se referirá a elementos de DSL FamilyTree.No Dsl o projeto da solução MusicLibrary, sob o nó References, adicione referências aos assemblies seguintes:

  • Fabrikam.FamilyTree.DSL.dll - DSL exposto.

  • Fabrikam.FamilyTree.ModelBusAdapters.dll - o adaptador de ModelBus de DSL exposto.

  • Microsoft.VisualStudio.Modeling.SDK.Integration.11.0

  • Microsoft.VisualStudio.Modeling.SDK.Integration.Shell.11.0

Esses assemblies podem ser encontrados na ModelBusAdapters o projeto de DSL exposto, em bin\*.

No arquivo de código onde você irá criar referências, geralmente você terá de importar esses espaços para nome:

// 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;
...

Ff519531.collapse_all(pt-br,VS.110).gifPara criar uma referência a um modelo

Para criar um referência de modelo, você acessar o AdapterManager para o DSL exposto e usá-lo para criar uma referência ao modelo.Você pode especificar um caminho arquivo, ou um EnvDTE.ProjectItem.

O AdapterManager, você pode obter um adaptador, que fornece acesso aos elementos individuais do modelo.

ObservaçãoObservação

Quando tiver terminado com ele, você deve descartar um adaptador.A maneira mais conveniente para conseguir isso é com um using instrução.O exemplo a seguir ilustra isto:

 
// 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 você deseja ser capaz de usar modelReference mais tarde, você pode armazená-lo em uma propriedade de domínio que tem o tipo externo ModelBusReference:

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

Para permitir que usuários editem esta propriedade de domínio, use ModelReferenceEditor como o parâmetro no atributo Editor.Para obter mais informações, consulte Permitir que o usuário para editar uma referência.

Ff519531.collapse_all(pt-br,VS.110).gifPara criar uma referência a um elemento

O adaptador que você criou 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 você deseja ser capaz de usar elementReference mais tarde, você pode armazená-lo em uma propriedade de domínio que tem o tipo externo ModelBusReference.Para permitir que usuários para editá-lo, use ModelElementReferenceEditor como o parâmetro no atributo Editor.Para obter mais informações, consulte Permitir que o usuário para editar uma referência.

Ff519531.collapse_all(pt-br,VS.110).gifResolver referências

Se você tiver um ModelBusReference (MBR), você pode obter o modelo ou o elemento de modelo ao qual se refere.Se o elemento é apresentado em um diagrama ou de outro modo de exibição, você pode abrir o modo de exibição e selecione o elemento.

Você pode criar um adaptador de um MBR.Do adaptador, você pode obter a raiz do modelo.Você também pode resolver MBRs que se 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 de ModelBus em um modelo de texto

  1. O DSL que você deseja acessar deve ter um adaptador de ModelBus que tenha sido configurado para acesso por modelos de texto.Para obter mais informações, consulte To provide access to a DSL.

  2. Normalmente, você irá acessar um destino DSL usando uma referência de barramento de modelo (MBR) armazenado em uma fonte de DSL.Portanto, o seu modelo inclui a diretiva a origem DSL, mais código para resolver o MBR.Para obter mais informações sobre modelos de texto, consulte Gerando código a partir 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 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 obter mais informações e um passo a passo, consulteUsando o ModelBus de Visual Studio em um modelo de texto

Serializando um ModelBusReference

Se você quiser armazenar um ModelBusReference (MBR) na forma de uma seqüência de caracteres, você pode serializá-lo:

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

Um MBR que é serializado dessa maneira é independente do contexto.Se você estiver usando o adaptador de barramento do modelo baseado em arquivos simples, o MBR contém um caminho absoluto.Isso é suficiente se os arquivos de modelo de instância nunca serão movido.No entanto, os arquivos de modelo serão normalmente itens em um Visual Studio project.Os usuários esperam ser capazes de mover todo o projeto para diferentes partes do sistema de arquivos.Eles também passarão a ser capaz de manter o projeto sob controle de origem e abri-lo em computadores diferentes.Nomes de caminho, portanto, devem ser serializadas relativa ao local do projeto que contém os arquivos.

Ff519531.collapse_all(pt-br,VS.110).gifSerializando relativo a um caminho de arquivo especificado

A ModelBusReference contém um ReferenceContext, que é um dicionário na qual você pode armazenar informações como, por exemplo, o caminho do arquivo em relação ao qual deve ser serializada.

Para serializar em relação 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);

Ff519531.collapse_all(pt-br,VS.110).gifModelBusReferences criados por outros adaptadores

As informações a seguir serão útil se você quiser criar seu próprio adaptador.

A ModelBusReference (MBR) consiste em duas partes: o cabeçalho do MBR, o que é desserializado pelo barramento modelo, e um específico do adaptador que é tratado pelo gerente de adaptador específico.Isso permite que você fornecer seu próprio formato de serialização do adaptador.Por exemplo, você pode fazer referência a um banco de dados, em vez de um arquivo, ou você poderia armazenar informações adicionais na referência do adaptador.Seu próprio adaptador pode colocar informações adicionais a ReferenceContext.

Ao tentar desserializar um MBR, você deve fornecer um ReferenceContext, que é então armazenado no objeto MBR.Ao serializar um MBR, o ReferenceContext armazenado é usado pelo adaptador para ajudar a gerar a seqüência de caracteres.A seqüência de caracteres desserializada não contém todas as informações do ReferenceContext.Por exemplo, o adaptador simples baseado em arquivo, o ReferenceContext contém um caminho de arquivo raiz, que não é armazenado na cadeia de caracteres serializada do MBR.

O MBR é desserializado em dois estágios:

  • ModelBusReferencePropertySerializeré o serializador padrão que lida com o cabeçalho do MBR.Ele usa a DSL padrão SerializationContext o conjunto de propriedades, que é armazenado na ReferenceContext usando a chave ModelBusReferencePropertySerializer.ModelBusLoadContextKey.Em particular, o SerializationContext deve conter uma instância de ModelBus.

  • O adaptador ModelBus lida com a parte de específico do adaptador do MBR.Ele pode usar informações adicionais, armazenadas na ReferenceContext do MBR.O adaptador de simple baseado em arquivo mantém os caminhos de arquivo raiz usando as teclas de FilePathLoadContextKey e FilePathSaveContextKey.

    Uma referência em um arquivo de modelo de adaptador é desserializada somente quando ele é usado.

Para criar um modelo

Ff519531.collapse_all(pt-br,VS.110).gifCriando, abrindo e editando um modelo

O fragmento a seguir é tirado da amostra de máquina de estado no site VMSDK.Ele ilustra o uso de ModelBusReferences para criar e abrir um modelo e para obter o diagrama associado ao modelo.

Neste exemplo, o nome do destino DSL é StateMachine.Vários nomes são derivados a partir dele, como, por exemplo, o nome da classe modelo e o nome da 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();
    }
}

Validando referências

O BrokenReferenceDetector testa todas as propriedades de domínio em um armazenamento que pode conter ModelBusReferences.Ele chama a ação que fornecem onde qualquer ação é encontrada.Isso é particularmente útil para métodos de validação.O seguinte método de validação testa o armazenamento em uma tentativa de salvar o modelo e relatórios de 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 ths ReferenceState instance "
  + "named '{1}' contains reference value '{2}' which is invalid";

Ações realizadas pela extensão do ModelBus

As informações a seguir não não essenciais, mas podem ser útil se você fizer o uso extensivo de ModelBus.

A extensão ModelBus faz as seguintes alterações em sua solução DSL.

Quando o botão direito do mouse o diagrama de definição de DSL, clique em Habilitar Modelbuse selecione Ativar essa DSL consumir o ModelBus:

  • No projeto DSL, uma referência é adicionada aoMicrosoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll

  • Na definição de DSL, uma referência de tipo externo é adicionada: Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

    Você pode ver a referência na Explorer DSL, em Tipos de domínio.Para adicionar 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.

Quando você definir o tipo de uma propriedade de domínio para ModelBusReference e, em seguida, a propriedade com o botão direito e clique em propriedades específicas de habilitar ModelBusReference:

  • Vários atributos do CLR são adicionados à propriedade de domínio.Você pode vê-los no campo atributos personalizados na janela Propriedades.Na 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")]

Quando você clique com botão direito do diagrama de definição de DSL, clique em Habilitar ModelBuse selecione expor essa DSL para o ModelBus:

  • Um novo projeto ModelBusAdapter é adicionado à solução.

  • Uma referência a ModelBusAdapter é adicionado para o DslPackage project.ModelBusAdaptertem uma referência para o Dsl project.

  • Na DslPackage\source.extention.tt, |ModelBusAdapter| é adicionado como um componente MEF.

Consulte também

Conceitos

Como: abrir um modelo de arquivo no código de programa

Como: integrar modelos UML com outras ferramentas e modelos

Como: adicionar um manipulador de arrastar-e-soltar

Usando o ModelBus de Visual Studio em um modelo de texto