Usando o ModelBus de Visual Studio em um modelo de texto

Artigo
02/25/2013

Se você escrever modelos de texto que ler um modelo que contém Visual Studio ModelBus faz referência, você pode desejar resolver as referências para acessar os modelos de destino.Nesse caso, você deve adaptar os modelos de texto e as linguagens específicas de domínio referenciadas (DSLs):

O que é o destino das referências DSL deve ter um adaptador de ModelBus que está configurado para acesso a partir de modelos de texto.Se você também pode acessar o DSL de outro código, o adaptador reconfigurado é necessário além do adaptador ModelBus padrão.

O Gerenciador de adaptador deve herdar de VsTextTemplatingModelingAdapterManager e deve ter o atributo [HostSpecific(HostName)].
O modelo deve herdar de ModelBusEnabledTextTransformation.

Observação
Se você quiser ler modelos DSL que não contenham referências ModelBus, você pode usar os processadores de diretriz que são gerados em seus projetos DSL.Para obter mais informações, consulte Acessando modelos a partir de modelos de texto.

Para obter mais informações sobre modelos de texto, consulte Geração de código de tempo de design usando modelos de texto T4.

Criando um modelo de adaptador de barramento para acesso a partir de modelos de texto

Para resolver uma referência de ModelBus em um modelo de texto, o DSL de destino deve ter um adaptador compatível.Modelos de texto executar em um AppDomain separado a partir do Visual Studio editores de documento e, portanto, o adaptador tem que carregar o modelo em vez de acessá-lo por meio de DTE.

Para criar um adaptador de ModelBus que seja compatível com os modelos de texto

Se a solução DSL de destino não tem um ModelBusAdapter de projeto, crie uma usando o Assistente de extensão Modelbus:
1. Baixe e instale o Visual Studio ModelBus de extensão, se você ainda não tiver feito isso.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, selecione desejo expor essa DSL para o ModelBus.Você pode selecionar 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. Clique em transformar todos os modelos de.
6. Recrie a solução.
Se você deseja acessar DSL a partir de um modelo de texto e de outros códigos, como comando, duplicar o ModelBusAdapter projeto:
1. No Windows Explorer, copie e cole a pasta que contém ModelBusAdapter.csproj.
2. Renomeie o arquivo de projeto (por exemplo, para T4ModelBusAdapter.csproj).
3. Em Solution Explorer, o botão direito do mouse no nó da solução, aponte para Adde, em seguida, clique em Projeto existente.Localize o novo projeto de adaptador, T4ModelBusAdapter.csproj.
4. Em cada *.tt arquivo do novo projeto, altere o namespace.
5. Clique com o botão direito no novo projeto no Solution Explorer e, em seguida, clique em Propriedades.No editor de propriedades, altere os nomes de assembly gerado e o namespace padrão.
6. No projeto DslPackage, adicione uma referência para o novo projeto de adaptador para que ele tenha referências aos dois adaptadores.
7. No DslPackage\source.extension.tt, adicione uma linha que faz referência a seu novo projeto do adaptador.
```
<MefComponent>|T4ModelBusAdapter|</MefComponent>
```
8. Transformar todos os modelos de e recompile a solução.Não há erros de compilação devem ocorrer.
No novo projeto do adaptador, adicione referências aos assemblies seguintes:
- Microsoft.VisualStudio.TextTemplating.11.0
  
  Microsoft.VisualStudio.TextTemplating.Modeling.11.0
No AdapterManager.tt:
- Alterar a declaração do AdapterManagerBase, para que ele herda de VsTextTemplatingModelingAdapterManager.
  
  public partial class <#= dslName =>AdapterManagerBase :
  
  Microsoft.VisualStudio.TextTemplating.Modeling.VsTextTemplatingModelingAdapterManager { ...
- Próximo ao final do arquivo, substitua o atributo de HostSpecific antes da classe AdapterManager.Remova a seguinte linha:
  
  [DslIntegration::HostSpecific(DslIntegrationShell::VsModelingAdapterManager.HostName)]
  
  Insira a seguinte linha:
  
  [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
  
  Este atributo filtra o conjunto de adaptadores que está disponível quando um consumidor modelbus procura por um adaptador.
Transformar todos os modelos de e recompile a solução.Não há erros de compilação devem ocorrer.

Escrever um modelo de texto que pode resolver referências de ModelBus

Normalmente, comece com um modelo que lê e gera arquivos de uma DSL de "origem".Este modelo usa a diretiva que é gerada no projeto DSL de origem para ler os arquivos de modelo de origem da maneira descrita no Acessando modelos a partir de modelos de texto.No entanto, a fonte de DSL contém referências de ModelBus como uma DSL "target".Portanto, você deseja ativar o código do modelo resolver as referências e acessar o destino DSL.Portanto você deve adaptar o modelo, seguindo estas etapas:

Alterar a classe base do modelo para ModelBusEnabledTextTransformation.
Incluir hostspecific="true" na diretriz de modelo.
Adicione referências de assembly para o destino DSL e o seu adaptador e para ativar o ModelBus.
Você não precisa a diretiva que é gerada como parte do destino DSL.

<#@ template debug="true" hostspecific="true" language="C#"
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 = "Company.TargetDsl.Dsl.dll" #>
<#@ assembly name = "Company.TargetDsl.T4ModelBusAdapter.dll" #>
<#@ assembly name = "System.Core" #>
<#@ import namespace="Microsoft.VisualStudio.Modeling.Integration" #>
<#@ import namespace="Company.TargetDsl" #>
<#@ import namespace="Company.TargetDsl.T4ModelBusAdapters" #>
<#@ import namespace="System.Linq" #>
<#
  SourceModelRoot source = this.ModelRoot; // Usual access to source model.
  // In the source DSL Definition, the root element has a model reference:
  using (TargetAdapter adapter = this.ModelBus.CreateAdapter(source.ModelReference) as TargetAdapter) 
  {if (adapter != null)
   {
      // Get the root of the target model:
      TargetRoot target = adapter.ModelRoot;
    // The source DSL Definition has a class "SourceElement" embedded under the root.
    // (Let’s assume they’re all in the same model file):
    foreach (SourceElement sourceElement in source.Elements)
    {
      // In the source DSL Definition, each SourceElement has a MBR property:
      ModelBusReference elementReference = sourceElement.ReferenceToTarget;
      // Resolve the target model element: 
      TargetElement element = adapter.ResolveElementReference<TargetElement>(elementReference); 
#>
     The source <#= sourceElement.Name #> is linked to: <#= element.Name #> in target model: <#= target.Name #>.
<#
    }
  }}
  // Other useful code: this.Host.ResolvePath(filename) gets an absolute filename 
  // from a path that is relative to the text template.
#>

Quando este modelo de texto é executado, o SourceDsl diretiva carrega o arquivo Sample.source.O modelo pode acessar os elementos de modelo, a partir de this.ModelRoot.O código pode usar as classes de domínio e propriedades dessa DSL.

Além disso, o modelo pode resolver referências de ModelBus.Onde as referências apontam para o modelo de destino, as diretivas de assembly permitem que o código use as classes de domínio e propriedades de DSL do modelo.

Se você não usar uma diretiva que é gerada por um projeto DSL, você também deve incluir o seguinte.

<#@ assembly name = "Microsoft.VisualStudio.Modeling.Sdk.11.0" #>
<#@ assembly name = "Microsoft.VisualStudio.TextTemplating.Modeling.11.0" #>

Use this.ModelBus para obter acesso para o ModelBus.

Passo a passo: Teste de um modelo de texto que usa ModelBus

Esta explicação passo a passo, execute as seguintes etapas:

Construa dois DSLs.Uma DSL, o consumidor, tem um ModelBusReference propriedade que pode se referir a DSL, o provedor.
Criar dois adaptadores de ModelBus no provedor: uma para o acesso pelos modelos de texto, outro para o código comum.
Crie modelos de instância das DSLs em um único projeto experimental.
Defina uma propriedade de domínio em um modelo para apontar para outro modelo.
Escreva um manipulador de clique duplo que abre o modelo que é apontado.
Escreva um modelo de texto que pode carregar o primeiro modelo, siga a referência a outro modelo e leia o outro modelo.

Construir uma DSL que seja acessível para ModelBus

Crie uma nova solução DSL.Neste exemplo, selecione o modelo de solução de fluxo de tarefas.Defina o nome do idioma para MBProvider e a extensão de nome de arquivo para ".provide".
No diagrama de definição de DSL, uma parte em branco do diagrama que não está na parte superior com o botão direito e clique em Habilitar Modelbus.
- Se você não vir Habilitar Modelbus, faça o download e instalar a extensão VMSDK ModelBus.Encontrá-lo no site da VMSDK: SDK de modelagem e visualização.
No Modelbus habilitar caixa de diálogo, selecione expor essa DSL para o ModelBuse, em seguida, clique em OK.

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

Agora você tem uma DSL que pode ser acessada pelos modelos de texto por meio de ModelBus.Referências a ele podem ser resolvidas no código de comandos, manipuladores de eventos ou regras, os quais operam no AppDomain do editor de arquivo do modelo.Entretanto, os modelos de texto executar em um AppDomain separado e não podem acessar um modelo quando ele está sendo editado.Se você desejar acessar referências de ModelBus a essa DSL de um modelo de texto, você deve ter um ModelBusAdapter separado.

Para criar um adaptador de ModelBus está configurado para modelos de texto

No Windows Explorer, copie e cole a pasta que contém ModelBusAdapter.csproj.

Nomeie a pasta T4ModelBusAdapter.

Renomeie o arquivo de projeto T4ModelBusAdapter.csproj.
No Solution Explorer, adicione T4ModelBusAdapter para a solução de MBProvider.Clique com o botão direito no nó da solução, aponte para Adde, em seguida, clique em Projeto existente.
Clique com o botão direito no nó do projeto T4ModelBusAdapter e, em seguida, clique em Propriedades.Na janela de propriedades do projeto, altere o Nome do Assembly e Namespace padrão para Company.MBProvider.T4ModelBusAdapters.
Em cada arquivo de *.tt no T4ModelBusAdapter, insira "T4" a última parte do namespace, para que a linha semelhante à seguinte.

namespace <#= CodeGenerationUtilities.GetPackageNamespace(this.Dsl) #>.T4ModelBusAdapters
No DslPackage de projeto, adicione uma referência ao T4ModelBusAdapter.
No DslPackage\source.extension.tt, adicione a seguinte linha em <Content>.

<MefComponent>|T4ModelBusAdapter|</MefComponent>
No T4ModelBusAdapter de projeto, adicione uma referência a:Microsoft.VisualStudio.TextTemplating.Modeling.11.0

Abra T4ModelBusAdapter\AdapterManager.tt:

Alterar a classe base de AdapterManagerBase para VsTextTemplatingModelingAdapterManager.Esta parte do arquivo agora é semelhante ao seguinte.

namespace <#= CodeGenerationUtilities.GetPackageNamespace(this.Dsl) #>.T4ModelBusAdapters
{
    /// <summary>
    /// Adapter manager base class (double derived pattern) for the <#= dslName #> Designer
    /// </summary>
    public partial class <#= dslName #>AdapterManagerBase 
    : Microsoft.VisualStudio.TextTemplating.Modeling.VsTextTemplatingModelingAdapterManager
    {

Próximo ao final do arquivo, insira o seguinte atributo adicional na frente da classe AdapterManager.

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

O resultado é semelhante ao seguinte.

    /// <summary>
    /// ModelBus modeling adapter manager for a <#= dslName #>Adapter model adapter
    /// </summary>
    [Mef::Export(typeof(DslIntegration::ModelBusAdapterManager))]
    [Mef::ExportMetadata(DslIntegration::CompositionAttributes.AdapterIdKey,<#= dslName #>Adapter.AdapterId)]
    [DslIntegration::HostSpecific(DslIntegrationShell::VsModelingAdapterManager.HostName)]
    [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
    public partial class <#= dslName #>AdapterManager : <#= dslName #>AdapterManagerBase
    {
    }

Clique em Transformar todos os modelos de na barra de título do Solution Explorer.
Recrie a solução.Clique em F5.
Verificar se o DSL está funcionando, pressionando F5.No projeto experimental, abra Sample.provider.Feche a instância experimental do Visual Studio.

Referências de ModelBus a essa DSL agora pode ser resolvidas em modelos de texto e também em código comum.

Construir uma DSL com uma propriedade de domínio de referência de ModelBus

Crie uma nova DSL usando o modelo de solução de idioma mínima.Nomeie a linguagem MBConsumer e definir a extensão de nome de arquivo para ".consume".
No projeto DSL, adicione uma referência ao assembly MBProvider DSL.Com o botão direito MBConsumer\Dsl\References e, em seguida, clique em Add Reference.No Procurar de tabulação, localizeMBProvider\Dsl\bin\Debug\Company.MBProvider.Dsl.dll

Isso permite que você crie o código que usa outro DSL.Se você quiser criar referências para diversas DSLs, adicioná-los também.
No diagrama de definição de DSL, clique com o botão direito do diagrama e, em seguida, clique em Habilitar ModelBus.Na caixa de diálogo, selecione Ativar essa DSL consumir o ModelBus.
Na classe ExampleElement, adicionar uma nova propriedade de domínio MBRe na janela Properties, defina seu tipo para ModelBusReference.
A propriedade de domínio no diagrama com o botão direito e, em seguida, clique em propriedades específicas de editar ModelBusReference.Na caixa de diálogo, selecione um elemento de modelo.

Defina o filtro de diálogo de arquivo para o seguinte.

Provider File|*.provide

A substring após "|" é um filtro para a caixa de diálogo de seleção de arquivo.Você pode configurá-lo para permitir que todos os arquivos usando *. *

No o tipo de elemento de modelo , digite os nomes de uma ou mais domínio classes no provedor DSL (por exemplo, Company.MBProvider.Task).Eles podem ser classes abstratas.Se você deixar a lista, o usuário pode definir a referência a qualquer elemento.
Feche a caixa de diálogo e Transformar todos os modelos de.

Você criou uma DSL que pode conter referências aos elementos em outro DSL.

Criar uma referência de ModelBus para outro arquivo na solução

Na solução de MBConsumer, pressione CTRL + F5.Uma instância experimental do Visual Studio abre na MBConsumer\Debugging project.
Adicionar uma cópia de Sample.provide para o MBConsumer\Debugging project.Isso é necessário porque uma referência de ModelBus deve se referir a um arquivo na mesma solução.
1. Clique com o botão direito no projeto de depuração, aponte para Adde, em seguida, clique em Item existente.
2. No Add Item caixa de diálogo, definir o filtro todos os arquivos (*. *).
3. Navegue até MBProvider\Debugging\Sample.provide e, em seguida, clique em Add.
Abra Sample.consume.
Clique em uma forma de exemplo e, em seguida, na janela Properties, clique em [...] na propriedade MBR.Na caixa de diálogo, clique em Procurar e selecione Sample.provide.Na janela de elementos, expanda o tipo de tarefa e selecione um dos elementos.
Salve o arquivo.

(Não feche ainda a instância experimental do Visual Studio.)

Você criou um modelo que contém uma referência de ModelBus a um elemento em outro modelo.

Resolver uma referência de ModelBus em um modelo de texto

Na instância experimental do Visual Studio, abra um arquivo de modelo de texto de exemplo.Defina o seu conteúdo como segue.

<#@ template debug="true" hostspecific="true" language="C#"
inherits="Microsoft.VisualStudio.TextTemplating.Modeling.ModelBusEnabledTextTransformation" #> 
<#@ MBConsumer processor="MBConsumerDirectiveProcessor" requires="fileName='Sample.consume'" #>
<#@ output extension=".txt" #>
<#@ assembly name = "Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0" #>
<#@ assembly name = "Company.MBProvider.Dsl.dll" #>
<#@ import namespace="Microsoft.VisualStudio.Modeling.Integration" #>
<#@ import namespace="Company.MBProvider" #>
<#
  // Property provided by the Consumer directive processor:
  ExampleModel consumerModel = this.ExampleModel; 
  // Iterate through Consumer model, listing the elements:
  foreach (ExampleElement element in consumerModel.Elements)
  {
#>
   <#= element.Name #> 
<#
    if (element.MBR != null)
  using (ModelBusAdapter adapter = this.ModelBus.CreateAdapter(element.MBR))
  { 
          // If we allowed multiple types or DSLs in the MBR, discover type here.
    Task task = adapter.ResolveElementReference<Task>(element.MBR);
#>
        <#= element.Name #> is linked to Task: <#= task==null ? "(null)" : task.Name #>
<#
      }
  }
#>

Observe os seguintes pontos:

O hostSpecific e inherits atributos da template diretiva deve ser definida.
O modelo de consumidor é acessado da maneira usual por meio do processador de diretriz que DSL foi gerado.
As diretivas de importação e o assembly devem ser capazes de acessar o ModelBus e os tipos do provedor DSL.
Se você sabe que muitos MBRs são vinculados ao mesmo modelo, é melhor chamar CreateAdapter apenas uma vez.

Salve o modelo.Verifique se o arquivo de texto resultante é semelhante ao seguinte.

   ExampleElement1 
   ExampleElement2 
        ExampleElement2 is linked to Task: Task2

Resolver uma referência de ModelBus em um manipulador de gesto

Feche a instância experimental do Visual Studio, se ele estiver sendo executado.

Adicione um arquivo chamado MBConsumer\Dsl\Custom.cs e definir seu conteúdo para o seguinte.



namespace Company.MB2Consume
{
  using Microsoft.VisualStudio.Modeling.Integration;
  using Company.MB3Provider;

  public partial class ExampleShape
  {
    public override void OnDoubleClick(Microsoft.VisualStudio.Modeling.Diagrams.DiagramPointEventArgs e)
    {
      base.OnDoubleClick(e);
      ExampleElement element = this.ModelElement as ExampleElement;
      if (element.MBR != null)
      {
        IModelBus modelbus = this.Store.GetService(typeof(SModelBus)) as IModelBus;
        using (ModelBusAdapter adapter = modelbus.CreateAdapter(element.MBR))
        {
          Task task = adapter.ResolveElementReference<Task>(element.MBR);
          // Open a window on this model:
          ModelBusView view = adapter.GetDefaultView();
          view.Show();
          view.SetSelection(element.MBR);
        }
      }
    }
  }
}

Pressione CTRL+F5.
Na instância experimental do Visual Studio, abra Debugging\Sample.consume.
Clique duas vezes em uma forma.

Se você tiver definido o MBR naquele elemento, o modelo de referência abre e o elemento referenciado é selecionado.

Consulte também

Conceitos

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

Modelos de texto T4 e de geração de código

Partilhar via