Domande frequenti: conversione di componenti aggiuntivi in VSPackage Extensions

Articolo
06/10/2015

I componenti aggiuntivi sono deprecati. Per creare una nuova estensione di Visual Studio, è necessario creare un VSPackage. Se si ha già un componente aggiuntivo, potrebbe essere possibile eseguirlo, ma per distribuirlo è necessario convertirlo in un VSPackage. Di seguito sono riportate le risposte ad alcune domande frequenti relative alle operazioni di conversione di un componente aggiuntivo di Visual Studio in un'estensione VSPackage.

Importante

In molti casi è possibile trasferire semplicemente il codice del componente aggiuntivo in un progetto di VSPackage.È possibile ottenere l'oggetto di automazione DTE chiamando GetService nel metodo Initialize.

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

Per altre informazioni, vedere Come è possibile eseguire il codice del componente aggiuntivo in un VSPackage? di seguito.

Quale software si deve usare per sviluppare estensioni VSPackage?

È necessario installare Visual Studio 2013 SDK e l'edizione Professional, Premium o Ultimate di Visual Studio 2013. È possibile scaricare l'SDK dalla pagina Visual Studio 2013 SDK nell'Area download Microsoft. È consigliabile installare l'SDK prima di installare Visual Studio 2013 Update 2.

Dove è possibile trovare la documentazione relativa a VSPackage?

Iniziare dall'articolo Cenni preliminari sull'estensione di Visual Studio. Gli altri articoli relativi allo sviluppo di estensioni VSPackage sono organizzati al suo interno.

È possibile convertire un progetto di componente aggiuntivo in un progetto VSPackage?

Non è possibile convertire un progetto di componente aggiuntivo in un progetto VSPackage perché i meccanismi usati nei progetti VSPackage sono diversi da quelli usati nei progetti di componenti aggiuntivi. Il modello di progetto VSPackage contiene una grande quantità di codice che semplifica la creazione di un'estensione VSPackage.

Come si inizia a sviluppare estensioni VSPackage?

Il modello di progetto per le estensioni VSPackage contiene tutti gli elementi necessari. Ecco come creare un VSPackage contenente un comando di menu:

Creare un progetto Package Visual Studio e assegnargli il nome TestVSPackage. (File, Nuovo, Progetto o digitare progetto nella finestra Avvio veloce). Nella finestra di dialogo Nuovo progetto espandere Altri tipi di progetto, Extensibility e quindi fare clic su Package Visual Studio. Assegnare al progetto il nome TestVSPackage e specificare un percorso.
Verrà visualizzata la Creazione guidata pacchetto di Visual Studio. Nella pagina Selezionare un linguaggio di programmazione scegliere C#. Mantenere selezionata l'opzione Genera una nuova chiave. Nella pagina Opzioni VSPackage selezionare Comando di menu. Fare clic sul pulsante Fine.
Premere F5 per compilare ed eseguire il progetto in modalità di debug.

Verrà visualizzata una seconda istanza di Visual Studio. Questa seconda istanza è chiamata istanza sperimentale e potrebbe non presentare le stesse impostazioni dell'istanza di Visual Studio che si sta usando per scrivere il codice. La prima volta che si esegue l'istanza sperimentale, verrà richiesto di accedere a Visual Studio Online e specificare il tema e il profilo.

Nel menu Strumenti dell'istanza sperimentale dovrebbe essere visualizzato un pulsante denominato Nome comando. Quando si sceglie questo pulsante, viene visualizzato il messaggio seguente: All'interno di TestVSPackagePackage.MenuItemCallback().

Come è possibile eseguire il codice del componente aggiuntivo in un VSPackage?

Il codice del componente aggiuntivo viene in genere eseguito in uno dei due modi seguenti:

È attivato automaticamente da un comando di menu (il codice si trova nel metodo IDTCommandTarget.Exec)
Automaticamente all'avvio (il codice si trova nel gestore eventi OnConnection)

È possibile procedere nello stesso modo in un VSPackage. Ecco come è possibile aggiungere il codice del componente aggiuntivo nel metodo di callback:

Creare un VSPackage contenente un comando di menu. Per informazioni, vedere Come si inizia a sviluppare estensioni VSPackage?.
Aprire il file che contiene la definizione del VSPackage. In un progetto C#, corrisponde a <nome del progetto>Package.cs.
Aggiungere al file le istruzioni using seguenti:
```
using EnvDTE;
using EnvDTE80;
```
Trovare il metodo MenuItemCallback. Aggiungere una chiamata a GetService per recuperare l'oggetto DTE2:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Aggiungere il codice presente nel metodo IDTCommandTarget.Exec del componente aggiuntivo. Di seguito è illustrato un esempio di codice che aggiunge un nuovo riquadro alla finestra Output e stampa il testo "Some Text" nel nuovo riquadro.

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

Compilare ed eseguire il progetto. Premere F5 o selezionare Start sulla barra degli strumenti Debug. Nel menu Strumenti dell'istanza sperimentale di Visual Studio dovrebbe essere visualizzato un pulsante denominato Nome comando. Dopo avere premuto questo pulsante, le parole Some Text dovrebbero essere visualizzate nel riquadro della finestra Output. Potrebbe essere necessario dover aprire la finestra Output.

È anche possibile scegliere di eseguire il codice all'avvio. Tuttavia, questo approccio è generalmente sconsigliato per le estensioni VSPackage. Se all'avvio di Visual Studio vengono avviate troppe estensioni, il tempo di avvio potrebbe risultare molto più lungo. È invece consigliabile caricare automaticamente l'estensione VSPackage solo in determinate soluzioni, ad esempio all'apertura di una soluzione.

Questa procedura spiega come aggiungere il codice del componente aggiuntivo in un VSPackage che viene caricato automaticamente all'apertura di una soluzione.

Per caricare automaticamente un VSPackage

Creare un componente aggiuntivo per Visual Studio Per la procedura vedere: Come si inizia a sviluppare estensioni VSPackage? Assegnare al progetto il nome TestAutoload e specificare un percorso.
Verrà visualizzata la Creazione guidata pacchetto di Visual Studio. Nella pagina Selezionare un linguaggio di programmazione scegliere C# e mantenere selezionata l'opzione Genera una nuova chiave. Scegliere Fine.
Aprire TestAutoloadPackage.cs. Individuare la riga in cui è dichiarata la classe del pacchetto:
```
public sealed class <name of your package>Package : Package
```
Sopra questa riga è presente un set di attributi. Aggiungere questo attributo:
```
[ProvideAutoLoad(UIContextGuids80.SolutionExists)]
```
Impostare un punto di interruzione nel metodo Initialize() e avviare il debug (F5).
Aprire un progetto nell'istanza sperimentale. Il VSPackage verrà caricato e verrà raggiunto il punto di interruzione.

È possibile specificare altri contesti in cui caricare il VSPackage usando i campi di UIContextGuids80. Per altre informazioni, vedere Procedura: carico automatico un VSPackage.

Come si recupera l'oggetto DTE?

Se il componente aggiuntivo non mostra un'interfaccia utente, ad esempio comandi di menu, pulsanti della barra degli strumenti o finestre degli strumenti, potrebbe essere possibile usare il codice così com'è purché si recuperi l'oggetto di automazione DTE dal VSPackage. Ecco come:

Per recuperare l'oggetto DTE da un VSPackage

In una soluzione VSPackage cercare il file <nome progetto>Package.cs. Si tratta della classe che deriva da Package e consente di interagire con Visual Studio. In questo caso, usare il relativo GetService per recuperare l'oggetto DTE2.
Aggiungere queste istruzioni using:
```
using EnvDTE;
using EnvDTE80;
```
Trovare il metodo Initialize. Questo metodo gestisce i comandi specificati nella creazione guidata del pacchetto. Aggiungere una chiamata a GetService per recuperare l'oggetto DTE:
```
DTE dte = (DTE)GetService(typeof(DTE));
```

Dopo avere recuperato l'oggetto di automazione DTE, è possibile aggiungere la parte rimanente del codice del componente aggiuntivo al progetto. Se occorre l'oggetto DTE2, è possibile procedere nello stesso modo.

Le estensioni VSPackage usano il file con estensione vsct per creare la maggior parte dei comandi di menu, delle barre degli strumenti, dei pulsanti della barra degli strumenti e altri elementi dell'interfaccia utente. Nel modello di progetto VSPackage è disponibile l'opzione per creare un comando nel menu Strumenti. Per altre informazioni, vedere procedura dettagliata: Creazione di un comando di menu utilizzando il modello importa pacchetto Visual Studio.

Per altre informazioni sui file .vsct, vedere Come Vspackage aggiunge gli elementi dell'interfaccia utente dell'IDE. Per le procedure dettagliate che illustrano come usare il file VSCT per aggiungere voci di menu, barre degli strumenti e pulsanti della barra degli strumenti, vedere Procedure dettagliate per i controlli, i menu e le barre degli strumenti.

Come è possibile aggiungere finestre degli strumenti personalizzate con lo stile del VSPackage?

Nel modello di progetto VSPackage è disponibile l'opzione per creare una finestra degli strumenti. Per altre informazioni, vedere l'argomento Finestre degli strumenti e gli articoli in esso contenuti, in particolare Procedura: Per creare una finestra degli strumenti.

Come è possibile gestire finestre di Visual Studio con lo stile del VSPackage?

Se il componente aggiuntivo gestisce le finestre di Visual Studio, il codice del componente aggiuntivo dovrebbe funzionare in un VSPackage. Ad esempio, questa procedura spiega come aggiungere codice che gestisce l'Elenco attività nel metodo MenuItemCallback del VSPackage.

Per inserire il codice di gestione delle finestre da un componente aggiuntivo in un VSPackage

Creare un VSPackage contenente un comando di menu, come nella sezione Come si inizia a sviluppare estensioni VSPackage?.
Aprire il file che contiene la definizione del VSPackage. In un progetto C#, corrisponde a <nome del progetto>Package.cs.
Aggiungere queste istruzioni using:
```
using EnvDTE;
using EnvDTE80;
```
Trovare il metodo MenuItemCallback. Aggiungere una chiamata a GetService per recuperare l'oggetto DTE2:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Aggiungere il codice dal componente aggiuntivo. Ad esempio, qui viene mostrato il codice per aggiungere nuove attività all'Elenco attività, visualizzare il numero di attività e quindi eliminare un'attività.

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

Come è possibile gestire progetti e soluzioni in un VSPackage?

Se il componente aggiuntivo gestisce progetti e soluzioni, il codice del componente aggiuntivo dovrebbe funzionare in un VSPackage. Questa procedura spiega come aggiungere il codice che ottiene il progetto di avvio.

Creare un VSPackage contenente un comando di menu, come nella sezione Come si inizia a sviluppare estensioni VSPackage?.
Aprire il file che contiene la definizione del VSPackage. In un progetto C#, corrisponde a <nome del progetto>Package.cs.
Aggiungere queste istruzioni using:
```
using EnvDTE;
using EnvDTE80;
```
Trovare il metodo MenuItemCallback. Aggiungere una chiamata a GetService per recuperare l'oggetto DTE2:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Aggiungere il codice dal componente aggiuntivo. Nel codice seguente viene recuperato il nome del progetto di avvio in una soluzione. Durante l'esecuzione di questo pacchetto, deve essere aperta una soluzione multiprogetto.

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

Come è possibile impostare le scelte rapide da tastiera in un VSPackage?

È necessario usare l'elemento <KeyBindings> del file VSCT. Nell'esempio seguente la scelta rapida da tastiera per il comando idCommand1 è ALT+A e la scelta rapida da tastiera per il comando idCommand2 è ALT+CTRL+A. Osservare la sintassi per i nomi dei tasti.

<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>

Come è possibile gestire gli eventi di automazione in un VSPackage?

Gli eventi di automazione in un VSPackage e nel componente aggiuntivi vengono gestiti nello stesso modo. L'esempio di codice seguente mostra come gestire l'evento OnItemRenamed. In questo esempio si presuppone che l'oggetto DTE sia già stato recuperato.

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