{"id":55000187,"date":"2019-08-01T00:00:00","date_gmt":"2020-03-27T19:38:44","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=187"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Visual_Studio_mit_LINQPad_Project_und_ProjectItems","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Visual_Studio_mit_LINQPad_Project_und_ProjectItems\/","title":{"rendered":"Visual Studio mit LINQPad: Project und ProjectItems"},"content":{"rendered":"

In den Artikeln der Reihe Visual Studio erweitern greifen wir von Visual Studio-Erweiterungen aus auf Elemente von Visual Studio zu. Leider ist das Debuggen dieser Erweiterungen äußerst mühsam. Zum Debuggen müssen Sie nämlich immer erst eine weitere Visual Studio-Instanz erstellen, welche dann die Erweiterungen enthält und zum Testen bereitstellt. Fällt eine Änderung an, müssen Sie das Debuggen beenden, die Änderungen einarbeiten und erneut starten. Da wäre es doch praktisch, wenn man einfach nur eine Instanz von Visual Studio öffnen und die darauf zugreifenden Methoden direkt testen könnte. Genau das realisieren wir in diesem Artikel, wo wir das Tool LINQPad nutzen. Dieses haben wir bereits in früheren Artikeln verwendet.<\/b><\/p>\n

Wer von Access und dem VBA-Editor kommt, findet das Debuggen unter Visual Studio bisweilen anstrengend. Im Visual Basic Editor war das alles viel einfacher: Man konnte einfach eine Prozedur in ein Standardmodul schreiben, die Einfügemarke in der Prozedur platzieren und diese mit der Taste F5 <\/b>starten. Damit konnte man sogar während der Entwicklung auf Elemente des Visual Studio Editors selbst zugreifen! Und genau das wollen wir mit Visual Studio auch tun, um uns die Objekte, Methoden und Eigenschaften, die für die Programmierung von Visual Studio notwendig sind, besser kennenzulernen und schnell ausprobieren zu können.<\/p>\n

Eine Möglichkeit dazu finden wir über das Tool LINQPad. Dieses erlaubt die Eingabe von Prozeduren und die direkte Ausführung mit der Taste F5 <\/b>– genau so, wie Sie es auch von Access und dem VBA-Editor kennen. <\/p>\n

LINQPad können Sie in einer kostenlosen Version unter https:\/\/www.linqpad.net\/<\/b> herunterladen. Wenn Sie damit einfache VB-Prozeduren ausführen wollen, wechseln Sie im Auswahlfeld Language <\/b>auf VB Program<\/b>. Dadurch wird direkt eine leere Prozedur namens Main <\/b>angelegt, die wir mit einer einfachen Debug.Print<\/b>-Anweisung füllen. Diese ist übrigens automatisch verfügbar, ohne dass Sie zuvor einen Verweis auf den Namespace System.Diagnostics <\/b>hinzufügen müssen. Wenn Sie dann die Einfügemarke in der Prozedur platzieren und auf die Start-Schaltfläche klicken oder die Taste F5<\/b> betätigen, führt LINQPad die Prozedur aus und das Ergebnis landet im Results<\/b>-Bereich von LINQPad (siehe Bild 1).<\/p>\n

\"Einfache<\/p>\n

Bild 1: Einfache Eingabe von Prozeduren<\/span><\/b><\/p>\n

Visual Studio fernsteuern<\/h2>\n

Nun wollen wir von LINQPad aus die aktuelle Visual Studio-Instanz fernsteuern. Dazu benötigen wir zunächst zwei Verweise.<\/p>\n

Diese fügen wir über einen Dialog hinzu, den wir mit der Taste F4 <\/b>öffnen. Der nun erscheinende Dialog Query Properties <\/b>enthält eine Schaltfläche namens Add…<\/b>, mit der wir einen weiteren Dialog namens Add Custom Assembly References <\/b>anzeigen.<\/p>\n

Hier können Sie die angezeigte Liste aller verfügbaren Verweise schnell durch die Eingabe der Buchstaben env<\/b> filtern, sodass nur noch die Einträge aus Bild 2 erscheinen. Hier wählen Sie die beiden Einträge EnvDTE.dll <\/b>und EnvDTE80.dll <\/b>aus und schließen den Dialog mit der OK<\/b>-Schaltfläche.<\/p>\n

\"Hinzufügen<\/p>\n

Bild 2: Hinzufügen von Verweisen<\/span><\/b><\/p>\n

Danach zeigt der Dialog Query Properties <\/b>die hinzugefügten Verweise an (siehe Bild 3). Damit können Sie auch diesen Dialog schließen.<\/p>\n

\"Neu<\/p>\n

Bild 3: Neu hinzugefügte Verweise<\/span><\/b><\/p>\n

Referenzieren des Visual Studio-Objekts<\/h2>\n

Das oberste Element der Bibliothek zum Arbeiten mit Visual Studio ist das DTE2<\/b>-Objekt.<\/p>\n

Dieses deklarieren wir in unserer Prozedur wie folgt:<\/p>\n

Dim <\/span>objDTE As <\/span>EnvDTE80.DTE2<\/pre>\n
Dann referenzieren wir es über die Methode GetActiveObject<\/b>:<\/p>\n
objDTE = System.Runtime.InteropServices.Marshal.GetActiveObject(\"VisualStudio.DTE.15.0\")<\/pre>\n
Hier ist zu beachten, dass Sie die richtige Version angeben – hier etwa 15.0 <\/b>für Visual Studio 2017. Danach können wir mit der folgenden Anweisung etwa das aktuell angezeigte Dokument in Visual Studio ausgeben lassen:<\/p>\n
Debug.Print<\/span> (objDTE.ActiveDocument.Name.ToString())<\/pre>\n
Das Ergebnis sieht schließlich wie in Bild 4 aus. Gemessen daran, wie lange es dauert, einen Zugriff auf Elemente der Benutzeroberfläche von Visual Studio auszuprobieren, wenn wir diese innerhalb einer Visual Studio-Erweiterung testen, geschieht dies außerdem rasend schnell. Damit haben wir also ein Werkzeug, um uns komfortabel die Elemente des Objektmodells für den Zugriff auf Visual Studio anzusehen.<\/p>\n
\"Zugriff<\/p>\n
Bild 4: Zugriff auf Visual Studio<\/span><\/b><\/p>\n
Elemente des DTE2-Objekts<\/h2>\n
Das DTE2<\/b>-Objekt hat folgende für uns interessante Eigenschaften:<\/p>\n