Bagikan melalui

Menggunakan Visual Studio ModelBus dalam Templat Teks

Jika Anda menulis templat teks yang membaca model yang berisi Visual Studio referensi ModelBus, Anda mungkin ingin menyelesaikan referensi untuk mengakses model target. Dalam hal ini, Anda harus menyesuaikan templat teks dan bahasa khusus domain (DSL) yang dirujuk:

  • DSL yang merupakan target referensi harus memiliki Adaptor ModelBus yang dikonfigurasi untuk akses dari templat teks. Jika Anda juga mengakses DSL dari kode lain, adaptor yang dikonfigurasi ulang diperlukan selain Adaptor ModelBus standar.

    Manajer adaptor harus mewarisi dari VsTextTemplatingModelingAdapterManager dan harus memiliki atribut [HostSpecific(HostName)].

  • Templat harus mewarisi dari ModelBusEnabledTextTransformation.

Catatan

Jika Anda ingin membaca model DSL yang tidak berisi referensi ModelBus, Anda dapat menggunakan prosesor direktif yang dihasilkan dalam proyek DSL Anda. Untuk informasi selengkapnya, lihat Mengakses Model dari Templat Teks.

Untuk informasi selengkapnya, lihat Pembuatan Kode Design-Time dengan menggunakan Templat Teks T4.

Membuat Adaptor Bus Model untuk Akses dari Templat Teks

Untuk mengatasi referensi ModelBus dalam templat teks, DSL target harus memiliki adaptor yang kompatibel. Templat teks dijalankan di AppDomain terpisah dari editor dokumen Visual Studio, dan oleh karena itu adaptor harus memuat model alih-alih mengaksesnya melalui DTE.

  1. Jika solusi DSL target tidak memiliki proyek ModelBusAdapter, buat dengan menggunakan wizard Ekstensi Modelbus:

    1. Unduh dan instal Ekstensi ModelBus Visual Studio, jika Anda belum melakukan ini. Untuk informasi selengkapnya, lihat Visualisasi dan Pemodelan SDK.

    2. Buka file Definisi DSL. Klik kanan permukaan desain, kemudian klik Aktifkan Modelbus.

    3. Dalam kotak dialog, pilih Saya ingin mengekspos DSL ini ke ModelBus. Anda dapat memilih kedua opsi jika Anda ingin DSL ini mengekspos modelnya dan menggunakan referensi ke DLL lain.

    4. Klik OK. Proyek baru "ModelBusAdapter" ditambahkan ke solusi DSL.

    5. Klik Transformasi Semua Templat.

    6. Bangun kembali solusinya.

  2. Jika Anda ingin mengakses DSL baik dari templat teks maupun dari kode lain, seperti perintah, duplikat proyek ModelBusAdapter :

    1. Di Windows Explorer, salin dan tempel folder yang berisi ModelBusAdapter.csproj.

    2. Ganti nama file proyek (misalnya, menjadi T4ModelBusAdapter.csproj).

    3. Di Penjelajah Solusi, klik kanan simpul solusi, arahkan ke Tambahkan, lalu klik Project yang Sudah Ada. Temukan proyek adaptor baru, T4ModelBusAdapter.csproj.

    4. Di setiap *.tt file proyek baru, ubah namespace layanan.

    5. Klik kanan proyek di Penjelajah Solusi lalu klik Properti. Di editor properti, ubah nama assembly yang dihasilkan dan namespace default.

    6. Dalam proyek DslPackage, tambahkan referensi ke proyek adaptor baru sehingga memiliki referensi ke kedua adaptor.

    7. Di DslPackage\source.extension.tt, tambahkan baris yang mereferensikan proyek adaptor baru Anda.

      <MefComponent>|T4ModelBusAdapter|</MefComponent>

    8. Ubah Semua Templat dan bangun kembali solusinya. Tidak ada kesalahan build yang harus terjadi.

  3. Dalam proyek adaptor baru, tambahkan referensi ke rakitan berikut:

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

  4. Dalam AdapterManager.tt:

    • Ubah deklarasi AdapterManagerBase sehingga mewarisi dari VsTextTemplatingModelingAdapterManager.

      public partial class <#= dslName =>AdapterManagerBase :

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

    • Di dekat akhir file, ganti atribut HostSpecific sebelum kelas AdapterManager. Hapus baris berikut:

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

      Hapus baris berikut:

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

      Atribut ini memfilter set adaptor yang tersedia saat konsumen modelbus mencari adaptor.

  5. Ubah Semua Templat dan bangun kembali solusinya. Tidak ada kesalahan build yang harus terjadi.

Menulis Templat Teks yang Dapat Mengatasi Referensi ModelBus

Biasanya, Anda mulai dengan templat yang membaca dan menghasilkan file dari DSL "sumber". Templat ini menggunakan direktif yang dihasilkan dalam proyek DSL sumber untuk membaca file model sumber dengan cara yang dijelaskan dalam Mengakses Model dari Templat Teks. Namun, DSL sumber berisi Referensi ModelBus ke DSL "target". Oleh karena itu, Anda ingin mengaktifkan kode templat untuk menyelesaikan referensi dan mengakses DSL target. Oleh karena itu, Anda harus menyesuaikan templat dengan mengikuti langkah-langkah berikut:

  • Ubah kelas dasar templat menjadi ModelBusEnabledTextTransformation.

  • Sertakan hostspecific="true" dalam direktif templat.

  • Tambahkan referensi rakitan ke DSL target dan adaptornya, dan untuk mengaktifkan ModelBus.

  • Anda tidak memerlukan direktif yang dihasilkan sebagai bagian dari DSL target.

<#@ 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 an 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.
#>

Ketika templat teks ini dijalankan, direktif SourceDsl memuat file Sample.source. Templat dapat mengakses elemen model tersebut, mulai dari this.ModelRoot. Kode dapat menggunakan kelas domain dan properti DSL tersebut.

Selain itu, templat dapat mengatasi Referensi ModelBus. Jika referensi menunjuk ke model Target, arahan perakitan memungkinkan kode menggunakan kelas domain dan properti DSL model tersebut.

  • Jika Anda tidak menggunakan direktif yang dihasilkan oleh proyek DSL, Anda juga harus menyertakan yang berikut ini.

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

  • Gunakan this.ModelBus untuk mendapatkan akses ke ModelBus.

Panduan: Menguji Templat Teks yang Menggunakan ModelBus

Dalam panduan ini, Anda mengikuti langkah-langkah berikut:

  1. Buat dua DLL. Satu DSL, Konsumen, memiliki ModelBusReference properti yang dapat merujuk ke DSL lainnya, Penyedia.

  2. Buat dua Adaptor ModelBus di Penyedia: satu untuk akses menurut templat teks, yang lain untuk kode biasa.

  3. Buat model instans DLL dalam satu proyek eksperimental.

  4. Atur properti domain dalam satu model untuk menunjuk ke model lain.

  5. Tulis handler klik ganda yang membuka model yang diarahkan.

  6. Tulis templat teks yang dapat memuat model pertama, ikuti referensi ke model lain, dan baca model lainnya.

Membuat DSL yang dapat diakses oleh ModelBus

  1. Membuat Solusi Bahasa Khusus Domain Untuk contoh ini, pilih templat solusi Flow Tugas. Atur nama bahasa ke MBProvider dan ekstensi nama file ke ".provide".

  2. Dalam diagram Definisi DSL, klik kanan bagian kosong diagram yang tidak berada di dekat bagian atas, lalu klik Aktifkan Modelbus.

    Jika Anda tidak melihat Aktifkan Modelbus, unduh dan instal ekstensi ModelBus VMSDK.

  3. Dalam kotak dialog Aktifkan Modelbus, pilih Ekspos DSL ini ke ModelBus, lalu klik OK.

    Proyek baru, ModelBusAdapter, ditambahkan ke solusi.

Anda sekarang memiliki DSL yang dapat diakses oleh templat teks melalui ModelBus. Referensi ke dalamnya dapat diselesaikan dalam kode perintah, penanganan aktivitas, atau aturan, yang semuanya beroperasi di AppDomain editor file model. Namun, templat teks berjalan di AppDomain terpisah dan tidak dapat mengakses model saat sedang diedit. Jika Anda ingin mengakses referensi ModelBus ke DSL ini dari templat teks, Anda harus memiliki ModelBusAdapter terpisah.

Membuat Adaptor ModelBus yang dikonfigurasi untuk Templat Teks

  1. Di Windows Explorer, salin dan tempel folder yang berisi ModelBusAdapter.csproj.

    Beri nama folder T4ModelBusAdapter.

    Ganti nama file proyek T4ModelBusAdapter.csproj.

  2. Di Penjelajah Solusi, tambahkan T4ModelBusAdapter ke solusi MBProvider. Klik kanan simpul solusi, arahkan ke Tambahkan, lalu klik Project yang Sudah Ada.

  3. Klik kanan node proyek T4ModelBusAdapter dan kemudian klik Properti. Di jendela properti proyek, ubah Nama Rakitan dan Namespace Default menjadi Company.MBProvider.T4ModelBusAdapters.

  4. Di setiap file *.tt di T4ModelBusAdapter, sisipkan "T4" ke bagian terakhir namespace layanan, sehingga baris menyerupan berikut ini.

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

  5. Dalam DslPackage proyek, tambahkan referensi proyek ke T4ModelBusAdapter.

  6. Di DslPackage\source.extension.tt, tambahkan baris berikut di bawah <Content>.

    <MefComponent>|T4ModelBusAdapter|</MefComponent>

  7. Dalam T4ModelBusAdapter proyek, tambahkan referensi ke: Microsoft.VisualStudio.TextTemplating.Modeling.11.0

  8. Open T4ModelBusAdapter\AdapterManager.tt:

    1. Ubah kelas dasar AdapterManagerBase menjadi VsTextTemplatingModelingAdapterManager. Bagian file ini sekarang menyerupai berikut ini.

      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. Di dekat akhir file, sisipkan atribut tambahan berikut di depan kelas AdapterManager.

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

      Hasilnya menyerupan berikut ini.

      /// <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. Klik Transformasikan Semua Templat di toolbar Penjelajah Solusi.

  10. Tekan F5.

  11. Verifikasi bahwa DSL berfungsi. Dalam proyek eksperimental, buka Sample.provider. Tutup instans eksperimental Visual Studio.

    Referensi ModelBus ke DSL ini sekarang dapat diselesaikan dalam templat teks dan juga dalam kode biasa.

Membuat DSL dengan properti domain Referensi ModelBus

  1. Buat DSL baru dengan menggunakan templat solusi Bahasa Minimal. Beri nama bahasa MBConsumer dan atur ekstensi nama file ke ".consume".

  2. Dalam proyek DSL, tambahkan referensi ke rakitan DSL MBProvider. Klik kanan MBConsumer\Dsl\References, lalu klik Ubah Tambahkan Referensi. Pada tab Telusuri, letaakkan MBProvider\Dsl\bin\Debug\Company.MBProvider.Dsl.dll

    Ini memungkinkan Anda membuat kode yang menggunakan DSL lainnya. Jika Anda ingin membuat referensi ke beberapa DLL, tambahkan juga.

  3. Dalam diagram Definisi DSL, klik kanan diagram lalu klik Aktifkan ModelBus. Dalam kotak dialog, pilih Aktifkan DSL ini untuk Menggunakan ModelBus.

  4. Di kelas ExampleElement, tambahkan properti domain baruMBR, dan di jendela Properti, atur jenisnya ke ModelBusReference.

  5. Klik kanan properti domain pada diagram lalu klik Edit ModelBusReference properti tertentu. Dalam kotak dialog, pilih elemen model.

    Atur filter dialog file ke berikut ini.

    Provider File|*.provide

    Substring setelah "|" adalah filter untuk kotak dialog pemilihan file. Anda dapat mengaturnya untuk mengizinkan file apa pun dengan menggunakan *.*

    Dalam daftar jenis Elemen Model , masukkan nama satu atau beberapa kelas domain di DSL penyedia (misalnya, Company.MBProvider.Task). Mereka bisa menjadi kelas abstrak. Jika Anda membiarkan daftar kosong, pengguna dapat mengatur referensi ke elemen apa pun.

  6. Tutup dialog dan Ubah Semua Templat.

    Anda telah membuat DSL yang dapat berisi referensi ke elemen di DSL lain.

Membuat referensi ModelBus ke file lain dalam solusi

  1. Di solusi MBConsumer, tekan CTRL+F5. Instans eksperimental Visual Studio terbuka di proyek MBConsumer\Debugging.

  2. Tambahkan salinan Sample.provide ke proyek MBConsumer\Debugging. Ini diperlukan karena referensi ModelBus harus merujuk ke file dalam solusi yang sama.

    1. Klik kanan proyek Penelusuran Kesalahan, arahkan ke Tambahkan, lalu klik Item yang Tersedia.

    2. Dalam dialog Tambahkan Item, atur filter ke Semua File (*.*).

    3. Navigasikan ke MBProvider\Debugging\Sample.provide lalu klik Tambahkan.

  3. Buka Sample.consume.

  4. Klik satu contoh bentuk, dan di jendela Properti, klik [...] di properti MBR. Dalam kotak dialog, klik Telusuri dan pilih Sample.provide. Di jendela elemen, perluas jenis Tugas dan pilih salah satu elemen.

  5. Simpan file. (Jangan tutup instans eksperimental Visual Studio.)

    Anda telah membuat model yang berisi referensi ModelBus ke elemen di model lain.

Mengatasi Referensi ModelBus dalam templat teks

  1. Dalam contoh eksperimental Visual Studio, buka contoh file templat teks. Atur kontennya sebagai berikut.

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

    Perhatikan poin berikut:

    • Atribut hostSpecific dan inherits direktif template harus diatur.

    • Model konsumen diakses secara biasa melalui prosesor arahan yang dihasilkan dalam DSL tersebut.

    • Arahan rakitan dan impor harus dapat mengakses ModelBus dan jenis penyedia DSL.

    • Jika Anda tahu bahwa banyak MBR ditautkan ke model yang sama, lebih baik memanggil CreateAdapter hanya satu kali.

  2. Simpan templat. Verifikasi bahwa file teks yang dihasilkan menyerupan berikut ini.

    ExampleElement1
ExampleElement2
     ExampleElement2 is linked to Task: Task2

Mengatasi referensi ModelBus dalam handler gerakan

  1. Tutup instans eksperimental Visual Studio.

  2. Tambahkan file bernama MBConsumer\Dsl\Custom.cs dan atur kontennya ke yang berikut ini:

    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. Tekan Ctrl+F5.

  4. Dalam instans eksperimental Visual Studio, buka Debugging\Sample.consume.

  5. Klik dua kali satu bentuk.

    Jika Anda telah mengatur MBR pada elemen tersebut, model yang dirujuk terbuka dan elemen yang dirujuk dipilih.

Konten terkait

Catatan

Komponen Transformasi Template Teks secara otomatis diinstal sebagai bagian dari beban kerja pengembangan ekstensi Visual Studio. Anda juga dapat menginstalnya dari tab Komponen individual Alat Penginstal Visual Studio, di bawah kategori SDK, pustaka, dan kerangka kerja. Instal komponen SDK Pemodelan dari tab Komponen individual.

  • Last updated on