FAQ: Konvertieren von Add-Ins in VSPackage-Erweiterungen

Artikel
06/10/2015

Add-Ins sind jetzt veraltet. Um neue Visual Studio-Erweiterungen zu erstellen, müssen Sie ein VSPackage erstellen. Vorhandene Add-Ins können Sie weiter verwenden, jedoch keine neuen erstellen. Es wird jedoch empfohlen, Add-Ins in VSPackages zu konvertieren, wenn Sie diese verteilen möchten. Im Folgenden finden Sie Antworten zu häufig gestellten Fragen zum Konvertieren eines Add-Ins in eine VSPackage-Erweiterung.

Wichtig

In vielen Fällen können Sie einfach den Add-In-Code in ein VSPackage-Projekt übertragen.Das DTE-Automatisierungsobjekt können Sie durch Aufrufen von GetService in der Initialize-Methode abrufen.

DTE2 dte = (DTE2)GetService(typeof(DTE));

Weitere Informationen finden Sie unter Wie kann ich meinen Add-In-Code in einem VSPackage ausführen? unten.

Welche Software benötige ich, um VSPackage-Erweiterungen zu erstellen?

Sie müssen Visual Studio 2013 SDK zusätzlich zur Edition Professional, Premium oder Ultimate von Visual Studio 2013 installieren. Sie können das SDK auf der Microsoft Download Center-Website von der Seite für Visual Studio 2013 SDK herunterladen. Es wird empfohlen, das SDK zu installieren, bevor Sie Visual Studio 2013 Update 2 installieren.

Wo befindet sich die Dokumentation zu VSPackages?

Beginnen Sie mit Erweitern von Visual Studio Overview. Weitere Artikel zur Entwicklung von VSPackages sind unter diesem Artikel organisiert.

Kann ich ein Add-In-Projekt in ein VSPackage-Projekt konvertieren?

Sie können ein Add-In-Projekt nicht in ein VSPackage-Projekt konvertieren, da sich die verwendeten Mechanismen in VSPackage-Projekten und Add-In-Projekten unterscheiden. Die VSPackage-Projektvorlage verfügt über viel Code, wodurch sie schnell als VSPackage-Erweiterung eingerichtet und ausgeführt werden kann.

Wie beginne ich mit der Entwicklung von VSPackage-Erweiterungen?

Die Projektvorlage für VSPackage-Erweiterungen enthält alle Elemente, die Sie benötigen. So erstellen Sie ein VSPackage mit Menübefehl:

Erstellen eines VSPackages, das über einen Menübefehl verfügt

Erstellen Sie ein neues Visual Studio-Paketprojekt, und nennen Sie es TestVSPackage. (Datei, Neu, Projekt oder geben Sie Projekt im Fenster Schnellstart ein). Erweitern Sie im Dialogfeld Neues Projekt Andere Projekttypen, Erweiterungen, und wählen Sie dann Visual Studio-Paket aus. Nennen Sie das Projekt TestVSPackage, und geben Sie einen Speicherort an.
Der Assistent für das Visual Studio-Paket wird angezeigt. Wählen Sie auf der Seite Wählen Sie eine Programmiersprache C# als Programmiersprache aus. Behalten Sie die Aktivierung der Option Neuen Schlüssel generieren bei. Auf der Seite VSPackage-Optionen wählen Sie Menübefehl aus. Wählen Sie die Schaltfläche Fertig stellen aus.
Drücken Sie F5, um das Projekt im Debugmodus zu erstellen und auszuführen.

Eine zweite Instanz von Visual Studio wird geöffnet. Diese zweite Instanz wird experimentelle Instanz genannt und besitzt möglicherweise nicht die gleichen Einstellungen wie die Instanz von Visual Studio, die Sie zum Schreiben von Code verwenden. Wenn Sie die experimentelle Instanz zum ersten Mal ausführen, müssen Sie sich bei VS Online anmelden und Ihr Design und Profil festlegen.

Im Menü Extras (in der experimentellen Instanz) sollte eine Schaltfläche mit dem Namen My Command name angezeigt werden. Wenn Sie diese Schaltfläche wählen, sollte eine Meldung angezeigt werden: Inside TestVSPackagePackage.MenuItemCallback().

Wie kann ich Add-In-Code in einem VSPackage ausführen?

Add-In-Code kann auf zwei Arten ausgeführt werden:

Ausgelöst durch einen Menübefehl (Der Code befindet sich in der IDTCommandTarget.Exec-Methode.)
Automatisch beim Start (Der Code befindet sich im OnConnection-Ereignishandler.)

Das Gleiche ist in einem VSPackage möglich. So fügen Sie Add-In-Code zur Rückrufmethode hinzu:

Implementieren eines Menübefehls in ein VSPackage

Erstellen Sie ein VSPackage, das über einen Menübefehl verfügt. (Siehe Wie beginne ich mit der Entwicklung von VSPackage-Erweiterungen?)
Öffnen Sie die Datei, in der die Definition des VSPackage enthalten ist. (In einem C#-Project ist es <Projektname>Package.cs.)
Fügen Sie folgende using-Anweisungen in die Datei ein:
```
using EnvDTE;
using EnvDTE80;
```
Suchen Sie die MenuItemCallback-Methode. Fügen Sie einen Aufruf zu GetService hinzu, um das DTE2-Objekt abzurufen:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Fügen Sie den Code aus der IDTCommandTarget.Exec-Methode des Add-Ins hinzu. Das Beispiel enthält Code, der einen neuen Bereich zum Ausgabefenster hinzufügt, und im neuen Bereich den Text "Some Text" druckt.

private void MenuItemCallback(object sender, EventArgs e)
{
    DTE2 dte = (DTE2) GetService(typeof(DTE));
    OutputWindow outputWindow = dte.ToolWindows.OutputWindow;

    OutputWindowPane outputWindowPane = outputWindow.OutputWindowPanes.Add("A New Pane");
    outputWindowPane.OutputString("Some Text");
}

Erstellen Sie das Projekt, und führen Sie es aus. Drücken Sie F5, oder wählen Sie Start auf der Symbolleiste Debuggen aus. In der experimentellen Instanz von Visual Studio sollte im Menü Extras eine Schaltfläche mit dem Namen My Command name angezeigt werden. Wenn Sie diese Schaltfläche auswählen, sollten die Worte Some Text in einem Ausgabefensterbereich angezeigt werden. (Möglicherweise müssen Sie das Ausgabefenster öffnen.)

Sie können den Code auch beim Start ausführen lassen. Dieser Ansatz wird jedoch für VSPackage-Erweiterungen generell nicht empfohlen. Wenn beim Start von Visual Studio versucht wird, zu viele Erweiterungen zu laden, kann sich die Startzeit erheblich verlängern. Eine bessere Vorgehensweise ist es, das VSPackage nur automatisch zu laden, wenn eine Bedingung erfüllt ist (beispielsweise, wenn eine Projektmappe geöffnet wird).

Dieses Verfahren zeigt, wie Sie Add-In-Code in einem VSPackage ausführen können, das automatisch geladen wird, wenn eine Projektmappe geöffnet wird:

Automatisches Laden eines VSPackages

Erstellen Sie ein Visual Studio-Paketprojekt. (Anweisungen hierzu finden Sie unter Wie beginne ich mit der Entwicklung von VSPackage-Erweiterungen?. Nennen Sie das Projekt TestAutoload, und geben Sie einen Speicherort an.
Der Assistent für das Visual Studio-Paket wird angezeigt. Wählen Sie auf der Seite Wählen Sie eine Programmiersprache C# als Programmiersprache aus. Behalten Sie die Aktivierung der Option Neuen Schlüssel generieren bei. Wählen Sie Fertig stellen aus.
Öffnen Sie TestAutoloadPackage.cs. Suchen Sie die Zeile, in der die Paketklasse deklariert ist:
```
public sealed class <name of your package>Package : Package
```
Über dieser Zeile befindet sich ein Satz Attribute. Fügen Sie dieses Attribut hinzu:
```
[ProvideAutoLoad(UIContextGuids80.SolutionExists)]
```
Setzen Sie einen Haltepunkt in der Initialize()-Methode, und starten Sie das Debuggen (F5).
Öffnen Sie in der experimentellen Instanz ein Projekt. Das VSPackage sollte geladen und der Haltepunkt erreicht werden.

Sie können andere Kontexte angeben, in denen das VSPackage geladen werden soll, indem Sie die Felder von UIContextGuids80 verwenden. Weitere Informationen finden Sie unter Gewusst wie: Automatisches Laden von VSPackages.

Wie kann ich das DTE-Objekt abrufen?

Wenn das Add-In kein Benutzeroberfläche – zum Beispiel Menübefehle, Schaltflächen der Symbolleiste oder Toolfenster – anzeigt, können Sie möglicherweise den Code unverändert nutzen, solange Sie das DTE-Automatisierungsobjekt aus dem VSPackage abrufen. Gehen Sie dabei folgendermaßen vor:

Abrufen des DTE-Objekts aus einem VSPackage

Suchen Sie in einer VSPackage-Projektmappe nach der Datei <Projektname>Package.cs. Dies ist die Klasse, die von Package abgeleitet wird. Sie kann Ihnen helfen, mit Visual Studio zu interagieren. In diesem Fall verwenden Sie die GetService-Methode, um das DTE2-Objekt zu suchen.
Fügen Sie diese using-Anweisungen hinzu:
```
using EnvDTE;
using EnvDTE80;
```
Suchen Sie die Initialize-Methode. Diese Methode behandelt den Befehl, den Sie im Paket-Assistenten angegeben haben. Fügen Sie einen Aufruf zu GetService hinzu, um das DTE-Objekt abzurufen:
```
DTE dte = (DTE)GetService(typeof(DTE));
```

Wenn Sie das DTE-Automatisierungsobjekt abgerufen haben, können Sie den übrigen Code zum Projekt hinzufügen. Wenn Sie das DTE2-Objekt benötigen, können Sie ebenso verfahren.

Wie ändere ich Menübefehle und Schaltflächen der Symbolleisten im Add-In in den Stil des VSPackages?

VSPackage-Erweiterungen nutzen die .vsct-Datei zur Erstellung der meisten Menübefehle, Symbolleisten, Schaltflächen der Symbolleisten und anderer Elemente der Benutzeroberfläche. Mit der VSPackage-Projektvorlage können Sie einen Befehl im Menü Extras erstellen. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Wenn Sie einen Menübefehl mit der Visual Studio-Paket-Vorlage erstellen.

Weitere Informationen zu VSCT-Dateien finden Sie unter Wie VSPackages Benutzeroberflächenelemente Hinzufügen der IDE. Exemplarische Vorgehensweisen für die Verwendung von .vsct-Dateien zum Hinzufügen von Menübefehlen, Symbolleisten und Schaltflächen der Symbolleisten finden Sie unter Exemplarische Vorgehensweisen für Befehle, Menüs und Symbolleisten.

Wie füge ich in VSPackages benutzerdefinierte Toolfenster hinzu?

Mit der VSPackage-Projektvorlage können Sie ein Toolfenster erstellen. Weitere Informationen finden Sie unter Toolfenster und den darunter aufgelisteten Artikeln, insbesondere Gewusst wie: Erstellen Sie ein Toolfenster erstellen.

Wie verwalte ich Visual Studio-Fenster mit VSPackages?

Wenn das Add-In Visual Studio-Fenster verwaltet, sollte der Code des Add-Ins auch in einem VSPackage funktionieren. Dieser Vorgang zeigt beispielsweise, wie Sie Code hinzufügen können, der die Aufgabenliste zur MenuItemCallback-Methode des VSPackages verwaltet.

Einfügen von Code zur Fensterverwaltung von einem Add-In in ein VSPackage

Erstellen Sie ein VSPackage mit einem Menübefehl, wie im Abschnitt Wie beginne ich mit der Entwicklung von VSPackage-Erweiterungen? beschrieben.
Öffnen Sie die Datei, in der die Definition des VSPackage enthalten ist. (In einem C#-Project ist es <Projektname>Package.cs.)
Fügen Sie diese using-Anweisungen hinzu:
```
using EnvDTE;
using EnvDTE80;
```
Suchen Sie die MenuItemCallback-Methode. Fügen Sie einen Aufruf zu GetService hinzu, um das DTE2-Objekt abzurufen:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Fügen Sie den Code aus dem Add-In hinzu. Dieses Beispiel enthält Code, der neue Aufgaben zur Aufgabenliste hinzufügt, die Anzahl der Aufgaben auflistet und anschließend eine Aufgabe löscht.

private void MenuItemCallback(object sender, EventArgs e) 
{
    DTE2 dte = (DTE2) GetService(typeof(DTE)); 

    TaskList tl = (TaskList)dte.ToolWindows.TaskList; 
    askItem tlItem; 

    // Add a couple of tasks to the Task List. 
    tlItem = tl.TaskItems.Add(" ", " ", "Test task 1.",  
        vsTaskPriority.vsTaskPriorityHigh, vsTaskIcon.vsTaskIconUser, 
        true, "", 10, true, true);
    tlItem = tl.TaskItems.Add(" ", " ", "Test task 2.", 
        vsTaskPriority.vsTaskPriorityLow, vsTaskIcon.vsTaskIconComment, true, "", 20, true,true);

    // List the total number of task list items after adding the new task items.
    System.Windows.Forms.MessageBox.Show("Task Item 1 description: "+tl.TaskItems.Item(2).Description);
    System.Windows.Forms.MessageBox.Show("Total number of task items: "+tl.TaskItems.Count); 

    // Remove the second task item. The items list in reverse numeric order. 
    System.Windows.Forms.MessageBox.Show("Deleting the second task item");
    tl.TaskItems.Item(2).Delete();
    System.Windows.Forms.MessageBox.Show("Total number of task items: "+tl.TaskItems.Count); 
}

Wie verwalte ich Projekte und Projektmappen in einem VSPackage?

Wenn das Add-In Projekte und Projektmappen verwaltet, sollte der Code des Add-Ins auch in einem VSPackage funktionieren. Dieser Vorgang zeigt beispielsweise, wie Sie Code hinzufügen können, der das Startprojekt abruft.

Erstellen Sie ein VSPackage mit einem Menübefehl, wie im Abschnitt Wie beginne ich mit der Entwicklung von VSPackage-Erweiterungen? beschrieben.
Öffnen Sie die Datei, in der die Definition des VSPackage enthalten ist. (In einem C#-Project ist es <Projektname>Package.cs.)
Fügen Sie diese using-Anweisungen hinzu:
```
using EnvDTE;
using EnvDTE80;
```
Suchen Sie die MenuItemCallback-Methode. Fügen Sie einen Aufruf zu GetService hinzu, um das DTE2-Objekt abzurufen:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Fügen Sie den Code aus dem Add-In hinzu. Der folgende Code ruft beispielsweise den Namen eine Startprojekts in einer Projektmappe ab. (Eine Projektmappe mit mehreren Projekten muss geöffnet sein, wenn dieses Paket ausgeführt wird.)

private void MenuItemCallback(object sender, EventArgs e)
{
    DTE2 dte = (DTE2) GetService(typeof(DTE)); 

    SolutionBuild2 sb = (SolutionBuild2)dte.Solution.SolutionBuild; 
    Project startupProj; 
    string msg = "";

    foreach (String item in (Array)sb.StartupProjects) 
    {
        msg += item; 
    }
    System.Windows.Forms.MessageBox.Show("Solution startup Project: "+msg); 
    startupProj = dte.Solution.Item(msg); 
    System.Windows.Forms.MessageBox.Show("Full name of solution's startup project: "+"/n"+startupProj.FullName); 
}

Wie lege ich Tastenkombinationen in einem VSPackage fest?

Verwenden Sie das <KeyBindings>-Element der .vsct-Datei. Im folgenden Beispiel ist die Tastenkombination für den Befehl idCommand1 Alt+A. Die Tastenkombination für den Befehl idCommand2 ist Alt+Ctrl+A. Beachten Sie die Sytax für die Schlüsselnamen.

<KeyBindings>
    <KeyBinding guid="MyProjectCmdSet" id="idCommand1" editor="guidVSStd97" key1="A" mod1="ALT" />
    <KeyBinding guid="MyProjectCmdSet" id="idCommand2" editor="guidVSStd97" key1="A" mod1="CONTROL" mod2="ALT" />
</KeyBindings>

Wie behandle ich Automatisierungsereignisse in einem VSPackage?

Automatisierungsereignisse in einem VSPackage behandeln Sie genauso wie im Add-In. Im folgenden Codebeispiel wird die Behandlung des OnItemRenamed-Ereignisses veranschaulicht. (In diesem Beispiel wird angenommen, dass Sie das DTE-Objekt bereits abgerufen haben.)

Events2 dteEvents = (Events2)dte.Events;
dteEvents.ProjectItemsEvents.ItemRenamed += listener1.OnItemRenamed; 
. . .
public void OnItemRenamed(EnvDTE.ProjectItem projItem, string oldName) 
{
    string s = "[Event] Renamed " + oldName + " to " + Path.GetFileName(projItem.get_FileNames(1) + " in project " + projItem.ContainingProject.Name; 
}