Usar ModelBus de Visual Studio en plantillas de textoUsing Visual Studio ModelBus in a Text Template

Si escribe plantillas de texto que lee un modelo que contenga Visual StudioVisual Studio hace referencia a ModelBus, desea resolver las referencias para tener acceso a los modelos de destino.If you write text templates that read a model that contains Visual StudioVisual Studio ModelBus references, you might want to resolve the references to access the target models. En ese caso, tendrá que adaptar las plantillas de texto y los que se hace referencia lenguajes específicos de dominio (DSL):In that case, you have to adapt the text templates and the referenced domain-specific languages (DSLs):

  • DSL que es el destino de las referencias debe tener un adaptador de ModelBus que está configurado para el acceso de las plantillas de texto.The DSL that is the target of the references must have a ModelBus Adapter that is configured for access from text templates. Si también tiene acceso DSL desde otro código, el adaptador ha vuelto a configurar sea necesario además del adaptador ModelBus estándar.If you also access the DSL from other code, the reconfigured adapter is required in addition to the standard ModelBus Adapter.

    El Administrador de adaptador debe heredar de VsTextTemplatingModelingAdapterManager y debe tener el atributo [HostSpecific(HostName)].The adapter manager must inherit from VsTextTemplatingModelingAdapterManager and must have the attribute [HostSpecific(HostName)].

  • La plantilla debe heredar de ModelBusEnabledTextTransformation.The template must inherit from ModelBusEnabledTextTransformation.

Nota

Si desea leer modelos DSL que no contienen referencias de ModelBus, puede usar los procesadores de directivas que se generan en los proyectos DSL.If you want to read DSL models that do not contain ModelBus references, you can use the directive processors that are generated in your DSL projects. Para obtener más información, consulte modelos de acceso a partir de plantillas de texto.For more information, see Accessing Models from Text Templates.

Para obtener más información acerca de las plantillas de texto, consulte generación de código en tiempo de diseño mediante el uso de plantillas de texto T4.For more information about text templates, see Design-Time Code Generation by using T4 Text Templates.

Crear un adaptador de Bus de modelo para el acceso de las plantillas de textoCreating a Model Bus Adapter for Access from Text Templates

Para resolver una referencia de ModelBus en una plantilla de texto, el destino DSL debe tener un adaptador compatible.To resolve a ModelBus reference in a text template, the target DSL must have a compatible adapter. Plantillas de texto que se ejecutan en un AppDomain independiente desde el Visual StudioVisual Studio editores de documento y, por lo tanto, el adaptador debe cargar el modelo en lugar de tener acceso a ella a través de DTE.Text templates execute in a separate AppDomain from the Visual StudioVisual Studio document editors, and therefore the adapter has to load the model instead of accessing it through DTE.

Para crear un adaptador ModelBus que sea compatible con las plantillas de textoTo create a ModelBus Adapter that is compatible with text templates

  1. Si la solución DSL de destino no tiene un ModelBusAdapter del proyecto, cree uno mediante el Asistente para la Modelbus extensión:If the target DSL solution does not have a ModelBusAdapter project, create one by using the Modelbus Extension wizard:

    1. Descargue e instale el Visual StudioVisual Studio ModelBus de extensión, si aún no lo ha hecho.Download and install the Visual StudioVisual Studio ModelBus Extension, if you have not already done this. Para obtener más información, consulte SDK de visualización y modelado.For more information, see Visualization and Modeling SDK.

    2. Abra el archivo de definición de DSL.Open the DSL definition file. Haga clic en la superficie de diseño y, a continuación, haga clic en habilitar Modelbus.Right-click the design surface and then click Enable Modelbus.

    3. En el cuadro de diálogo, seleccione desea exponer este DSL para el ModelBus.In the dialog box, select I want to expose this DSL to the ModelBus. Puede seleccionar ambas opciones si desea que este DSL para exponer sus modelos y usar referencias a otros lenguajes DSL.You can select both options if you want this DSL both to expose its models and to consume references to other DSLs.

    4. Haga clic en Aceptar.Click OK. Se agrega un nuevo proyecto "ModelBusAdapter" a la solución de DSL.A new project "ModelBusAdapter" is added to the DSL solution.

    5. Haga clic en Transformar todas las plantillas de.Click Transform All Templates.

    6. Recompilar la solución.Rebuild the solution.

  2. Si desea obtener acceso a DSL desde una plantilla de texto y del resto del código, por ejemplo, comando, duplicar el ModelBusAdapter proyecto:If you want to access the DSL both from a text template and from other code, such as command, duplicate the ModelBusAdapter project:

    1. En el Explorador de Windows, copie y pegue la carpeta que contiene ModelBusAdapter.csproj.In Windows Explorer, copy and paste the folder that contains ModelBusAdapter.csproj.

    2. Cambiar el nombre de archivo del proyecto (por ejemplo, para T4ModelBusAdapter.csproj).Rename the project file (for example, to T4ModelBusAdapter.csproj).

    3. En el Explorador de soluciones, haga clic en el nodo de soluciones, seleccione agregary, a continuación, haga clic en proyecto existente.In Solution Explorer, right-click the solution node, point to Add, and then click Existing Project. Busque el nuevo proyecto de adaptador, T4ModelBusAdapter.csproj.Locate the new adapter project, T4ModelBusAdapter.csproj.

    4. En cada uno de ellos *.tt archivo del nuevo proyecto, cambie el espacio de nombres.In each *.tt file of the new project, change the namespace.

    5. Haga clic en el nuevo proyecto en el Explorador de soluciones y, a continuación, haga clic en Propiedades.Right-click the new project in Solution Explorer and then click Properties. En el editor de propiedades, cambie los nombres de ensamblado generado y el espacio de nombres predeterminado.In the properties editor, change the names of the generated assembly and the default namespace.

    6. En el proyecto DslPackage, agregue una referencia al nuevo proyecto de adaptador para que tenga las referencias a ambos adaptadores.In the DslPackage project, add a reference to the new adapter project so that it has references to both adapters.

    7. En DslPackage\source.extension.tt, agregue una línea que hace referencia a su nuevo proyecto de adaptador.In DslPackage\source.extension.tt, add a line that references your new adapter project.

      <MefComponent>|T4ModelBusAdapter|</MefComponent>
      
    8. Transformar todas las plantillas y recompile la solución.Transform All Templates and rebuild the solution. No debería producirse ningún error de compilación.No build errors should occur.

  3. En el nuevo proyecto de adaptador, agregue referencias a los ensamblados siguientes:In the new adapter project, add references to the following assemblies:

    • Microsoft.VisualStudio.TextTemplating.11.0Microsoft.VisualStudio.TextTemplating.11.0

      Microsoft.VisualStudio.TextTemplating.Modeling.11.0Microsoft.VisualStudio.TextTemplating.Modeling.11.0

  4. En AdapterManager.tt:In AdapterManager.tt:

    • Cambie la declaración de AdapterManagerBase para que herede de VsTextTemplatingModelingAdapterManager.Change the declaration of AdapterManagerBase so that it inherits from VsTextTemplatingModelingAdapterManager.

      public partial class <#= dslName =>AdapterManagerBase :

      Microsoft.VisualStudio.TextTemplating.Modeling.VsTextTemplatingModelingAdapterManager { ...

    • Casi al final del archivo, reemplace el atributo HostSpecific antes de la clase AdapterManager.Near the end of the file, replace the HostSpecific attribute before the AdapterManager class. Quite la línea siguiente:Remove the following line:

      [DslIntegration::HostSpecific(DslIntegrationShell::VsModelingAdapterManager.HostName)]

      Inserte la siguiente línea:Insert the following line:

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

      Este atributo filtra el conjunto de adaptadores que está disponible cuando un consumidor de modelbus busca un adaptador.This attribute filters the set of adapters that is available when a modelbus consumer searches for an adapter.

  5. Transformar todas las plantillas y recompile la solución.Transform All Templates and rebuild the solution. No debería producirse ningún error de compilación.No build errors should occur.

Escribir una plantilla de texto que puede resolver las referencias a ModelBusWriting a Text Template That Can Resolve ModelBus References

Normalmente, comenzar con una plantilla que lee y genera los archivos de un "origen" ADSL.Typically, you begin with a template that reads and generates files from a "source" DSL. Esta plantilla usa la directiva que se genera en el proyecto DSL de origen para leer archivos de modelo de código fuente de la manera que se describe en modelos de acceso a partir de plantillas de texto.This template uses the directive that is generated in the source DSL project to read source model files in the manner that is described in Accessing Models from Text Templates. Sin embargo, el origen de DSL contiene referencias de ModelBus a un DSL "destino".However, the source DSL contains ModelBus References to a "target" DSL. Por lo tanto, desea habilitar el código de plantilla resolver las referencias y tener acceso al destino ADSL.You therefore want to enable the template code to resolve the references and access the target DSL. Por lo tanto debe adaptar la plantilla, siga estos pasos:You therefore must adapt the template by following these steps:

  • Cambie la clase base de la plantilla para ModelBusEnabledTextTransformation.Change the base class of the template to ModelBusEnabledTextTransformation.

  • Incluir hostspecific="true" en la directiva de plantilla.Include hostspecific="true" in the template directive.

  • Agregar referencias de ensamblado para el destino de DSL y su adaptador y habilitar ModelBus.Add assembly references to the target DSL and its adapter, and to enable ModelBus.

  • No necesita la directiva que se genera como parte del destino ADSL.You do not need the directive that is generated as part of the target 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.
#>

Cuando se ejecuta esta plantilla de texto, el SourceDsl directiva carga el archivo Sample.source.When this text template is executed, the SourceDsl directive loads the file Sample.source. La plantilla puede tener acceso a los elementos de ese modelo, a partir de this.ModelRoot.The template can access the elements of that model, starting from this.ModelRoot. El código puede usar las clases de dominio y propiedades de ese DSL.The code can use the domain classes and properties of that DSL.

Además, la plantilla puede resolver las referencias de ModelBus.In addition, the template can resolve ModelBus References. Cuando las referencias del puntero en el modelo de destino, las directivas de ensamblado dejar que el código utiliza las clases de dominio y propiedades de DSL de ese modelo.Where the references point to the Target model, the assembly directives let the code use the domain classes and properties of that model's DSL.

  • Si no usa una directiva que se genera un proyecto de DSL, también debe incluir lo siguiente.If you do not use a directive that is generated by a DSL project, you should also include the following.

    <#@ assembly name = "Microsoft.VisualStudio.Modeling.Sdk.11.0" #>
    <#@ assembly name = "Microsoft.VisualStudio.TextTemplating.Modeling.11.0" #>
    
  • Use this.ModelBus para obtener acceso a ModelBus de la.Use this.ModelBus to obtain access to the ModelBus.

Tutorial: Probar una plantilla de texto que usa ModelBusWalkthrough: Testing a Text Template That Uses ModelBus

En este tutorial, siga estos pasos:In this walkthrough, you follow these steps:

  1. Cree dos DSL.Construct two DSLs. Un DSL, el consumidor, tiene un ModelBusReference propiedad que puede hacer referencia a la línea ADSL, el proveedor.One DSL, the Consumer, has a ModelBusReference property that can refer to the other DSL, the Provider.

  2. Crear dos adaptadores de ModelBus en el proveedor: uno para el acceso mediante plantillas de texto, el otro código normal.Create two ModelBus Adapters in the Provider: one for access by text templates, the other for ordinary code.

  3. Crear modelos de la instancia de la DSL en un solo proyecto experimental.Create instance models of the DSLs in a single experimental project.

  4. Establecer una propiedad de dominio en un modelo para que señale a otro modelo.Set a domain property in one model to point to the other model.

  5. Escribir un controlador de doble clic que se abre el modelo que apunta.Write a double-click handler that opens the model that is pointed to.

  6. Escribir una plantilla de texto que se puede cargar el primer modelo, siga la referencia al otro modelo y leer el otro modelo.Write a text template that can load the first model, follow the reference to the other model, and read the other model.

Un DSL que tenga acceso a ModelBus de construcciónConstruct a DSL that is accessible to ModelBus

  1. Cree una nueva solución DSL.Create a new DSL solution. En este ejemplo, seleccione la plantilla de solución de flujo de tareas.For this example, select the Task Flow solution template. Establece el nombre del idioma en MBProvider y la extensión de nombre de archivo a ".provide".Set the language name to MBProvider and the file name extension to ".provide".

  2. En el diagrama de definición DSL, haga clic en una parte en blanco del diagrama que no está en la parte superior y, a continuación, haga clic en habilitar Modelbus.In the DSL Definition diagram, right-click a blank part of the diagram that is not near the top, and then click Enable Modelbus.

  3. En el habilitar Modelbus cuadro de diálogo, seleccione exponer este DSL para el ModelBusy, a continuación, haga clic en Aceptar.In the Enable Modelbus dialog box, select Expose this DSL to the ModelBus, and then click OK.

    Un nuevo proyecto, ModelBusAdapter, se agrega a la solución.A new project, ModelBusAdapter, is added to the solution.

    Ahora tiene un DSL que puede tener acceso a las plantillas de texto a través de ModelBus.You now have a DSL that can be accessed by text templates through ModelBus. Las referencias a él pueden resolverse en el código de comandos, controladores de eventos o reglas, todos ellos funcionan en el AppDomain del editor de archivos de modelo.References to it can be resolved in the code of commands, event handlers, or rules, all of which operate in the AppDomain of the model file editor. Sin embargo, las plantillas de texto se ejecutan en un AppDomain independiente y no pueden tener acceso a un modelo cuando se está editando.However, text templates run in a separate AppDomain and cannot access a model when it is being edited. Si desea tener acceso a ModelBus referencias a este DSL desde una plantilla de texto, debe tener un ModelBusAdapter independiente.If you want to access ModelBus references to this DSL from a text template, you must have a separate ModelBusAdapter.

Para crear un adaptador ModelBus que esté configurado para las plantillas de textoTo create a ModelBus Adapter that is configured for Text Templates

  1. En el Explorador de Windows, copie y pegue la carpeta que contiene ModelBusAdapter.csproj.In Windows Explorer, copy and paste the folder that contains ModelBusAdapter.csproj.

    Nombre de la carpeta T4ModelBusAdapter.Name the folder T4ModelBusAdapter.

    Cambie el nombre del archivo de proyecto T4ModelBusAdapter.csproj.Rename the project file T4ModelBusAdapter.csproj.

  2. En el Explorador de soluciones, agregue T4ModelBusAdapter a la solución MBProvider.In Solution Explorer, add T4ModelBusAdapter to the MBProvider solution. Haga clic en el nodo de soluciones, seleccione agregary, a continuación, haga clic en proyecto existente.Right-click the solution node, point to Add, and then click Existing Project.

  3. Haga clic en el nodo del proyecto T4ModelBusAdapter y, a continuación, haga clic en Propiedades.Right-click the T4ModelBusAdapter project node and then click Properties. En la ventana de propiedades del proyecto, cambie la nombre de ensamblado y Default Namespace a Company.MBProvider.T4ModelBusAdapters.In the project properties window, change the Assembly Name and Default Namespace to Company.MBProvider.T4ModelBusAdapters.

  4. En cada archivo *.tt T4ModelBusAdapter, inserte "T4" en la última parte del espacio de nombres, por lo que la línea es similar al siguiente.In each *.tt file in T4ModelBusAdapter, insert "T4" into the last part of the namespace, so that the line resembles the following.

    namespace <#= CodeGenerationUtilities.GetPackageNamespace(this.Dsl) #>.T4ModelBusAdapters

  5. En el DslPackage del proyecto, agregue una referencia de proyecto T4ModelBusAdapter.In the DslPackage project, add a project reference to T4ModelBusAdapter.

  6. En DslPackage\source.extension.tt, agregue la siguiente línea en <Content>.In DslPackage\source.extension.tt, add the following line under <Content>.

    <MefComponent>|T4ModelBusAdapter|</MefComponent>

  7. En el T4ModelBusAdapter del proyecto, agregue una referencia a: Microsoft.VisualStudio.TextTemplating.Modeling.11.0In the T4ModelBusAdapter project, add a reference to: Microsoft.VisualStudio.TextTemplating.Modeling.11.0

  8. Abra T4ModelBusAdapter\AdapterManager.tt:Open T4ModelBusAdapter\AdapterManager.tt:

    1. Cambie la clase base de AdapterManagerBase por VsTextTemplatingModelingAdapterManager.Change the base class of AdapterManagerBase to VsTextTemplatingModelingAdapterManager. Esta parte del archivo ahora es similar al siguiente.This part of the file now resembles the following.

      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
          {
      
    2. Casi al final del archivo, inserte el siguiente atributo adicional delante de la clase AdapterManager.Near the end of the file, insert the following additional attribute in front of class AdapterManager.

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

      El resultado es similar al siguiente.The result resembles the following.

      /// <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
      {
      }
      
  9. Haga clic en Transformar todas las plantillas en la barra de título de solución de explorador.Click Transform All Templates in the title bar of Solution Explorer.

  10. Recompilar la solución.Rebuild the solution. Haga clic en F5.Click F5.

  11. Compruebe que funciona la DSL presionando F5.Verify that the DSL is working by pressing F5. En el proyecto experimental, abra Sample.provider.In the experimental project, open Sample.provider. Cierre la instancia experimental de Visual StudioVisual Studio.Close the experimental instance of Visual StudioVisual Studio.

    Ahora se puede resolver las referencias de ModelBus a este DSL en plantillas de texto y también en código normal.ModelBus References to this DSL can now be resolved in text templates and also in ordinary code.

Construir un DSL con una propiedad de dominio de referencia de ModelBusConstruct a DSL with a ModelBus Reference domain property

  1. Crear un nuevo DSL mediante la plantilla de solución de lenguaje mínima.Create a new DSL by using the Minimal Language solution template. Nombre del idioma MBConsumer y establezca la extensión de nombre de archivo a ".consume".Name the language MBConsumer and set the file name extension to ".consume".

  2. En el proyecto ADSL, agregue una referencia al ensamblado MBProvider DSL.In the DSL project, add a reference to the MBProvider DSL assembly. Haga clic en MBConsumer\Dsl\References y, a continuación, haga clic en Agregar referencia.Right-click MBConsumer\Dsl\References and then click Add Reference. En el examinar ficha, busque MBProvider\Dsl\bin\Debug\Company.MBProvider.Dsl.dllIn the Browse tab, locate MBProvider\Dsl\bin\Debug\Company.MBProvider.Dsl.dll

    Esto le permite crear código que utilice otra DSL.This enables you to create code that uses the other DSL. Si desea crear las referencias a varias DSL, agréguela también.If you want to create references to several DSLs, add them also.

  3. En el diagrama de definición DSL, haga clic en el diagrama y, a continuación, haga clic en habilitar ModelBus.In the DSL Definition diagram, right-click the diagram and then click Enable ModelBus. En el cuadro de diálogo, seleccione habilitar este DSL consumir el ModelBus.In the dialog box, select Enable this DSL to Consume the ModelBus.

  4. En la clase ExampleElement, agregar una nueva propiedad de dominio MBRy en la ventana Propiedades, establezca su tipo en ModelBusReference.In the class ExampleElement, add a new domain property MBR, and in the Properties window, set its type to ModelBusReference.

  5. Haga clic en la propiedad de dominio en el diagrama y, a continuación, haga clic en propiedades específicas de editar ModelBusReference.Right-click the domain property on the diagram and then click Edit ModelBusReference specific properties. En el cuadro de diálogo, seleccione un elemento del modelo.In the dialog box, select a model element.

    Establezca el filtro de cuadro de diálogo de archivo a la siguiente.Set the file dialog filter to the following.

    Provider File|*.provide

    La subcadena después de "|" es un filtro para el cuadro de diálogo de selección de archivos.The substring after "|" is a filter for the file selection dialog box. Puede establecer para permitir que los archivos mediante el uso de *.*You could set it to allow any files by using *.*

    En el tipo de elemento de modelo lista, escriba los nombres de uno o más dominios clases en el proveedor de DSL (por ejemplo, Company.MBProvider.Task).In the Model Element type list, enter the names of one ore more domain classes in the provider DSL (for example, Company.MBProvider.Task). Pueden ser clases abstractas.They can be abstract classes. Si deja en blanco la lista, el usuario puede establecer la referencia a cualquier elemento.If you leave the list blank, the user can set the reference to any element.

  6. Cierre el cuadro de diálogo y Transformar todas las plantillas.Close the dialog and Transform All Templates.

    Ha creado un DSL que puede contener referencias a los elementos de otro ADSL.You have created a DSL that can contain references to elements in another DSL.

Crear una referencia de ModelBus a otro archivo en la soluciónCreate a ModelBus reference to another file in the solution

  1. En la solución MBConsumer, presione CTRL + F5.In the MBConsumer solution, press CTRL+F5. Una instancia experimental de Visual StudioVisual Studio se abre en el MBConsumer\Debugging proyecto.An experimental instance of Visual StudioVisual Studio opens in the MBConsumer\Debugging project.

  2. Agregar una copia de Sample.provide a la MBConsumer\Debugging proyecto.Add a copy of Sample.provide to the MBConsumer\Debugging project. Esto es necesario porque una referencia de ModelBus debe hacer referencia a un archivo en la misma solución.This is necessary because a ModelBus reference must refer to a file in the same solution.

    1. Haga clic en el proyecto de depuración, seleccione agregary, a continuación, haga clic en elemento existente.Right-click the Debugging project, point to Add, and then click Existing Item.

    2. En el Agregar elemento cuadro de diálogo, establezca el filtro en todos los archivos (*.*) .In the Add Item dialog, set the filter to All Files (*.*).

    3. Vaya a MBProvider\Debugging\Sample.provide y, a continuación, haga clic en agregar.Navigate to MBProvider\Debugging\Sample.provide and then click Add.

  3. Abra Sample.consume.Open Sample.consume.

  4. Haga clic en una forma de ejemplo y en la ventana Propiedades, haga clic en [...] en la propiedad MBR.Click one example shape, and in the Properties window, click [...] in the MBR property. En el cuadro de diálogo, haga clic en examinar y seleccione Sample.provide.In the dialog box, click Browse and select Sample.provide. En la ventana de elementos, expanda el tipo de tarea y seleccione uno de los elementos.In the elements window, expand the type Task and select one of the elements.

  5. Guarde el archivo.Save the file.

    (No cierre todavía la instancia experimental de Visual StudioVisual Studio.)(Do not yet close the experimental instance of Visual StudioVisual Studio.)

    Ha creado un modelo que contiene una referencia de ModelBus a un elemento de otro modelo.You have created a model that contains a ModelBus reference to an element in another model.

Resolver una referencia de ModelBus en una plantilla de textoResolve a ModelBus Reference in a text template

  1. En la instancia experimental de Visual StudioVisual Studio, abra un archivo de plantilla de texto de ejemplo.In the experimental instance of Visual StudioVisual Studio, open a sample text template file. Establezca su contenido como se indica a continuación.Set its content as follows.

    <#@ 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 #>
    <#
          }
      }
    #>
    

    Tenga en cuenta los puntos siguientes:Notice the following points:

    1. El hostSpecific y inherits atributos de la template se debe establecer la directiva.The hostSpecific and inherits attributes of the template directive must be set.

    2. El modelo de consumidor se tiene acceso de la manera habitual mediante el procesador de directivas que se generó en ese DSL.The consumer model is accessed in the usual manner through the directive processor that was generated in that DSL.

    3. Las directivas de ensamblado e importación deben poder tener acceso a ModelBus y los tipos de proveedor de DSL.The assembly and import directives must be able to access ModelBus and the types of the provider DSL.

    4. Si sabe que muchos MBR se relacionan con el mismo modelo, es mejor llamar a CreateAdapter solo una vez.If you know that many MBRs are linked to the same model, it is better to call CreateAdapter only one time.

  2. Guarde la plantilla.Save the template. Compruebe que el archivo de texto resultante es similar al siguiente.Verify that the resulting text file resembles the following.

    
    ExampleElement1
    ExampleElement2
         ExampleElement2 is linked to Task: Task2
    

Resolver una referencia de ModelBus en un controlador de gestosResolve a ModelBus reference in a gesture handler

  1. Cierre la instancia experimental de Visual StudioVisual Studio, si se está ejecutando.Close the experimental instance of Visual StudioVisual Studio, if it is running.

  2. Agregue un archivo denominado MBConsumer\Dsl\Custom.cs y establezca su contenido en el siguiente.Add a file that is named MBConsumer\Dsl\Custom.cs and set its content to the following.

    
    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);
            }
          }
        }
      }
    }
    
  3. Presione CTRL+F5.Press CTRL+F5.

  4. En la instancia experimental de Visual StudioVisual Studio, abra Debugging\Sample.consume.In the experimental instance of Visual StudioVisual Studio, open Debugging\Sample.consume.

  5. Haga doble clic en una forma.Double-click one shape.

    Si ha configurado el MBR en ese elemento, el modelo que se hace referencia se abre y se selecciona el elemento que se hace referencia.If you have set the MBR on that element, the referenced model opens and the referenced element is selected.

Vea tambiénSee Also

Nota

En Visual Studio de 2017, el SDK de transformación de plantilla de texto y el SDK de modelado de Visual Studio se instalan automáticamente al instalar características específicas de Visual Studio.In Visual Studio 2017, the Text Template Transformation SDK and the Visual Studio Modeling SDK are installed automatically when you install specific features of Visual Studio. Para obtener más información, consulte esta entrada de blog.For more details, see this blog post.