Udostępnij za pośrednictwem

Przewodnik: łączenie hosta z wygenerowanym procesorem dyrektywy

  • Artykuł

Możesz napisać własnego hosta, który przetwarza szablony tekstu. Podstawowy host niestandardowy jest przedstawiony w przewodniku: Tworzenie niestandardowego hosta szablonu tekstu. Możesz rozszerzyć ten host, aby dodać funkcje, takie jak generowanie wielu plików wyjściowych.

W tym przewodniku rozszerzysz niestandardowy host tak, aby obsługiwał szablony tekstu wywołujące procesory dyrektywy. Podczas definiowania języka specyficznego dla domeny generuje procesor dyrektywy dla modelu domeny. Procesor dyrektywy ułatwia użytkownikom pisanie szablonów, które uzyskują dostęp do modelu, co zmniejsza konieczność pisania dyrektyw zestawów i importu w szablonach.

Uwaga

Ten przewodnik jest oparty na przewodniku: tworzenie niestandardowego hosta szablonu tekstowego. Najpierw wykonaj ten przewodnik.

Ten instruktaż zawiera następujące zagadnienia:

  • Używanie narzędzi językowych specyficznych dla domeny do generowania procesora dyrektywy opartego na modelu domeny.

  • Połączenie niestandardowego hosta szablonu tekstowego do wygenerowanego procesora dyrektywy.

  • Testowanie hosta niestandardowego za pomocą wygenerowanego procesora dyrektywy.

Wymagania wstępne

Aby zdefiniować rozszerzenie DSL, należy zainstalować następujące składniki:

Składnik 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

Uwaga

Składnik Przekształcanie szablonu tekstu jest automatycznie instalowany w ramach obciążenia programistycznego rozszerzenia programu Visual Studio. Można go również zainstalować na karcie Poszczególne składniki Instalator programu Visual Studio w kategorii Zestawy SDK, biblioteki i struktury. Zainstaluj składnik Zestawu SDK modelowania na karcie Poszczególne składniki.

Ponadto musisz mieć niestandardowe przekształcenie szablonu tekstowego utworzone w przewodniku: Tworzenie niestandardowego hosta szablonu tekstowego.

Generowanie procesora dyrektywy przy użyciu narzędzi językowych specyficznych dla domeny

W tym przewodniku użyjesz Kreatora Projektant języka specyficznego dla domeny, aby utworzyć język specyficzny dla domeny dla rozwiązania DSLMinimalTest.

  1. Utwórz rozwiązanie języka specyficznego dla domeny, które ma następujące cechy:

    • Nazwa: DSLMinimalTest

    • Szablon rozwiązania: minimalny język

    • Rozszerzenie pliku: min

    • Nazwa firmy: Fabrikam

    Aby uzyskać więcej informacji na temat tworzenia rozwiązania języka specyficznego dla domeny, zobacz How to: Create a Domain-Specific Language Solution (Jak utworzyć rozwiązanie języka specyficznego dla domeny).

  2. W menu Kompilacja kliknij pozycję Kompiluj rozwiązanie.

    Ważne

    Ten krok generuje procesor dyrektywy i dodaje klucz do niego w rejestrze.

  3. W menu Debugowanie kliknij polecenie Rozpocznij debugowanie.

    Zostanie otwarte drugie wystąpienie programu Visual Studio.

  4. W kompilacji eksperymentalnej w Eksplorator rozwiązań kliknij dwukrotnie plik sample.min.

    Plik zostanie otwarty w projektancie. Zwróć uwagę, że model ma dwa elementy: ExampleElement1 i ExampleElement2 oraz łącze między nimi.

  5. Zamknij drugie wystąpienie programu Visual Studio.

  6. Zapisz rozwiązanie, a następnie zamknij Projektant języka specyficznego dla domeny.

Połączenie niestandardowego hosta szablonu tekstowego do procesora dyrektywy

Po wygenerowaniu procesora dyrektywy należy połączyć procesor dyrektywy i niestandardowy host szablonu tekstowego utworzony w przewodniku: Tworzenie niestandardowego hosta szablonu tekstowego.

  1. Otwórz rozwiązanie CustomHost.

  2. W menu Project (Projekt) kliknij pozycję Add Reference (Dodaj odwołanie).

    Zostanie otwarte okno dialogowe Dodawanie odwołania z wyświetloną kartą .NET .

  3. Dodaj następujące odwołania:

    • 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. W górnej części pliku Program.cs lub Module1.vb dodaj następujący wiersz kodu:

    using Microsoft.Win32;

  5. Znajdź kod właściwości StandardAssemblyReferencesi zastąp go następującym kodem:

    Uwaga

    W tym kroku dodasz odwołania do zestawów wymaganych przez wygenerowany procesor dyrektywy, który będzie obsługiwał host.

    //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. Znajdź kod funkcji ResolveDirectiveProcessori zastąp go następującym kodem:

    Ważne

    Ten kod zawiera trwale zakodowane odwołania do nazwy wygenerowanego procesora dyrektywy, z którym chcesz nawiązać połączenie. Można łatwo uczynić to bardziej ogólnym, w takim przypadku szuka wszystkich procesorów dyrektywy wymienionych w rejestrze i próbuje znaleźć dopasowanie. W takim przypadku host będzie działał z dowolnym wygenerowanymi procesorami dyrektywy.

    //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. W menu File kliknij pozycję Save All.

  8. W menu Kompilacja kliknij pozycję Kompiluj rozwiązanie.

Testowanie hosta niestandardowego za pomocą procesora dyrektywy

Aby przetestować niestandardowy host szablonu tekstowego, najpierw musisz napisać szablon tekstowy, który wywołuje wygenerowany procesor dyrektywy. Następnie uruchomisz hosta niestandardowego, przekaż do niego nazwę szablonu tekstowego i sprawdź, czy dyrektywa jest przetwarzana poprawnie.

Tworzenie szablonu tekstowego do testowania hosta niestandardowego

  1. Utwórz plik tekstowy i nadaj mu TestTemplateWithDP.ttnazwę . Do utworzenia pliku można użyć dowolnego edytora tekstów, takiego jak Notatnik.

  2. Dodaj następującą zawartość do pliku tekstowego:

    Uwaga

    Język programowania szablonu tekstu nie musi być zgodny z językiem niestandardowym hosta.

    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. W kodzie zastąp <ciąg YOUR PATH> ścieżką pliku Sample.min z języka specyficznego dla projektu utworzonego w pierwszej procedurze.

  4. Zapisz i zamknij plik.

Testowanie hosta niestandardowego

  1. Otwórz wiersz polecenia.

  2. Wpisz ścieżkę pliku wykonywalnego dla niestandardowego hosta, ale nie naciskaj jeszcze ENTER.

    Na przykład wpisz:

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

    Uwaga

    Zamiast wpisywać adres, możesz przejść do pliku CustomHost.exe w Eksploratorze Windows, a następnie przeciągnąć plik do okna wiersza polecenia.

  3. Wpisz spację.

  4. Wpisz ścieżkę do pliku szablonu tekstu, a następnie naciśnij ENTER.

    Na przykład wpisz:

    <YOUR PATH>TestTemplateWithDP.txt

    Uwaga

    Zamiast wpisywać adres, możesz przejść do pliku TestTemplateWithDP.txt w Eksploratorze Windows, a następnie przeciągnąć plik do okna wiersza polecenia.

    Aplikacja niestandardowego hosta jest uruchamiana i uruchamia proces przekształcania szablonu tekstu.

  5. W Eksploratorze Windows przejdź do folderu zawierającego plik TestTemplateWithDP.txt.

    Folder zawiera również plik TestTemplateWithDP1.txt.

  6. Otwórz ten plik, aby zobaczyć wyniki przekształcenia szablonu tekstu.

    Wyniki wygenerowanego tekstu wyjściowego są wyświetlane i powinny wyglądać następująco:

    Text Template Host Test

Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Powiązana zawartość