procedura dettagliata: L'integrazione nella Finestra Proprietà, nell'elenco attività, nella Finestra di output e nella finestra di dialogo Opzioni (parte 4 a 4)

Articolo
05/17/2015

Utilizzando Visual Studio SDK, è possibile consentire al codice di accedere a tutte le finestre degli strumenti in Visual Studio. Ad esempio, è possibile aggiungere voci a Elenco attività, aggiungere il testo alla finestra di output, o integrare estensione nella finestra di Proprietà che consente agli utenti di configurare l'estensione impostando le proprietà. In questa procedura dettagliata viene illustrato come integrare l'estensione nelle finestre degli strumenti in Visual Studio.

Completare questa procedura dettagliata, è possibile informazioni su come effettuare le seguenti operazioni:

Creare un package VS utilizzando il modello importa pacchetto.
Implementare la finestra degli strumenti generata un'eccezione.
Implementare un gestore di comandi di menu.
creare una pagina di opzioni.
Rendere i dati della finestra di Proprietà .
Integrare nella Finestra Proprietà.
Aggiungere il testo alla finestra di output e gli elementi a Elenco attività.

In questa procedura dettagliata fa parte di una serie in cui viene illustrato come estendere l'IDE di Visual Studio. Per ulteriori informazioni, vedere Procedure dettagliate per personalizzare Visual Studio tramite package VS..

Prerequisiti

Per completare questa procedura dettagliata, è necessario installare Visual Studio 2010 SDK.

Nota

per ulteriori informazioni su Visual Studio SDK, vedere Cenni preliminari sull'estensione di Visual Studio.Per ulteriori informazioni su come scaricare Visual Studio SDK, vedere Centro per sviluppatori di estensibilità di Visual Studio il sito Web MSDN.

Posizioni del modello di progetto del pacchetto Visual Studio

Il modello di progetto del pacchetto Visual Studio è disponibile in tre posizioni diverse nella finestra di dialogo di nuovo progetto :

Sotto di estensibilità di Visual Basic. La lingua predefinita del progetto di Visual Basic.
Sotto di estensibilità di c#. La lingua predefinita del progetto è c#.
Nell'ambito dell'altra estensibilità dei tipi di progetto. La lingua predefinita del progetto è C++.

Creare un package VS utilizzando il modello importa pacchetto Visual Studio

Per creare un package VS

creare un VSPackage. Per ulteriori informazioni su come creare un package VS, vedere procedura dettagliata: Creazione di un comando di menu utilizzando il modello importa pacchetto Visual Studio.
Denominare il progetto TodoList, impostare il linguaggio con Visual c# o Visual Basic e nella pagina di Opzioni selezionate di un VSPackage , selezionare sia comando di menu che Finestra degli strumenti.
Nella pagina di ordinare le opzioni , impostare Nome del comando a amministratore di Todo e ID di comando a cmdidTodoCommand.
Nella pagina di Opzioni della finestra degli strumenti , impostare Nome della finestra a amministratore di Todo e ID di comando a cmdidTodoTool.
Fare clic su Fine.

Implementare la finestra degli strumenti generata

Il modello del pacchetto è stata generata una finestra degli strumenti di base sotto forma di controllo utente. Tuttavia, non dispone di funzionalità. Per fornire la funzionalità, è necessario aggiungere i controlli figlio e modificare il codice in MyControl.xaml.cs o in MyControl.vb.

La finestra degli strumenti incorporata TextBox in cui digitare un nuovo elemento di ToDo, Button per aggiungere il nuovo elemento all'elenco e ListBox per visualizzare gli elementi nell'elenco. La finestra degli strumenti completata sarà simile all'immagine seguente:

Finestra degli strumenti finita

Per aggiungere controlli alla finestra degli strumenti

Eliminare il pulsante, il testo e i controlli di elemento StackPanel dalla griglia.

Nota

Questa operazione non elimina il gestore eventi button1_Click, che se in un passaggio successivo.
Dalla sezione di Tutti i controlli WPF di Casella degli strumenti, trascinare un controllo di area di disegno alla griglia.
Trascinare un controllo TextBox, un pulsante e un controllo ListBoxarea di disegno. Disporli come nella figura precedente.
selezionare il pulsante. Impostare la proprietà di contenuto a aggiungere.

Nel riquadro XAML, riconnettere il gestore eventi del pulsante sul pulsante aggiungendo un attributo di Click= " button1_Click„. La linea risultante XAML dovrebbe risultare simile al seguente:

Public _parent As MyToolWindow
Public Sub New(ByVal parent As MyToolWindow)
    InitializeComponent()
    _parent = parent
End Sub

<Button Content="Add" Height="21" Name="button1" Width="50" Canvas.Left="345" Canvas.Top="6" Click="button1_Click" />

Salvare il lavoro.

Per impostazione predefinita, il costruttore del controllo utente nel file di MyControl.xaml.vb o di MyControl.xaml.cs non accetta parametri. Tuttavia, è possibile personalizzare il costruttore per includere parametri in modo che sia possibile salvare il padre per un utilizzo successivo.

Per personalizzare il costruttore

La pagina di progettazione, fare clic con il pulsante destro del mouse su Visualizza codice.
Sostituire il costruttore esistente con il codice seguente:
```
public MyToolWindow _parent;
public MyControl(MyToolWindow parent)
{
    InitializeComponent();
    _parent = parent;
}
```
Questa operazione consente al costruttore per accettare un parametro di tipo MyToolWindow.
Salvare il lavoro.
A questo punto, aggiungere un parametro al codice che chiama il costruttore.

in Esplora soluzioni, aprire MyToolWindow.cs o MyToolWindow.vb.
Individuare la riga nel costruttore di MyToolWindow simile al seguente codice.
```
Me.Content = New MyControl()
```
```
base.Content = new MyControl();
```
Modificare la riga come illustrato di seguito.
```
Me.Content = New MyControl(Me)
```
```
base.Content = new MyControl(this);
```
Questo scopo passa l'istanza della finestra degli strumenti al controllo utente. (Questo è obbligatorio in un passaggio successivo creare il costruttore per la classe di ToDoItem).

Quando il progetto TodoList è stato creato, è incluso un gestore predefinito per la voce di menu. Il gestore è nel file di TodoListPackage. A questo punto, aggiungere codice al gestore per visualizzare la finestra degli strumenti. È possibile eseguire questa operazione solo a una coppia di passaggi perché TodoListPackage contiene già una funzione denominata ShowToolWindow.

aprire TodoListPackage.cs o TodoListPackage.vb. Si noti che il gestore della voce di menu contiene il seguente codice di esempio.

Private Sub MenuItemCallback(ByVal sender As Object, ByVal e As EventArgs)
    ' Show a Message Box to prove we were here 
    Dim uiShell As IVsUIShell = TryCast(GetService(GetType(SVsUIShell)), IVsUIShell)
    Dim clsid As Guid = Guid.Empty
    Dim result As Integer
    Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(uiShell.ShowMessageBox(0, clsid, "TodoList", String.Format(CultureInfo.CurrentCulture, "Inside {0}.MenuItemCallback()", Me.GetType().Name), String.Empty, 0, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST, OLEMSGICON.OLEMSGICON_INFO, 0, result))
End Sub

private void MenuItemCallback(object sender, EventArgs e)
{
    // Show a Message Box to prove we were here
    IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
    Guid clsid = Guid.Empty;
    int result;
    Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(uiShell.ShowMessageBox(
               0,
               ref clsid,
               "TodoList",
               string.Format(CultureInfo.CurrentCulture, "Inside {0}.MenuItemCallback()", this.ToString()),
               string.Empty,
               0,
               OLEMSGBUTTON.OLEMSGBUTTON_OK,
               OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
               OLEMSGICON.OLEMSGICON_INFO,
               0,        // false 
               out result));
}

Rimuovere tutto il contenuto della funzione e sostituirlo con una chiamata a ShowToolWindow come segue.
```
Private Sub MenuItemCallback(ByVal sender As Object, ByVal e As EventArgs)
    ShowToolWindow(sender, e)
End Sub
```
```
private void MenuItemCallback(object sender, EventArgs e)
{
    ShowToolWindow(sender, e);
}        
```
Salvare il lavoro e quindi premere F5 per compilare il progetto e per aprirlo nella compilazione sperimentale di Visual Studio. Test se la finestra degli strumenti verrà aperta facendo clic su amministratore di ToDo scegliere dal menu di strumenti .

Chiudere la compilazione sperimentale prima di continuare.

creare una pagina di opzioni

È possibile fornire una pagina nella finestra di dialogo di opzioni in modo che sia possibile modificare gli utenti impostazioni per la finestra degli strumenti. Creare una pagina delle opzioni sono necessari sia la classe che descrive le opzioni che una voce nel file di TodoListPackage.vb o di TodoListPackage.cs.

Per creare una pagina di opzioni

In Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto ToDoList, scegliere aggiungerequindi fare clic su classe.
Nella finestra di dialogo di Aggiungi nuovo elemento , denominare il file ToolsOptions.cs, o ToolsOptions.vb quindi fare clic su aggiungere.

Visual Studio crea ToolsOptions classe denominata nel file, ma è necessario modificare l'intestazione della classe in modo che derivare la classe da DialogPage.

Aggiungere lo spazio dei nomi di Microsoft.VisualStudio.Shell a un oggetto esistente utilizzando/istruzioni imports, come illustrato di seguito.
```
Imports Microsoft.VisualStudio.Shell
```
```
using Microsoft.VisualStudio.Shell;
```
modificare la dichiarazione di classe di ToolsOptions per ereditare da DialogPage.
```
Inherits DialogPage
```
```
class ToolsOptions : DialogPage
```
La pagina delle opzioni in questa procedura dettagliata verranno restituiti solo un DaysAhead denominato opzione. Per aggiungere questa opzione, aggiungere una proprietà denominata DaysAhead alla classe di ToolsOptions come segue.
```
Private _daysAhead As Double 

Public Property DaysAhead() As Double 
    Get 
        Return _daysAhead
    End Get 
    Set(ByVal value As Double)
        _daysAhead = value
    End Set 
End Property
```
```
private double _daysAhead;

public double DaysAhead
{
    get { return _daysAhead; }
    set { _daysAhead = value; }
}
```
Questa classe archivia una sola opzione come membro privato denominato _daysAhead. La classe fornisce quindi una proprietà pubblica denominata DaysAhead per accedere all'opzione.
Salvare il file.

Ora è necessario notificare al progetto di questa pagina di opzioni in modo che sia disponibile correttamente registrata e degli utenti.

Per definire le opzioni pagina disponibile agli utenti

in Esplora soluzioni, aprire TodoListPackage.cs o TodoListPackage.vb.

Individuare la riga che contiene l'attributo di ProvideToolWindowAttribute quindi aggiungere un attributo di ProvideOptionPageAttribute , come illustrato di seguito.

<PackageRegistration(UseManagedResourcesOnly:=True), _
InstalledProductRegistration("#110", "#112", "1.0", IconResourceID:=400), _
ProvideMenuResource("Menus.ctmenu", 1), _
ProvideToolWindow(GetType(MyToolWindow)), _
ProvideOptionPage(GetType(ToolsOptions), "To-Do", "General", 101, 106, True), _
Guid(GuidList.guidTodoListPkgString)> _
Public NotInheritable Class TodoListPackage
    Inherits Package

[ProvideToolWindow(typeof(MyToolWindow))]
[ProvideOptionPage(typeof(ToolsOptions), "To-Do", "General", 101, 106, true)]

Nota

Non è necessario includere la parola “attributo„ dichiarazioni di attributo.

Salvare il file.

Il primo parametro al costruttore di ProvideOptionPage è il tipo della classe ToolsOptions, creato precedentemente. Il secondo parametro, “in l„, è il nome della categoria nella finestra di dialogo di opzioni . Il terzo parametro, “generale„, è il nome della sottocategoria della finestra di dialogo di opzioni in cui la pagina delle opzioni sarà disponibile. I due parametri seguenti sono ID risorsa per le stringhe, il primo è il nome della categoria e il secondo è il nome della sottocategoria. Il parametro finale imposta se questa pagina è possibile accedere mediante l'automazione.

Quando la pagina delle opzioni viene eseguito, il risultato sarà simile all'immagine seguente.

Si noti il da fare di categoria e la sottocategoria generale di.

Rendere i dati della Finestra Proprietà

I principi seguenti per una buona progettazione orientata a oggetti, è possibile fare ToDoItem classe denominata che archivia le informazioni sui singoli elementi nell'elenco di operazioni da eseguire.

Per rendere disponibili i dati nella Finestra Proprietà

In Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto ToDoList, scegliere aggiungerequindi fare clic su classe.
Nella finestra di dialogo di Aggiungi nuovo elemento , denominare il file ToDoItem.cs o ToDoItem.vbquindi fare clic su aggiungere.

Quando la finestra degli strumenti è disponibile agli utenti, gli elementi della casella di riepilogo verranno rappresentati da istanze di ToDoItem. Quando l'utente seleziona una di queste voci nella casella di riepilogo, la finestra di Proprietà visualizzare le informazioni sull'elemento.

Per rendere disponibili i dati nella finestra di Proprietà , trasformare i dati le proprietà pubbliche di classe e quindi documentarle utilizzando due attributi, descrizione e categorie speciali. La descrizione è il testo visualizzato nella parte inferiore della finestra di Proprietà . La categoria definisce dove la proprietà deve essere visualizzato quando la finestra di Proprietà la visualizzazione per categoria. Nella seguente immagine, la finestra di Proprietà è in una visualizzazione per categoria, la proprietà di Nome nella categoria di Campi di da eseguire è selezionata e la descrizione della proprietà di Nome visualizzata nella parte inferiore della finestra.

Aggiungere i seguenti spazi dei nomi all'inizio del file di ToDoItem.vb o di ToDoItem.cs, dopo l'esistenza mediante/istruzioni imports.

Imports System.ComponentModel
Imports System.Windows.Forms
Imports Microsoft.VisualStudio.Shell.Interop

using System.ComponentModel;
using System.Windows.Forms;
using Microsoft.VisualStudio.Shell.Interop;

Avviare che implementa la classe di ToDoItem come segue. Assicurarsi di aggiungere il modificatore di accesso di public alla dichiarazione di classe.

Private _name As String
<Description("Name of the To-Do item")> _
<Category("To-Do Fields")> _
Public Property Name() As String 
    Get 
        Return _name
    End Get 
    Set(ByVal value As String)
        _name = value
        _parent.UpdateList(Me)
    End Set 
End Property 

Private _dueDate As Date
<Description("Due date of the To-Do item")> _
<Category("To-Do Fields")> _
Public Property DueDate() As Date 
    Get 
        Return _dueDate
    End Get 
    Set(ByVal value As Date)
        _dueDate = value
        _parent.UpdateList(Me)
        _parent.CheckForErrors()
    End Set 
End Property

public class ToDoItem
{
    private string _name;
    [Description("Name of the To-Do item")]
    [Category("To-Do Fields")]
    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            _parent.UpdateList(this);
        }
    }

    private DateTime _dueDate;
    [Description("Due date of the To-Do item")]
    [Category("To-Do Fields")]
    public DateTime DueDate
    {
        get { return _dueDate; }
        set
        {
            _dueDate = value;
            _parent.UpdateList(this);
            _parent.CheckForErrors();
        }
    }
}

Si noti che il codice ha due proprietà, nome e DueDate. Si tratta delle due proprietà che saranno visualizzati nella finestra di Proprietà , come illustrato nell'immagine precedente. Ogni proprietà è preceduta dagli attributi e di categoria di descrizione, che forniscono informazioni per la visualizzazione nella finestra di Proprietà . Esaminare questi due attributi per la proprietà name, le stringhe devono corrispondere a quelle dell'immagine.

Aggiungere la seguente funzione costruttore all'inizio della classe.
```
Private _parent As MyControl
Public Sub New(ByVal parent As MyControl, ByVal name As String)
    _parent = parent
    _name = name
    _dueDate = Date.Now

    Dim daysAhead As Double = 0
    Dim package As IVsPackage = TryCast(_parent._parent.Package, IVsPackage)
    If package IsNot Nothing Then 
        Dim obj As Object
        package.GetAutomationObject("To-Do.General", obj)

        Dim options As ToolsOptions = TryCast(obj, ToolsOptions)
        If options IsNot Nothing Then
            daysAhead = options.DaysAhead
        End If 
    End If

    _dueDate = _dueDate.AddDays(daysAhead)
End Sub
```
```
private MyControl _parent;
public ToDoItem(MyControl parent, string name)
{
    _parent = parent;
    _name = name;
    _dueDate = DateTime.Now;

    double daysAhead = 0;
    IVsPackage package = _parent._parent.Package as IVsPackage;
    if (package != null)
    {
        object obj;
        package.GetAutomationObject("To-Do.General", out obj);

        ToolsOptions options = obj as ToolsOptions;
        if (options != null)
        {
            daysAhead = options.DaysAhead;
        }
    }

    _dueDate = _dueDate.AddDays(daysAhead);
}
```
Innanzitutto, questo codice dichiara un membro privato denominato _parent, che corrisponde al controllo utente contenente la casella di testo, il pulsante e i controlli ListBox creato precedentemente. Il costruttore accetta il controllo utente come parametro, insieme a una stringa che rappresenta il nome per questo elemento di ToDo. Le prime tre righe nel costruttore salvataggio del controllo utente, il nome e la data e l'ora corrente.

È possibile utilizzare la data e l'ora corrente come base per abilitare l'opzione di DaysAhead nella pagina di opzione creato precedentemente. Poiché la data e l'ora corrente non viene in genere utilizzata come scadenza, è possibile prevedere la data corrente dal numero di giorni specificati nella pagina di opzioni. .

Il codice dichiara una variabile locale denominata daysAhead che è impostata utilizzando il valore nell'opzione di DaysAhead. La riga successiva ottiene il padre del controllo utente e dalla, il membro del pacchetto. (Questo è il punto in cui si utilizza il membro _parent aggiunto in precedenza alla classe di MyControl.xaml.cs).

Se questo membro del package non è null, un oggetto viene dichiarato che utilizzerà l'istanza di ToolsOptions. Per ottenere l'istanza, le chiamate di codice il membro di GetAutomationObject del pacchetto e passa il nome della categoria e la sottocategoria come una singola stringa punto-delimitata, To-Do.General. I risultati vengono passati come parametro di output nella variabile obj.

La variabile obj viene quindi eseguito il cast sulla classe di ToolsOptions e viene salvata in una variabile denominata options. Se la variabile non è null, il codice ottiene il membro di DaysAhead e salvarlo nella variabile di _daysAhead .

Il codice quindi sposta la variabile diduedate _dal numero di giorni in avanti tramite il metodo di AddDays .
Poiché le istanze della classe di ToDoItem verranno archiviate nella casella di riepilogo e la casella di riepilogo chiamerà la funzione di ToString che la classe eredita dalla classe base di Object per recuperare la stringa da visualizzare per l'elemento, è necessario eseguire l'overload della funzione di ToString .

Aggiungere il seguente codice a ToDoItem.cs, dopo il costruttore e prima della fine della classe.
```
Public Overloads Overrides Function ToString() As String 
    Return (_name & " Due: ") + _dueDate.ToShortDateString()
End Function
```
```
public override string ToString()
{
    return _name + " Due: " + _dueDate.ToShortDateString();
}
```
aprire MyControl.xaml.cs o MyControl.xaml.vb.
Aggiungere i metodi stub alla classe di MyControl per i metodi di UpdateList e di CheckForError . Inserite dopo il ProcessDialogChar e prima della fine del file.
```
Public Sub CheckForErrors()

End Sub 

Public Sub UpdateList(ByVal item As ToDoItem)

End Sub
Public Sub CheckForErrors()

End Sub 

Public Sub UpdateList(ByVal item As ToDoItem)

End Sub
```
```
public void CheckForErrors()
{
}
public void UpdateList(ToDoItem item)
{
}
```
Il metodo di CheckForError chiamerà un metodo con lo stesso nome nell'oggetto padre e che il metodo verificherà se gli errori sono stati verificati e gestirli correttamente. Il metodo di UpdateList aggiornerà la casella di riepilogo nel controllo padre; il metodo viene chiamato quando le proprietà di DueDate e di Name in questa modifica della classe. Implementare questi metodi in un passaggio successivo.

Integrare nella Finestra Proprietà

Scrivere ora il codice che gestisce la casella di riepilogo, che verrà collegata alla finestra di Proprietà .

È necessario aggiungere handle del pulsante indica la casella di testo, crea un'istanza di ToDoItem e aggiungere l'istanza alla casella di riepilogo.

Per integrare con la Finestra Proprietà

Passare alla visualizzazione progettazione di MyControl.xaml, quindi fare doppio clic sul pulsante

Sostituire la funzione di gestione esistente di button1_Click tramite il codice seguente.

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles Button1.Click
    If TextBox1.Text.Length > 0 Then 
        Dim item = New ToDoItem(Me, TextBox1.Text)
        ListBox1.Items.Add(item)
        TrackSelection()
        CheckForErrors()
    End If 
End Sub

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1300:SpecifyMessageBoxOptions")]
private void button1_Click(object sender, EventArgs e)
{
    if (textBox1.Text.Length > 0)
    {
        var item = new ToDoItem(this, textBox1.Text);
        listBox1.Items.Add(item);
        TrackSelection();
        CheckForErrors();
    }
}

Questo codice crea una nuova istanza di ToDoItem e passa l'istanza del controllo utente come parametro insieme al testo che l'utente ha immesso nel controllo TextBox. Successivamente, il codice aggiunge l'elemento della casella di riepilogo. Nella casella di riepilogo chiamerà il metodo ToString dell'istanza di ToDoItem per recuperare la stringa da visualizzare nella casella di riepilogo.) Successivamente, il codice chiama la funzione di TrackSelection, che verrà scritto in un passaggio successivo. Infine, i controlli di codice per gli errori.

Passare alla visualizzazione progettazione di MyControl.xaml per aggiungere il codice che gestisce la selezione dell'utente di nuovo elemento nella casella di riepilogo.
Fare clic sul controllo ListBox. Nella finestra di Proprietà , fare doppio clic sull'evento di SelectionChanged. Questo scopo viene aggiunto uno stub per un gestore di SelectionChanged e lo assegna all'evento.

Completare il gestore di SelectionChanged come segue e lo stub del metodo che chiama.

Private Sub ListBox1_SelectionChanged(ByVal sender As System.Object, ByVal e As System.Windows.Controls.SelectionChangedEventArgs) Handles ListBox1.SelectionChanged
    TrackSelection()
End Sub 

Private Sub TrackSelection()

End Sub

private void listBox1_SelectionChanged(object sender, EventArgs e)
{
    TrackSelection();
}
private void TrackSelection()
{
}

Salvare il lavoro. È possibile compilare il progetto e individuare gli errori.
A questo punto, compilare la funzione di TrackSelection, che consenta l'integrazione con la finestra di Proprietà . Questa funzione viene chiamata quando l'utente aggiunge un elemento alla casella di riepilogo o fa clic su un elemento nella casella di riepilogo.

Ora che si dispone di una classe che la finestra di Proprietà possibile utilizzare, è possibile integrare la finestra di Proprietà con la finestra degli strumenti. Quando l'utente fa clic su un elemento nella casella di riepilogo nella finestra degli strumenti, la finestra di Proprietà deve essere aggiornata di conseguenza. Analogamente, quando l'utente modifica un elemento di ToDo nella finestra di Proprietà , l'elemento associato deve essere aggiornato.

Nota

In alternativa, è possibile generare gli eventi di PropertyChanged direttamente implementando l'interfaccia di INotifyPropertyChanged .

Inserire il codice per aggiornare la finestra di Proprietà nella funzione di TrackSelection. Questo scopo collegheranno l'oggetto di ToDoItem alla finestra di Proprietà ; non è necessario scrivere codice aggiuntivo per modificare il ToDoItem quando l'utente modifica un valore nella finestra di Proprietà . La finestra di Proprietà automaticamente chiamerà le funzioni di accesso alla proprietà di set per aggiornare i valori. Tuttavia, è necessario completare il metodo di UpdateList creata quando è stato scritto il codice per la classe di ToDoItem.

Aggiungere le seguenti dichiarazioni dello spazio dei nomi all'inizio del file di MyControl.vb o di MyControl.xaml.cs, dopo l'esistenza mediante/istruzioni imports.

Imports System
Imports System.Runtime.InteropServices
Imports Microsoft.VisualStudio.Shell.Interop
Imports Microsoft.VisualStudio
Imports Microsoft.VisualStudio.Shell

using System.Runtime.InteropServices;
using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Shell;

implementare la funzione di TrackSelection come segue.

Private mySelContainer As SelectionContainer
Private mySelItems As System.Collections.ArrayList
Private frame As IVsWindowFrame = Nothing 
Private Sub TrackSelection()
    If frame Is Nothing Then 
        Dim shell = TryCast(GetService(GetType(SVsUIShell)), IVsUIShell)
        If shell IsNot Nothing Then 
            Dim guidPropertyBrowser = New Guid(ToolWindowGuids.PropertyBrowser)
            shell.FindToolWindow(CUInt(__VSFINDTOOLWIN.FTW_fForceCreate), guidPropertyBrowser, frame)
        End If 
    End If 
    If frame IsNot Nothing Then
        frame.Show()
    End If 
    If mySelContainer Is Nothing Then
        mySelContainer = New SelectionContainer()
    End If

    mySelItems = New System.Collections.ArrayList()

    Dim selected = TryCast(listBox1.SelectedItem, ToDoItem)
    If selected IsNot Nothing Then
        mySelItems.Add(selected)
    End If

    mySelContainer.SelectedObjects = mySelItems

    Dim track = TryCast(GetService(GetType(STrackSelection)), ITrackSelection)
    If track IsNot Nothing Then
        track.OnSelectChange(mySelContainer)
    End If 
End Sub

private SelectionContainer mySelContainer;
private System.Collections.ArrayList mySelItems;
private IVsWindowFrame frame = null;

private void TrackSelection()
{
    if (frame == null)
    {
        var shell = GetService(typeof(SVsUIShell)) as IVsUIShell;
        if (shell != null)
        {
            var guidPropertyBrowser = new
                Guid(ToolWindowGuids.PropertyBrowser);
            shell.FindToolWindow((uint)__VSFINDTOOLWIN.FTW_fForceCreate,
                ref guidPropertyBrowser, out frame);
        }
    }
    if (frame != null)
    {
        frame.Show();
    }
    if (mySelContainer == null)
    {
        mySelContainer = new SelectionContainer();
    }

    mySelItems = new System.Collections.ArrayList();

    var selected = listBox1.SelectedItem as ToDoItem;
    if (selected != null)
    {
        mySelItems.Add(selected);
    }

    mySelContainer.SelectedObjects = mySelItems;

    var track = GetService(typeof(STrackSelection))
        as ITrackSelection;
    if (track != null)
    {
        track.OnSelectChange(mySelContainer);
    }
}

Aggiungere il codice seguente subito dopo la fine della funzione di TrackSelection.
```
Protected Function GetService(ByVal service As Type) As Object 
    Dim obj As Object = Nothing 
    If _parent IsNot Nothing Then
        obj = _parent.GetVsService(service)
    End If 
    Return obj
End Function
```
```
protected object GetService(Type service)
{
    if (_parent != null)
    {
        return _parent.GetVsService(service);
    }
    return null;
}
```
Questo codice chiama la funzione GetService. Questa funzione dapprima tenta di ottenere il servizio dalla finestra degli strumenti padre chiamando la funzione GetService. Se tale autenticazione non riesce, tenta di ottenerle dalla funzione GetService dell'oggetto. Poiché la funzione GetService nella finestra degli strumenti padre non è pubblica, il codice chiama GetVsService anziché. È necessario aggiungere la funzione di GetVsService.

aprire MyToolWindow.cs o MyToolWindow.vb. Aggiungere il seguente codice alla fine della classe, subito prima della fine del file.

Friend Function GetVsService(ByVal service As Type) As Object 
    Return GetService(service)
End Function

internal object GetVsService(Type service)
{
    return GetService(service);
}

Salvare il file.

La prima volta che la funzione di TrackSelection viene eseguita, chiama GetService per ottenere un'istanza della shell di Visual Studio . Vengono quindi utilizzate per istanza per ottenere un oggetto dalla finestra di Proprietà . Per ottenere l'oggetto della finestra di Proprietà , il codice viene avviato tramite il GUID che rappresenta la finestra di Proprietà . (I GUID per le finestre degli strumenti sono membri della classe di ToolWindowGuids80 ). Viene quindi chiamato la funzione di FindToolWindow della shell, passando il GUID, per ottenere l'oggetto della finestra di Proprietà . Questo scopo viene salvato nella variabile di frame in modo che quando viene chiamata la funzione inoltre, non debbano essere ripetuto questo processo di ottenere la finestra di Proprietà .

Successivamente, il metodo chiama il metodo di visualizzazione della variabile di frame per visualizzare la finestra di Proprietà .

Il codice seguente raccoglie gli elementi selezionati nella casella di riepilogo. La casella di riepilogo non configurato per abilitare la selezione multipla. Per passare l'elemento selezionato nella finestra di Proprietà , è necessario utilizzare un contenitore. Di conseguenza, il codice unisce l'elemento selezionato e lo inserisce in un oggetto ArrayList quindi inserire tale oggetto ArrayList in un contenitore di tipo SelectionContainer.

Successivamente, il codice chiama GetService per ottenere un'istanza di ITrackSelection, che rappresenta l'oggetto di Visual Studio che le barre di avanzamento selezionate gli oggetti nell'interfaccia (UI) utente e visualizzare le relative proprietà. Quindi direttamente il codice chiama il gestore eventi di ITrackSelection OnSelectChange e passa il SelectionContainer che utilizza l'elemento selezionato. Il risultato è che la finestra di Proprietà visualizzare le proprietà per l'elemento selezionato.

Quando l'utente modifica un oggetto di ToDoItem nella finestra di Proprietà , la finestra di Proprietà chiama automaticamente le funzioni di accesso di set nell'oggetto di ToDoItem. Tale aggiorna l'oggetto, ma è necessario aggiornare la casella di riepilogo.
In un passaggio precedente, è stato aggiunto il codice nelle funzioni di accesso di set per chiamare una funzione di UpdateList in MyControl.xaml.cs o in MyControl.xaml.vb. A questo punto, aggiungere il resto del codice della funzione di UpdateList.
da MyControl.xaml.cs o da MyControl.xaml.vb, implementare il metodo di UpdateList come segue.
```
Public Sub UpdateList(ByVal item As ToDoItem)
    Dim index As Integer = ListBox1.SelectedIndex
    listBox1.Items.RemoveAt(index)
    listBox1.Items.Insert(index, item)
    ListBox1.SelectedItem = index
End Sub
```
```
public void UpdateList(ToDoItem item)
{
    var index = listBox1.SelectedIndex;
    listBox1.Items.RemoveAt(index);
    listBox1.Items.Insert(index, item);
    listBox1.SelectedItem = index;
}
```
Questo codice determina quale elemento viene selezionato e corrisponderà a ToDoItem in fase di modifica. Il codice consente di rimuovere l'elemento dalla casella di riepilogo e lo reinserisce. Utilizzando questo aggiorna la riga nella casella di riepilogo per l'elemento. Viene quindi impostata la selezione di nuovo allo stesso elemento.
Salvare il lavoro.

Aggiungere il testo alla Finestra di output e gli elementi all'elenco attività

Per aggiungere le stringhe in Elenco attività e nella finestra di output, è necessario innanzitutto ottenere gli oggetti che fanno riferimento alle due finestre. Quindi, è possibile chiamare i metodi su oggetti. Per Elenco attività, viene creato un nuovo oggetto attività di tipo e quindi aggiungere tale oggetto di attività a Elenco attività chiamando il relativo metodo Add. Per scrivere nella finestra di output, chiamare il relativo metodo di GetPane per ottenere un oggetto riquadro e quindi chiamare il metodo di OutputString dell'oggetto del riquadro.

Per aggiungere testo nella finestra di output e all'elenco attività

aprire MyControl.xaml.cs o MyControl.xaml.vb.

Espandere il metodo button1_Click inserendo il seguente codice prima della chiamata a TrackSelection().

Dim outputWindow = TryCast(GetService(GetType(SVsOutputWindow)), IVsOutputWindow)
Dim pane As IVsOutputWindowPane
Dim guidGeneralPane As Guid = VSConstants.GUID_OutWindowGeneralPane
outputWindow.GetPane(guidGeneralPane, pane)
If pane IsNot Nothing Then
    pane.OutputString(String.Format("To Do item created: {0} \r\n", item.ToString()))
End If

private void button1_Click(object sender, EventArgs e)
{
    if (textBox1.Text.Length > 0)
    {
        var item = new ToDoItem(this, textBox1.Text);
        listBox1.Items.Add(item);

        //Insert this section------------------ 
        var outputWindow = GetService(
            typeof(SVsOutputWindow)) as IVsOutputWindow;
        IVsOutputWindowPane pane;
        Guid guidGeneralPane =
            VSConstants.GUID_OutWindowGeneralPane;
        outputWindow.GetPane(ref guidGeneralPane, out pane);
        if (pane != null)
        {
            pane.OutputString(string.Format(
                "To Do item created: {0}\r\n",
                item.ToString()));
        }
        //-------------------------------------

        TrackSelection();
        CheckForErrors();
    }

questo codice ottiene l'oggetto per la finestra di output. l'oggetto espone un'interfaccia di IVsOutputWindow. Il codice recupera quindi un oggetto di IVsOutputWindowPane che include la funzione di OutputString, che quindi scrive nella finestra di output.

Distribuire il metodo di CheckForErrors, come illustrato di seguito.

Public Sub CheckForErrors()
    For Each item As ToDoItem In ListBox1.Items
        If item.DueDate < DateTime.Now Then
            ReportError("To Do Item is out of date: " & item.ToString())
        End If 
    Next 
End Sub

public void CheckForErrors()
{
    foreach (ToDoItem item in listBox1.Items)
    {
        if (item.DueDate < DateTime.Now)
        {
            ReportError("To Do Item is out of date: "
                + item.ToString());
        }
    }
}

Questo codice chiama il metodo di ReportError, che verrà successivamente, insieme ad altri metodi che consentono di aggiungere elementi a Elenco attività.

Aggiungere il seguente codice alla fine della classe, subito prima delle due parentesi graffe di apertura e di chiusura.

<Guid("72de1eAD-a00c-4f57-bff7-57edb162d0be")> _
Public Class MyTaskProvider
    Inherits TaskProvider
    Public Sub New(ByVal sp As IServiceProvider)
        MyBase.New(sp)
    End Sub 
End Class 
Private _taskProvider As MyTaskProvider
Private Sub CreateProvider()
    If _taskProvider Is Nothing Then
        _taskProvider = New MyTaskProvider(_parent)
        _taskProvider.ProviderName = "To Do" 
    End If 
End Sub 
Private Sub ClearError()
    CreateProvider()
    _taskProvider.Tasks.Clear()
End Sub 
Private Sub ReportError(ByVal p As String)
    CreateProvider()
    Dim errorTask = New Task()
    errorTask.CanDelete = False
    errorTask.Category = TaskCategory.Misc
    errorTask.Text = p

    _taskProvider.Tasks.Add(errorTask)

    _taskProvider.Show()

    Dim taskList = TryCast(GetService(GetType(SVsTaskList)), IVsTaskList2)
    If taskList Is Nothing Then 
        Exit Sub 
    End If 

    Dim guidProvider = GetType(MyTaskProvider).GUID
    taskList.SetActiveProvider(guidProvider)
End Sub

[Guid("72de1eAD-a00c-4f57-bff7-57edb162d0be")]
public class MyTaskProvider : TaskProvider
{
    public MyTaskProvider(IServiceProvider sp)
        : base(sp)
    {
    }
}
private MyTaskProvider _taskProvider;
private void CreateProvider()
{
    if (_taskProvider == null)
    {
        _taskProvider = new MyTaskProvider(_parent);
        _taskProvider.ProviderName = "To Do";
    }
}
private void ClearError()
{
    CreateProvider();
    _taskProvider.Tasks.Clear();
}
private void ReportError(string p)
{
    CreateProvider();
    var errorTask = new Task();
    errorTask.CanDelete = false;
    errorTask.Category = TaskCategory.Misc;
    errorTask.Text = p;

    _taskProvider.Tasks.Add(errorTask);

    _taskProvider.Show();

    var taskList = GetService(typeof(SVsTaskList))
        as IVsTaskList2;
    if (taskList == null)
    {
        return;
    }

    var guidProvider = typeof(MyTaskProvider).GUID;
    taskList.SetActiveProvider(ref guidProvider);
}

All'inizio del codice è una classe specializzata di TaskProvider MyTaskProvider denominato che include un GUID. Il successivo una variabile membro di questo nuovo tipo di classe, seguito da un metodo che crea la nuova istanza quando viene richiesto.

Dopo vengono definite due metodi, ClearError, che cambia ARIA gli elementi attività esistenti e ReportError importanti, che aggiunge elementi a Elenco attività.

Il metodo di ReportError crea una nuova istanza dell'attività, inizializzare l'istanza e aggiungere l'istanza a Elenco attività. Nuove voci di Elenco attività sono visibili solo quando l'utente seleziona l'elemento di ToDo nell'elenco a discesa nella parte superiore di Elenco attività. Le due righe finali nel codice automaticamente selezionare l'elemento di ToDo dall'elenco a discesa e introducono nuovi elementi attività. Il GUID è obbligatorio quando la classe di TaskProvider è ereditata perché il metodo di SetActiveProvider richiede un GUID come parametro.

Provandolo esterno

Per testare l'estensione

Premere CTRL+F5 per aprire la compilazione sperimentale di Visual Studio.
Nella compilazione sperimentale, scegliere dal menu di strumenti , fare clic su amministratore di ToDo.

La finestra degli strumenti progettati necessario aprire.
Digitare nella casella di testo e fare clic su aggiungere.

È necessario verificare che l'elemento viene aggiunto alla casella di riepilogo.
Digitare il grado di interpretare quindi fare clic su aggiungere ancora.

Quando si aggiungono gli elementi, la data iniziale viene impostata sulla data e l'ora corrente. Ciò attiva un errore e anche una voce in Elenco attività.
Scegliere dal menu di visualizzazione , fare clic su Output per aprire la finestra di output.

Si noti che ogni volta che si aggiunge un elemento, un messaggio visualizzato nel riquadro di Elenco attività .
Fare clic su uno degli elementi della casella di riepilogo.

La finestra di Proprietà visualizzare le due proprietà per l'elemento.
Modificare una proprietà e premere INVIO.

L'elemento viene aggiornato nella casella di riepilogo.

Argomenti successivi

In questa procedura dettagliata è stata creata una finestra degli strumenti che viene integrata con un'altra finestra degli strumenti in Visual Studio. Visual Studio sono disponibili numerose finestre degli strumenti che è possibile utilizzare i GUID per questi sono disponibili nella classe di ToolWindowGuids . Anche avere creato una classe che contiene proprietà che la finestra di Proprietà può accedere. Si svolto le funzioni di accesso che la finestra di Proprietà utilizza. Nella funzione di accesso di set, è stato chiamato nel proprio codice per gestire le modifiche apportate nella finestra di Proprietà . Questo scopo fornisce un meccanismo di comunicazione bidirezionale. Infine, è stato descritto come aggiungere elementi a Elenco attività, come inserire elementi nella visualizzazione e come aggiungere il testo alla finestra di output.

Vedere anche

Concetti

Finestra di output (Visual Studio SDK)

Elenco attività

Altre risorse

Controlli, menu e barre degli strumenti

Finestre degli strumenti

Finestra Proprietà e pagine delle proprietà

Condividi tramite