Condividi tramite

Integrare i modelli usando ModelBus di Visual Studio

  • Articolo

Visual Studio ModelBus fornisce un metodo per la creazione di collegamenti tra modelli e da altri strumenti in modelli. Ad esempio, è possibile collegare modelli DSL (Domain Specific Language) e modelli UML. È anche possibile creare un set integrato di DSL.

Avviso

L'estensione ModelBus di Visual Studio, descritta in questo articolo, non è più disponibile per il download. Tuttavia, queste istruzioni continuano a funzionare per gli utenti che hanno già installato questa estensione.

ModelBus consente di creare un riferimento univoco a un modello o a un elemento specifico all'interno di un modello. Questo riferimento può essere archiviato all'esterno del modello, ad esempio in un elemento in un altro modello. Quando, in un secondo momento, uno strumento vuole ottenere l'accesso all'elemento, l'infrastruttura ModelBus carica il modello appropriato e restituisce l'elemento. Se si vuole, è possibile mostrare il modello all'utente. Se non è possibile accedere al file nel percorso precedente, ModelBus chiede all'utente di trovarlo. Se l'utente trova il file, ModelBus aggiorna tutti i riferimenti a tale file.

Nota

Nell'implementazione corrente di Visual Studio di ModelBus i modelli collegati devono essere elementi nella stessa soluzione di Visual Studio.

Per altre informazioni sull'estensione ModelBus, vedere le risorse seguenti:

Nota

Il componente Trasformazione modello di testo viene installato automaticamente come parte del carico di lavoro sviluppo di estensioni di Visual Studio. È anche possibile installarlo dalla scheda Singoli componenti di Programma di installazione di Visual Studio, nella categoria SDK, librerie e framework. Installare il componente Modeling SDK dalla scheda Singoli componenti .

Fornire l'accesso a un dsl

Prima di poter creare riferimenti ModelBus a un modello o ai relativi elementi, definire un ModelBusAdapter per il linguaggio DSL. Il modo più semplice per definirne uno consiste nell'usare l'estensione ModelBus di Visual Studio, che aggiunge comandi alla finestra di progettazione DSL.

Per esporre una definizione DSL a ModelBus

  1. Aprire il file di definizione del linguaggio specifico di dominio. Fare clic con il pulsante destro del mouse sull'area di progettazione e quindi scegliere Abilita ModelBus.

  2. Nella finestra di dialogo scegliere Desidero esporre questo dsl al ModelBus. È possibile scegliere entrambe le opzioni se si vuole che il linguaggio specifico di dominio esponga i propri modelli e usi riferimenti ad altri modelli.

  3. Seleziona OK. Alla soluzione DSL viene aggiunto un nuovo progetto ModelBusAdapter .

  4. Se si vuole accedere al linguaggio DSL da un modello di testo, è necessario modificare AdapterManager.tt nel nuovo progetto. Ignorare questo passaggio se si vuole accedere al linguaggio specifico di dominio da altro codice, ad esempio comandi e gestori di eventi. Per altre informazioni, vedere Uso di Visual Studio ModelBus in un modello di testo.

    1. Modificare la classe base di in AdapterManagerBaseVsTextTemplatingModelingAdapterManager.

    2. Nella parte finale del file inserire questo attributo davanti alla classe AdapterManager:

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

    3. Nel Gestione pacchetti NuGet del ModelBusAdapter progetto aggiungere un oggetto NuGet PackageReference a Microsoft.VisualStudio.TextTemplating.Modeling.

      Se si vuole accedere al linguaggio specifico di dominio sia da modelli di testo che da altro codice, sono necessari due adattatori, uno modificato e uno non modificato.

  5. Selezionare Trasforma tutti i modelli.

  6. Ricompila la soluzione.

    ModelBus può ora aprire istanze di questo linguaggio DSL.

    La cartella ModelBusAdapters\bin* contiene gli assembly compilati dal Dsl progetto e dal ModelBusAdapters progetto. Per fare riferimento a questo linguaggio DSL da un altro linguaggio DSL, importare questi assembly.

Verificare che sia possibile fare riferimento a elementi

Per impostazione predefinita, gli adattatori ModelBus di Visual Studio usano il GUID di un elemento per identificarlo. Questi identificatori devono essere salvati in modo permanente nel file del modello.

Per assicurarsi che gli ID elemento siano persistenti:

  1. Aprire DslDefinition.dsl.

  2. In Esplora DSL espandere Comportamento di serializzazione XML, quindi Dati classe.

  3. Per ogni classe a cui si desidera creare riferimenti ModelBus:

    Selezionare il nodo della classe e nella finestra Proprietà assicurarsi che Serialize ID sia impostato su true.

In alternativa, se si desidera utilizzare i nomi degli elementi per identificare gli elementi anziché i GUID, è possibile eseguire l'override delle parti degli adattatori generati. Eseguire l'override dei metodi seguenti nella classe Adapter:

  • Eseguire l'override di GetElementId affinché venga restituito l'identificatore che si vuole usare. Questo metodo viene chiamato quando vengono creati i riferimenti.
  • Eseguire l'override ResolveElementReference per individuare l'elemento corretto da un riferimento ModelBus.

Accedere a un linguaggio DSL da un altro dsl

È possibile archiviare i riferimenti ModelBus in una proprietà di dominio in un linguaggio DSL e scrivere codice personalizzato che li usa. È anche possibile consentire all'utente di creare un riferimento ModelBus selezionando un file di modello e un elemento al suo interno.

Per consentire a un dsl di usare riferimenti a un altro linguaggio DSL, è necessario prima impostarlo come consumer di riferimenti al bus di modello.

Per consentire a un linguaggio specifico di dominio di usare riferimenti a un linguaggio specifico di dominio esposto

  1. Nel diagramma di definizione DSL fare clic con il pulsante destro del mouse sulla parte principale del diagramma e quindi scegliere Abilita ModelBus.

  2. Nella finestra di dialogo selezionare Si vuole abilitare questo modello per l'utilizzo dei riferimenti al bus di modello.

  3. Dsl Nel progetto del linguaggio DSL di utilizzo aggiungere gli assembly seguenti ai riferimenti al progetto. Questi assembly (.dll file) si trovano nella directory ModelBusAdapter\bin\* del dsl esposto.

    • Assembly DSL esposto, ad esempio Fabrikam.FamilyTree.Dsl.dll

    • Assembly dell'adattatore del bus di modello esposto, ad esempio Fabrikam.FamilyTree.ModelBusAdapter.dll

  4. Aggiungere gli assembly .NET seguenti ai riferimenti del progetto del progetto DSL usato.

    • Microsoft.VisualStudio.Modeling.Sdk.Integration.dll
    • Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.dll

Per archiviare un oggetto ModelBusReference in una proprietà di dominio

  1. Nella definizione DSL del linguaggio specifico di dominio usato, aggiungere una proprietà di dominio a una classe di dominio e impostarne il nome.

  2. Nella finestra Proprietà, con la proprietà di dominio selezionata, impostare Tipo su ModelBusReference.

    In questa fase, il codice del programma può impostare il valore della proprietà. Il valore è di sola lettura nella finestra Proprietà .

    È possibile consentire agli utenti di impostare la proprietà con un editor ModelBusReference specializzato. Esistono due versioni di questo editor o selezione. Uno consente agli utenti di scegliere un file di modello e l'altro consente agli utenti di scegliere un file di modello e un elemento all'interno del modello.

Per consentire all'utente di impostare ModelBusReference in una proprietà di dominio

  1. Fare clic con il pulsante destro del mouse sulla proprietà del dominio e quindi scegliere Modifica proprietà specifiche di ModelBusReference. Verrà visualizzata la finestra di dialogo Selezione bus modello.

  2. Impostare il tipo appropriato di ModelBusReference su un modello o su un elemento all'interno di un modello.

  3. Nella stringa di filtro della finestra di dialogo File, immettere una stringa come Family Tree files |*.ftree. Sostituire l'estensione del linguaggio DSL esposto.

  4. Se si sceglie di fare riferimento a un elemento in un modello, è possibile aggiungere un elenco di tipi che l'utente può selezionare, ad esempio Company.FamilyTree.Person.

  5. Selezionare OK e quindi trasforma tutti i modelli nella barra degli strumenti Esplora soluzioni.

    Avviso

    Se non è stato selezionato un modello o un'entità valida, il pulsante OK non ha alcun effetto, anche se potrebbe essere abilitato.

  6. Se è stato specificato un elenco di tipi di destinazione, ad esempio Company.FamilyTree.Person, è necessario aggiungere un riferimento all'assembly al progetto DSL, facendo riferimento alla DLL del dsl di destinazione, ad esempio Company.FamilyTree.Dsl.dll.

Per testare un oggetto ModelBusReference

  1. Compilare entrambi i DSL esposto e utilizzato.

  2. Eseguire uno dei DSL in modalità sperimentale premendo F5 o CTRL+F5.

  3. Nel progetto debug nell'istanza sperimentale di Visual Studio aggiungere file che sono istanze di ogni dsl.

    Nota

    Visual Studio ModelBus può risolvere solo i riferimenti ai modelli che sono elementi nella stessa soluzione di Visual Studio. Ad esempio, non è possibile creare un riferimento a un file di modello in un'altra parte del file system.

  4. Creare alcuni elementi e collegamenti nell'istanza del DSL esposto e salvarlo.

  5. Aprire un'istanza del DSL utilizzato e selezionare un elemento del modello contenente una proprietà di riferimento ModelBus.

  6. Nella finestra Proprietà fare doppio clic sulla proprietà di riferimento del bus di modello. Verrà visualizzata la finestra di dialogo del selettore.

  7. Selezionare Sfoglia e selezionare l'istanza del DSL esposto.

    Se è stato specificato il riferimento al bus di modello specifico dell'elemento, la selezione consente anche di scegliere un elemento nel modello.

Creare riferimenti nel codice del programma

Quando si desidera archiviare un riferimento a un modello o a un elemento all'interno di un modello, creare un oggetto ModelBusReference. Esistono due tipi di ModelBusReference: riferimenti a modelli e riferimenti a elementi.

Per creare un riferimento al modello, è necessario AdapterManager del linguaggio DSL di cui il modello è un'istanza e il nome file o l'elemento di progetto di Visual Studio del modello.

Per creare un riferimento a un elemento, occorre un adattatore per il file di modello e l'elemento a cui si vuole fare riferimento.

Nota

Con ModelBus di Visual Studio è possibile creare riferimenti solo agli elementi nella stessa soluzione di Visual Studio.

Importare gli assembly DSL esposti

Nel progetto di utilizzo aggiungere riferimenti di progetto al DSL e ModelBusAdapter agli assembly del dsl esposto.

Si supponga, ad esempio, di voler archiviare riferimenti ModelBus negli elementi di un dsl Musica Library. I riferimenti modelbus fanno riferimento agli elementi del linguaggio DSL FamilyTree. Nel nodo Riferimenti aggiungere riferimenti agli assembly seguenti nel Dsl progetto della soluzione Musica Library:

  • Fabrikam.FamilyTree.Dsl.dll. DSL esposto.

  • Fabrikam.FamilyTree.ModelBusAdapters.dll Adattatore ModelBus del DSL esposto.

  • Microsoft.VisualStudio.Modeling.Sdk.Integration

  • Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell

    Questi assembly sono disponibili nel ModelBusAdapters progetto del linguaggio DSL esposto, in *bin\**.

    Nel file di codice in cui si creano riferimenti, in genere è necessario importare questi spazi dei nomi:

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

Per creare un riferimento a un modello

Per creare un riferimento a un modello, accedere all'AdapterManager per il DSL esposto e usarlo per creare un riferimento al modello. È possibile specificare un percorso di file o un oggetto EnvDTE.ProjectItem.

Da AdapterManager è possibile ottenere un adattatore, che fornisce accesso ai singoli elementi nel modello.

Nota

È necessario eliminare l'adattatore dopo avere finito di usarlo. Il modo più pratico per eseguire questa operazione, è usare un'istruzione using. Ciò è illustrato nell'esempio seguente.

// 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 si vuole poter riutilizzare modelReference in un secondo momento, è possibile archiviarlo in una proprietà di dominio con un ModelBusReference di tipo esterno.

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

Per consentire agli utenti di modificare questa proprietà di dominio, usare ModelReferenceEditor come parametro nell'attributo Editor . Per altre informazioni, vedere Consentire all'utente di modificare un riferimento.

Per creare un riferimento a un elemento

L'adattatore creato per il modello può essere usato anche per creare e risolvere riferimenti.

// person is an element in the FamilyTree model:
ModelBusReference personReference =
  adapter.GetElementReference(person);

Se si vuole poter riutilizzare elementReference in un secondo momento, è possibile archiviarlo in una proprietà di dominio con un ModelBusReference di tipo esterno. Per consentire agli utenti di modificarlo, usare ModelElementReferenceEditor come parametro nell'attributo Editor . Per altre informazioni, vedere Consentire all'utente di modificare un riferimento.

Risolvere i riferimenti

Se è disponibile un ModelBusReference (MBR), è possibile ottenere il modello o l'elemento del modello a cui fa riferimento. Se l'elemento è presentato in un diagramma o in un'altra visualizzazione, è possibile aprire la visualizzazione e selezionare l'elemento.

È possibile creare un adattatore da un MBR. Dall'adattatore è quindi possibile ottenere la radice del modello. È anche possibile risolvere gli MBR che fanno riferimento a elementi specifici nel modello.

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.

Per risolvere ModelBusReferences in un modello di testo

Il DSL a cui si vuole accedere deve disporre di un adattatore ModelBus configurato per l'accesso dai modelli di testo. Per altre informazioni, vedere Fornire l'accesso a un linguaggio DSL.

In genere, si accede a un linguaggio DSL di destinazione usando un riferimento al bus di modello (MBR) archiviato in un dsl di origine. Il modello include pertanto la direttiva del DSL di origine, più il codice per risolvere l'MBR. Per altre informazioni sui modelli di testo, vedere Generazione di codice da un linguaggio specifico del dominio.

<#@ template debug="true" hostspecific="true"
inherits="Microsoft.VisualStudio.TextTemplating.Modeling.ModelBusEnabledTextTransformation" #>
<#@ SourceDsl processor="SourceDslDirectiveProcessor" requires="fileName='Sample.source'" #>
<#@ output extension=".txt" #>
<#@ assembly name = "Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0" #>
<#@ assembly name = "System.Core" #>
<#@ assembly name = "Company.CompartmentDragDrop.Dsl.dll" #>
<#@ assembly name = "Company.CompartmentDragDrop.ModelBusAdapter.dll" #>
<#@ import namespace="Microsoft.VisualStudio.Modeling.Integration" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="Company.CompartmentDragDrop" #>
<#@ import namespace="Company.CompartmentDragDrop.ModelBusAdapters" #>
<# // Get source root from directive processor:
  ExampleModel source = this.ExampleModel;
  // This DSL has an MBR in its root:
using (ModelBusAdapter adapter = this.ModelBus.CreateAdapter(source.ModelReference) as ModelBusAdapter)
  {
  ModelBusAdapterManager manager = this.ModelBus.FindAdapterManagers(this.Host.ResolvePath("Sample.compDD1")).FirstOrDefault();
  ModelBusReference modelReference =
    manager.CreateReference(this.Host.ResolvePath("Sample.compDD1"));

  // Get the root element of this model:
  using (CompartmentDragDropAdapter adapter =
     this.ModelBus.CreateAdapter(modelReference) as CompartmentDragDropAdapter)
  {
    ModelRoot root = adapter.ModelRoot;
#>
[[<#= root.Name #>]]
<#
  }
#>

Per altre informazioni e una procedura dettagliata, vedere Uso di Visual Studio ModelBus in un modello di testo

Serializzare un oggetto ModelBusReference

Se si vuole archiviare un ModelBusReference (MBR) sotto forma di stringa, è possibile serializzarlo:

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

Un MBR serializzato in questo modo è indipendente dal contesto. Se si usa il semplice adattatore del bus di modello basato su file, MBR contiene un percorso di file assoluto. Se i file del modello di istanza non vengono mai spostati, questa serializzazione è sufficiente. Tuttavia, i file di modello sono in genere elementi in un progetto di Visual Studio. Gli utenti si aspettano di poter spostare l'intero progetto in parti diverse del file system. Si aspettano anche di poter mantenere il progetto sotto il controllo del codice sorgente e aprirlo in computer diversi. I nomi dei percorsi devono quindi essere serializzati in relazione al percorso del progetto contenente i file.

Serializzazione relativa a un percorso di file specificato

Un ModelBusReference contiene un ReferenceContext, ovvero un dizionario in cui è possibile archiviare informazioni, ad esempio il percorso del file in relazione al quale deve essere serializzato.

Per eseguire la serializzazione in relazione a un percorso:

elementReference.ReferenceContext.Add(
   ModelBusReferencePropertySerializer.FilePathSaveContextKey,
   currentProjectFilePath);
string serialized = modelBus.SerializeReference(elementReference);

Per recuperare il riferimento dalla stringa:

ReferenceContext context = new ReferenceContext();
context.Add(ModelBusReferencePropertySerializer.FilePathLoadContextKey,
    currentProjectFilePath);
ModelBusReference elementReferenceRestored =
    modelBus.DeserializeReference(serialized, context);

Riferimenti ModelBus creati da altri adattatori

Le informazioni seguenti risultano utili per la creazione di un adattatore personalizzato.

Un ModelBusReference (MBR) è costituito da due parti: l'intestazione dell'MBR, che è deserializzata da ModelBus e una parte specifica dell'adattatore gestita dal gestore dell'adattatore specifico. Questo approccio consente di fornire un formato di serializzazione dell'adattatore personalizzato. È ad esempio possibile fare riferimento a un database anziché a un file oppure archiviare informazioni aggiuntive nel riferimento dell'adattatore. L'adattatore può inserire informazioni aggiuntive in ReferenceContext.

Quando si esegue la deserializzazione di un MBR, è necessario fornire un ReferenceContext che viene quindi archiviato nell'oggetto MBR. Quando si esegue la serializzazione di un MBR, il ReferenceContext archiviato viene usato dall'adattatore per generare la stringa. La stringa deserializzata non contiene tutte le informazioni contenute in ReferenceContext. Ad esempio, nell'adattatore semplice basato su file, ReferenceContext contiene un percorso di file radice. Il percorso non viene archiviato nella stringa MBR serializzata.

L'MBR viene deserializzato in due fasi:

  • ModelBusReferencePropertySerializer è il serializzatore standard che gestisce l'intestazione MBR. Usa il contenitore delle proprietà SerializationContext DSL standard che è archiviato in ReferenceContext tramite la chiave ModelBusReferencePropertySerializer.ModelBusLoadContextKey. In particolare, SerializationContext deve contenere un'istanza di ModelBus.

  • L'adattatore ModelBus gestisce la parte specifica dell'adattatore dell'MBR. Può usare le informazioni aggiuntive archiviate nel ContextReference dell'MBR. L'adattatore semplice basato su file mantiene i percorsi dei file radice usando le chiavi FilePathLoadContextKey e FilePathSaveContextKey.

    Un riferimento adattatore in un file di modello viene deserializzato solo quando viene usato.

Creazione di un modello

Creazione, apertura e modifica di un modello

Il frammento seguente è tratto dall'esempio macchina a stati nel sito Web VMSDK. Viene illustrato l'uso di ModelBusReferences per creare e aprire un modello e per ottenere il diagramma associato al modello.

In questo esempio il nome del DSL di destinazione è StateMachine. Diversi nomi sono derivati da esso, ad esempio il nome della classe del modello e il nome dell'adattatore ModelBus.

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();
    }
}

Convalidare i riferimenti

BrokenReferenceDetector esegue il test di tutte le proprietà di dominio in un archivio che può contenere riferimenti ModelBus. Chiama l'azione specificata ogni volta che trova un'azione. Questo test è utile per i metodi di convalida. Il metodo di convalida seguente esegue un test sull'archivio nel tentativo di salvare i modelli e segnala i riferimenti interrotti nella finestra degli errori:

[ValidationMethod(ValidationCategories.Save)]
public void ValidateModelBusReferences(ValidationContext context)
{
  BrokenReferenceDetector.DetectBrokenReferences(this.Store,
    delegate(ModelElement element, // parent of property
             DomainPropertyInfo property, // identifies property
             ModelBusReference reference) // invalid reference
    {
      context.LogError(string.Format(INVALID_REF_FORMAT,
             property.Name,
             referenceState.Name,
             new ModelBusReferenceTypeConverter().
                 ConvertToInvariantString(reference)),
         "Reference",
         element);
    });
}
private const string INVALID_REF_FORMAT =
    "The '{0}' domain property of this ReferenceState instance "
  + "named '{1}' contains reference value '{2}' which is invalid";

Azioni eseguite dall'estensione ModelBus

Le informazioni seguenti possono risultare utili se si utilizza ampiamente ModelBus.

L'estensione ModelBus apporta le modifiche seguenti alla soluzione DSL.

Quando si fa clic con il pulsante destro del mouse sul diagramma di definizione DSL, selezionare Abilita Modelbus e quindi selezionare Abilita questo dsl per utilizzare ModelBus:

  • Nel progetto DSL è necessario aggiungere un riferimento a Microsoft.VisualStudio.Modeling.Sdk.Integration.dll.

  • Nella definizione DSL viene aggiunto un riferimento di tipo esterno: Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

    È possibile visualizzare il riferimento in Esplora DSL, in Tipi di dominio. Per aggiungere manualmente riferimenti di tipo esterno, fare clic con il pulsante destro del mouse sul nodo radice.

  • Viene aggiunto un nuovo file modello Dsl \GeneratedCode\ModelBusReferencesSerialization.tt.

Quando si imposta il tipo di una proprietà di dominio su ModelBusReference, quindi fare clic con il pulsante destro del mouse sulla proprietà e selezionare Abilita proprietà specifiche modelBusReference:

  • Alla proprietà di dominio vengono aggiunti numerosi attributi CLR ed È possibile visualizzarli nel campo Attributi personalizzati nella finestra Proprietà . In Dsl\GeneratedCode\DomainClasses.cs è possibile visualizzare gli attributi nella dichiarazione di proprietà:

    [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 si fa clic con il pulsante destro del mouse sul diagramma di definizione DSL, selezionare Abilita ModelBus e selezionare Esporre questo dsl al modelbus:

  • Viene aggiunto un nuovo progetto ModelBusAdapter alla soluzione.

  • Al progetto ModelBusAdapter viene aggiunto un riferimento a DslPackage. ModelBusAdapter ha un riferimento al Dsl progetto.

  • In DslPackage\source.extention.tt|ModelBusAdapter| viene aggiunto come componente MEF.

Contenuto correlato