Freigeben über

Exemplarische Vorgehensweise: Verbinden eines Hosts mit einem generierten Direktivenprozessor

Sie können Ihren eigenen Host schreiben, der Textvorlagen verarbeitet. Ein einfacher benutzerdefinierter Host wird im Artikel Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Textvorlagenhosts erläutert. Sie können diesen Host erweitern, um Funktionen wie das Generieren mehrerer Ausgabedateien hinzuzufügen.

In dieser exemplarischen Vorgehensweise erweitern Sie Ihren benutzerdefinierten Host so, dass er Textvorlagen unterstützt, die Anweisungsprozessoren aufrufen. Wenn Sie eine domänenspezifische Sprache definieren, generiert sie einen Anweisungsprozessor für das Domänenmodell. Der Anweisungsprozessor erleichtert Benutzer*innen das Schreiben von Vorlagen, die auf das Modell zugreifen, wodurch die Notwendigkeit reduziert wird, Assembly- und Importanweisungen in den Vorlagen zu schreiben.

Hinweis

Diese exemplarische Vorgehensweise basiert auf Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Textvorlagenhosts. Führen Sie zunächst die Schritte dieser exemplarischen Vorgehensweise aus.

Diese exemplarische Vorgehensweise umfasst die folgenden Aufgaben:

  • Verwenden von DSL-Tools zum Generieren eines Anweisungsprozessors, der auf einem Domänenmodell basiert

  • Verbinden eines benutzerdefinierten Textvorlagenhosts mit dem generierten Anweisungsprozessor

  • Testen des benutzerdefinierten Hosts mit dem generierten Anweisungsprozessor

Voraussetzungen

Zur Definition einer DSL müssen folgende Komponenten installiert sein:

Komponente Link
Visual Studio http://go.microsoft.com/fwlink/?LinkId=185579
Visual Studio SDK http://go.microsoft.com/fwlink/?LinkId=185580
Visual Studio Visualization and Modeling SDK

Hinweis

Die Komponente Textvorlagentransformation wird automatisch als Teil der Workload Visual Studio-Erweiterungsentwicklung installiert. Sie können die Installation auch über die Registerkarte Einzelne Komponenten des Visual Studio-Installers unter der Kategorie SDKs, Bibliotheken und Frameworks durchführen. Installieren Sie die Komponente Modellierungs-SDK auf der Registerkarte Einzelne Komponenten.

Darüber hinaus müssen Sie über die in Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Textvorlagenhosts erstellte benutzerdefinierte Textvorlagentransformation verfügen.

Verwenden von DSL-Tools zum Generieren eines Anweisungsprozessors

In dieser exemplarischen Vorgehensweise verwenden Sie den DSL-Designer-Assistenten zum Erstellen einer domänenspezifischen Sprache für die DSLMinimalTest-Projektmappe.

  1. Erstellen Sie eine Projektmappe für eine domänenspezifische Sprache, die die folgenden Merkmale aufweist:

    • Name: DSLMinimalTest

    • Projektmappenvorlage: Minimale Sprache

    • Dateierweiterung: min

    • Unternehmensname: Fabrikam

    Weitere Informationen zum Erstellen einer Projektmappe für eine domänenspezifische Sprache finden Sie unter Exemplarische Vorgehensweise: Erstellen einer Projektmappe für eine domänenspezifische Sprache.

  2. Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

    Wichtig

    Mit diesem Schritt wird der Anweisungsprozessor generiert und der entsprechende Schlüssel in der Registrierung hinzugefügt.

  3. Klicken Sie im Menü Debuggen auf Debuggen starten.

    Eine zweite Instanz von Visual Studio wird geöffnet.

  4. Doppelklicken Sie im experimentellen Build im Projektmappen-Explorer auf die Datei sample.min.

    Die Datei wird im Designer geöffnet. Beachten Sie, dass das Modell die beiden Elemente „ExampleElement1“ und „ExampleElement2“ sowie eine Verknüpfung zwischen diesen aufweist.

  5. Schließen Sie die zweite Instanz von Visual Studio.

  6. Speichern Sie die Projektmappe, und schließen Sie dann den DSL-Designer.

Verbinden eines benutzerdefinierten Textvorlagenhosts mit einem Anweisungsprozessor

Nachdem Sie den Anweisungsprozessor generiert haben, verbinden Sie ihn mit dem benutzerdefinierten Textvorlagenhost, den Sie unter Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Textvorlagenhosts erstellt haben.

  1. Öffnen Sie die CustomHost-Projektmappe.

  2. Klicken Sie im Menü Projekt auf Verweis hinzufügen.

    Das Dialogfeld Verweis hinzufügen wird geöffnet, wobei die Registerkarte .NET angezeigt wird.

  3. Fügen Sie die folgenden Verweise hinzu:

    • Microsoft.VisualStudio.Modeling.Sdk.11.0

    • Microsoft.VisualStudio.Modeling.Sdk.Diagrams.11.0

    • Microsoft.VisualStudio.TextTemplating.11.0

    • Microsoft.VisualStudio.TextTemplating.Interfaces.11.0

    • Microsoft.VisualStudio.TextTemplating.Modeling.11.0

    • Microsoft.VisualStudio.TextTemplating.VSHost.11.0

  4. Fügen Sie am Anfang von „Program.cs“ oder „Module1.vb“ die folgende Codezeile hinzu:

    using Microsoft.Win32;

  5. Suchen Sie den Code für die Eigenschaft StandardAssemblyReferences, und ersetzen Sie ihn durch den folgenden Code:

    Hinweis

    In diesem Schritt fügen Sie Verweise auf die Assemblys hinzu, die vom generierten Anweisungsprozessor benötigt werden, den Ihr Host unterstützt.

    //the host can provide standard assembly references
//the engine will use these references when compiling and
//executing the generated transformation class
//--------------------------------------------------------------
public IList<string> StandardAssemblyReferences
{
    get
    {
        return new string[]
        {
            //if this host searches standard paths and the GAC
            //we can specify the assembly name like this:
            //"System"
            //since this host only resolves assemblies from the
            //fully qualified path and name of the assembly
            //this is a quick way to get the code to give us the
            //fully qualified path and name of the System assembly
            //---------------------------------------------------------
            typeof(System.Uri).Assembly.Location,
                        typeof(System.Uri).Assembly.Location,
            typeof(Microsoft.VisualStudio.Modeling.ModelElement).Assembly.Location,
            typeof(Microsoft.VisualStudio.Modeling.Diagrams.BinaryLinkShape).Assembly.Location,
            typeof(Microsoft.VisualStudio.TextTemplating.VSHost.ITextTemplating).Assembly.Location,
            typeof(Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation).Assembly.Location

        };
    }
}

  6. Suchen Sie den Code für die Funktion ResolveDirectiveProcessor, und ersetzen Sie ihn durch den folgenden Code:

    Wichtig

    Dieser Code enthält hartcodierte Verweise auf den Namen des generierten Anweisungsprozessors, mit dem Sie eine Verbindung herstellen möchten. Bei einem allgemeineren Ansatz werden einfach alle in der Registrierung aufgeführten Anweisungsprozessoren durchsucht und Übereinstimmungen ermittelt. In diesem Fall würde der Host mit jedem generierten Anweisungsprozessor funktionieren.

    //the engine calls this method based on the directives the user has
        //specified it in the text template
        //this method can be called 0, 1, or more times
        //---------------------------------------------------------------------
        public Type ResolveDirectiveProcessor(string processorName)
        {
            //check the processor name, and if it is the name of the processor the
            //host wants to support, return the type of the processor
            //---------------------------------------------------------------------
            if (string.Compare(processorName, "DSLMinimalTestDirectiveProcessor", StringComparison.InvariantCultureIgnoreCase) == 0)
            {
                try
                {
                    string keyName = @"Software\Microsoft\VisualStudio\10.0Exp_Config\TextTemplating\DirectiveProcessors\DSLMinimalTestDirectiveProcessor";
                    using (RegistryKey specificKey = Registry.CurrentUser.OpenSubKey(keyName))
                    {
                        if (specificKey != null)
                        {
                            List<string> names = new List<String>(specificKey.GetValueNames());
                            string classValue = specificKey.GetValue("Class") as string;
                            if (!string.IsNullOrEmpty(classValue))
                            {
                                string loadValue = string.Empty;
                                System.Reflection.Assembly processorAssembly = null;
                                if (names.Contains("Assembly"))
                                {
                                    loadValue = specificKey.GetValue("Assembly") as string;
                                    if (!string.IsNullOrEmpty(loadValue))
                                    {
                                        //the assembly must be installed in the GAC
                                        processorAssembly = System.Reflection.Assembly.Load(loadValue);
                                    }
                                }
                                else if (names.Contains("CodeBase"))
                                {
                                    loadValue = specificKey.GetValue("CodeBase") as string;
                                    if (!string.IsNullOrEmpty(loadValue))
                                    {
                                        //loading local assembly
                                        processorAssembly = System.Reflection.Assembly.LoadFrom(loadValue);
                                    }
                                }
                                if (processorAssembly == null)
                                {
                                    throw new Exception("Directive Processor not found");
                                }
                                Type processorType = processorAssembly.GetType(classValue);
                                if (processorType == null)
                                {
                                    throw new Exception("Directive Processor not found");
                                }
                                return processorType;
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    //if the directive processor can not be found, throw an error
                    throw new Exception("Directive Processor not found");
                }
            }

            //if the directive processor is not one this host wants to support
            throw new Exception("Directive Processor not supported");
        }

  7. Klicken Sie im Menü Datei auf Alle speichern.

  8. Klicken Sie im Menü Build auf Projektmappe erstellen.

Testen des benutzerdefinierten Hosts mit dem Anweisungsprozessor

Um den benutzerdefinierten Textvorlagenhost zu testen, müssen Sie zuerst eine Textvorlage schreiben, die den generierten Anweisungsprozessor aufruft. Führen Sie anschließend den benutzerdefinierten Host aus, übergeben Sie ihm den Namen der Textvorlage, und stellen Sie sicher, dass die Anweisung ordnungsgemäß verarbeitet wird.

Erstellen einer Textvorlage zum Testen des benutzerdefinierten Hosts

  1. Erstellen Sie eine Textdatei mit dem Namen TestTemplateWithDP.tt. Sie können einen beliebigen Text-Editor (z. B. Editor) verwenden, um die Datei zu erstellen.

  2. Fügen Sie folgenden Text in der Textdatei ein:

    Hinweis

    Die Programmiersprache der Textvorlage muss nicht mit der Sprache des benutzerdefinierten Hosts identisch sein.

    Text Template Host Test

<#@ template debug="true" inherits="Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation" #>
<# //this is the call to the examplemodel directive in the generated directive processor #>
<#@ DSLMinimalTest processor="DSLMinimalTestDirectiveProcessor" requires="fileName='<Your Path>\Sample.min'" provides="ExampleModel=ExampleModel" #>
<# //uncomment this line to test that the host allows the engine to set the extension #>
<# //@ output extension=".htm" #>

<# //uncomment this line if you want to see the generated transformation class #>
<# //System.Diagnostics.Debugger.Break(); #>
<# //this code uses the results of the examplemodel directive #>
<#
    foreach ( ExampleElement box in this.ExampleModel.Elements )
    {
        WriteLine("Box: {0}", box.Name);

        foreach (ExampleElement linkedTo in box.Targets)
        {
            WriteLine("Linked to: {0}", linkedTo.Name);
        }

        foreach (ExampleElement linkedFrom in box.Sources)
        {
            WriteLine("Linked from: {0}", linkedFrom.Name);
        }

        WriteLine("");
    }
#>

  3. Ersetzen Sie <YOUR PATH> im Code durch den Pfad der Datei „sample.min“ über die entwurfsspezifische Sprache, die Sie in der ersten Prozedur erstellt haben.

  4. Speichern und schließen Sie die Datei.

Testen des benutzerdefinierten Hosts

  1. Öffnen Sie ein Eingabeaufforderungsfenster.

  2. Geben Sie den Pfad der ausführbaren Datei für den benutzerdefinierten Host ein, drücken Sie aber noch nicht die EINGABETASTE.

    Beispiel:

    <YOUR PATH>CustomHost\bin\Debug\CustomHost.exe

    Hinweis

    Anstatt die Adresse einzugeben, können Sie auch im Windows-Explorer zur Datei „CustomHost.exe“ navigieren und die Datei dann in das Eingabeaufforderungsfenster ziehen.

  3. Geben Sie ein Leerzeichen ein.

  4. Geben Sie den Pfad der Textvorlagendatei ein, und drücken Sie dann die EINGABETASTE.

    Beispiel:

    <YOUR PATH>TestTemplateWithDP.txt

    Hinweis

    Anstatt die Adresse einzugeben, können Sie auch im Windows-Explorer zur Datei „TestTemplateWithDP.txt“ navigieren und die Datei dann in das Eingabeaufforderungsfenster ziehen.

    Die benutzerdefinierte Hostanwendung wird ausgeführt und startet den Textvorlagen-Transformationsprozess.

  5. Navigieren Sie im Windows-Explorer zu dem Ordner, der die Datei „TestTemplateWithDP.txt“ enthält.

    Der Ordner enthält auch die Datei „TestTemplateWithDP1.txt“.

  6. Öffnen Sie diese Datei, um die Ergebnisse der Textvorlagentransformation anzuzeigen.

    Die Ergebnisse der generierten Textausgabe werden angezeigt und sollten wie folgt aussehen:

    Text Template Host Test

Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Zugehöriger Inhalt

  • Last updated on