Freigeben über

Exemplarische Vorgehensweise: Integration in das Eigenschaftenfenster, in die Aufgabenliste, in das Ausgabefenster und im Options Dialog Box (Teil 4 von 4)

  • Artikel

Mit Visual Studio SDKverwenden, können Sie den Code so einrichten, dass jedes Toolfenster in Visual Studiozuzugreifen. Sie können z. B. dem Text hinzufügen, AufgabenlisteEinträge Ausgabe Fenster hinzufügen oder die Erweiterung in das Fenster Eigenschaften integrieren, damit die Benutzer die Erweiterung konfigurieren können, indem Sie Eigenschaften festlegen. In dieser exemplarischen Vorgehensweise wird erläutert, wie Sie die Erweiterung in Toolfenstern in Visual Studiointegriert.

Indem Sie diese exemplarische Vorgehensweise abgeschlossen haben, können Sie erfahren, wie Sie die folgenden Aufgaben aus:

  • Erstellen Sie ein VSPackage, indem Sie die Vorlage Paket verwenden.

  • Implementieren Sie das generierte Toolfenster.

  • Implementieren eines Menübefehls Ereignishandler.

  • Erstellen Sie eine Optionsseite.

  • Führen Sie Daten für das Eigenschaften verfügbar.

  • Integrieren Sie im Eigenschaftenfenster angezeigt.

  • Fügen Sie dem Text Ausgabe Fenster und AufgabenlisteElemente hinzu.

Diese exemplarische Vorgehensweise ist Teil einer Zeile, der unterrichtet, wie die Visual Studio-IDE erweitert. Weitere Informationen finden Sie unter Exemplarische Vorgehensweisen zum Anpassen von Visual Studio mithilfe von VSPackages.

Vorbereitungsmaßnahmen

Zum Abschließen dieser exemplarischen Vorgehensweise müssen Sie Visual Studio 2010 SDKinstallieren.

Hinweis

Weitere Informationen über das Visual Studio-SDK finden Sie unter Erweitern von Visual Studio Overview.Um herauszufinden finden Sie unter wie das Visual Studio-SDK, auf Visual Studio Extensibility Developer Center der MSDN-Website herunterlädt.

Speicherorte für die Visual Studio-Paket-Projektvorlage

Die Visual Studio-Paket importieren kann in drei verschiedenen Stellen im Dialogfeld Neues Projekt gefunden werden:

  1. Klicken Sie unter Von Visual Basic-Erweiterbarkeit. Die Standardsprache des Projekts ist Visual Basic.

  2. Die C#-Erweiterbarkeit. Die Standardsprache ist C# des Projekts.

  3. Verwenden anderer Projekttyp-Erweiterbarkeit. Die Standardsprache des Projekts ist C++.

Erstellen Sie ein VSPackage, indem Sie die Visual Studio-Paket-Vorlage verwenden

So erstellen Sie ein VSPackage

  1. Erstellen Sie ein VSPackage. Weitere Informationen zum Erstellen von VSPackages finden Sie unter Exemplarische Vorgehensweise: Wenn Sie einen Menübefehl mit der Visual Studio-Paket-Vorlage erstellenerstellt.

  2. Nennen Sie das Projekt TodoList, legen Sie die Sprache in Visual C# oder Visual Basic, und wählen Sie auf der Seite Optionen für das VSPackage auswählenToolfensterund Menübefehl fest.

  3. Legen Sie auf der Seite Befehlsoptionen Befehlsname zu Todo-Manager und cmdidTodoCommandzu Befehls-ID fest.

  4. Legen Sie auf der Seite Optionen des Toolfensters Fenstername zu Todo-Manager und cmdidTodoToolzu Befehls-ID fest.

  5. Klicken Sie auf die Schaltfläche Beenden.

Implementieren Sie das generierte Toolfenster

Die Paket generierten Vorlage ein grundlegendes Toolfenster in Form eines Benutzersteuerelements. Allerdings hat er keine Funktion. Um ihm Funktionen zu geben, müssen Sie untergeordnete Steuerelemente hinzufügen und den Code in MyControl.xaml.cs oder MyControl.vb ändern.

Das Toolfenster geschlossen wird TextBox , in denen eine neue Aufgabe, Button , um das neue Element der Liste hinzuzufügen und ListBox eingeben, um die Elemente in der Liste angezeigt wird. Das abgeschlossene Toolfenster sollte dem folgenden Bild aussehen:

Fertig gestelltes Toolfenster

So erstellen Sie Steuerelemente zum Hinzufügen von Toolfenstern

  1. Löschen Sie die Schaltfläche, den Text und die StackPanel-Kontrollen aus dem Raster.

    Hinweis

    Diese löscht nicht den button1_Click-Ereignishandler, den Sie in einem späteren Schritt wiederverwenden.

  2. Klicken Alle WPF-Steuerelemente-Abschnitt Toolbox, ziehen Sie ein Zeichenbereich-Steuerelement im Raster.

  3. Ziehen Sie ein Button-Steuerelement, ein TextBox-Steuerelement und ein ListBox-Steuerelement auf den Bereich. Ordnen Sie sie wie in der Abbildung oben gezeigt.

  4. Wählen Sie die Schaltfläche aus. Legen Sie die Eigenschaft auf HinzufügenInhalt fest.

  5. Klicken Sie im XAML-Bereich erneutes Verbinden Sie den Ereignishandler der Schaltfläche auf das Button-Steuerelement, indem Sie ein Attribut Click= " button1_Click“ hinzufügen. Die resultierende Zeile aus XAML sollte wie folgt aussehen:

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

    Speichern Sie Ihre Arbeit.

Standardmäßig geht der Benutzersteuerelement Konstruktor oder in der MyControl.xaml.cs- MyControl.xaml.vb-Datei keine Parameter. Sie können jedoch den Konstruktor anpassen, um Parameter einzufügen, sodass Sie das übergeordnete Element für die spätere Verwendung gespeichert werden können.

Um den Konstruktor anpassen

  1. Von der Seite Designer mit der rechten Maustaste auf Code anzeigen.

  2. Ersetzen Sie den vorhandenen Konstruktor durch den folgenden Code:

    public MyToolWindow _parent;
public MyControl(MyToolWindow parent)
{
    InitializeComponent();
    _parent = parent;
}

    Auf diese Weise kann der Konstruktor, um einen Parameter des Typs MyToolWindowzu übernehmen.

  3. Speichern Sie Ihre Arbeit.

  4. Als Nächstes fügen Sie dem Code einen Parameter hinzu, der den Konstruktor aufgerufen wird.

    In Projektmappen-Exploreröffnen Sie MyToolWindow.cs oder MyToolWindow.vb.

  5. Suchen Sie die Zeile im MyToolWindow-Konstruktor, der folgendem Code ähnelt.

    Me.Content = New MyControl()

    base.Content = new MyControl();

  6. Ändern Sie die Zeile wie folgt.

    Me.Content = New MyControl(Me)

    base.Content = new MyControl(this);

    Dies führt zu der Instanz des Toolfensters zum Benutzersteuerelement. (Dies wird in einem späteren Schritt erforderlich, um den Konstruktor für die ToDoItem-Klasse zu erstellen.)

Implementieren Sie einen Menübefehls-Handler

Wenn das TodoList-Projekt erstellt wurde, wurde jedoch einen Standardhandler für das Menüelement. Der Handler befindet sich in der TodoListPackage-Datei. Als Nächstes fügen Sie dem Handler Code hinzu, um das Toolfenster anzuzeigen. Dazu haben Sie nur ein paar Schritten tun, da TodoListPackage bereits eine Funktion enthält, die ShowToolWindow benannt ist.

So fügen Sie dem Menüelement Klassenhandler implementieren

  1. Öffnen Sie TodoListPackage.cs oder TodoListPackage.vb. Beachten Sie, dass der Menüelement Handler den folgenden Beispielcode enthält.

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

  2. Entfernen Sie alle in der Funktion, und ersetzen Sie ihn durch einen Aufruf von ShowToolWindow wie folgt.

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

    Speichern Sie die Arbeit, und drücken Sie dann F5, um das Projekt zu erstellen und in der experimentellen Build von Visual Studio zu öffnen. Überprüft, ob das Toolfenster geöffnet wird, indem Sie auf ToDo-Manager im Menü Extras klickt.

    Schließen Sie die experimentelle Build, bevor Sie fortfahren.

Erstellen Sie eine Seite Optionen

Sie können eine Seite im Optionen Dialogfeld bereitstellen, damit Benutzer Einstellungen für das Toolfenster ändern können. Das Erstellen einer Optionsseite erfordert eine Klasse, die die angegebenen Optionen und einen Eintrag in der TodoListPackage.cs- oder TodoListPackage.vb-Datei beschreibt.

So erstellen Sie eine Seite Optionen

  1. In Projektmappen-Explorermit der rechten Maustaste auf das ToDoList-Projekt, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Klasse.

  2. Geben Sie im Dialogfeld Neues Element hinzufügen nennen Sie die Datei ToolsOptions.csoder ToolsOptions.vb und klicken Sie dann auf Hinzufügen.

    Visual Studio erstellt eine Klasse, die in dieser Datei ToolsOptions Namen, aber Sie müssen den Header Klassen so ändern, dass die Klasse von DialogPageabgeleitet ist.

    Fügen Sie dem Namespace Microsoft.VisualStudio.Shell Import-Direktiven/mit vorhandenen wie folgt hinzu.

    Imports Microsoft.VisualStudio.Shell

    using Microsoft.VisualStudio.Shell;

  3. Ändern Sie die Klassendeklaration an, um ToolsOptions von DialogPagezu erben.

    Inherits DialogPage

    class ToolsOptions : DialogPage

  4. Die Seite Optionen in dieser exemplarischen Vorgehensweise stellt nur ein Option benanntes DaysAhead. Um diese Option hinzuzufügen, fügen Sie eine Eigenschaft hinzu, die wie folgt DaysAhead der ToolsOptions-Klasse benannt ist.

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

    Diese Klasse speichert eine einzelne Option als privaten Member, der _daysAhead benannt ist. Die Klasse stellt dann eine öffentliche Eigenschaft bereit, die DaysAhead für den Zugriff auf die Option benannt ist.

  5. Speichern Sie die Datei.

Jetzt müssen Sie das Projekt aufmerksam machen diese Optionsseite, damit sie ordnungsgemäß registriert und für Benutzer verfügbar ist.

Um die Optionsseite für Benutzer verfügbar machen

  1. In Projektmappen-Exploreröffnen Sie TodoListPackage.cs oder TodoListPackage.vb.

  2. Suchen Sie die Zeile, die das ProvideToolWindowAttribute-Attribut enthält, und fügen Sie dann ein ProvideOptionPageAttribute-Attribut wie folgt unmittelbar im Anschluss hinzugefügt.

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

    Hinweis

    Sie müssen das Wort „Attribut“ kann nicht in den Attributdeklarationen einschließen.

  3. Speichern Sie die Datei.

    Der erste Parameter für den ProvideOptionPage-Konstruktor ist der Typ der Klasse ToolsOptions, die Sie zuvor erstellt haben. Der zweite Parameter ist“, „Zu-Tun den Namen der Kategorie im Dialogfeld Optionen . Der dritte Parameter, „Allgemein“, ist der Name der Unterkategorie des Optionen Dialogfeld, in dem die Optionsseite zur Verfügung steht. Die folgenden beiden Parameter sind Ressource ID für Zeichenfolgen. Das erste Element ist der Name der Kategorie, und das zweite Element ist der Name der Unterkategorie. Der letzte Parameter legt fest, ob diese Seite zugreifen können, indem Sie die Automatisierung veranschaulicht.

    Wenn die Seite Optionen zugegriffen wird, sollte der folgenden Abbildung aussehen.

    Seite Optionen

    Beachten Sie die Kategorie und die Unterkategorie Zu-Tun General.

Legen Sie im Eigenschaftenfenster für Daten

Die folgenden Prinzipien für objektorientierte guten Entwurf, können Sie eine Klasse, ToDoItem, das Informationen über die einzelnen Elemente in der Aufgabenliste gespeichert werden.

So zeigen Sie Daten im Eigenschaftenfenster bereitstellen

  1. In Projektmappen-Explorermit der rechten Maustaste auf das ToDoList-Projekt, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Klasse.

  2. Geben Sie im Dialogfeld Neues Element hinzufügen nennen Sie die Datei ToDoItem.cs oder ToDoItem.vb, und klicken Sie dann auf Hinzufügen.

    Wenn das Toolfenster für Benutzer verfügbar ist, werden die Elemente im Listenfeld durch ToDoItem-Instanzen dargestellt. Wenn der Benutzer eines dieser Elemente im Listenfeld auswählt, zeigt das Fenster Eigenschaften Informationen über das Element an.

    So rufen Sie Daten bereitstellen Eigenschaften im Fenster, lassen Sie die Daten in öffentlichen Eigenschaften einer Klasse und des Dokuments sie, indem Sie zwei spezielle Attribute, Beschreibung und Kategorie verwenden. Die Beschreibung ist der Text, der im unteren Bereich des Eigenschaften Fenster wird angezeigt. Kategorie definiert, wo die Eigenschaft angezeigt werden soll, wenn das Eigenschaften Fenster in der kategorisierten Ansicht angezeigt wird. Im folgenden Abbildung ist das Eigenschaften Fenster in der kategorisierten Ansicht, wird die Name-Eigenschaft in der Aufgabenfelder Kategorie ausgewählt, und die Beschreibung der Name-Eigenschaft wird am unteren Rand des Fensters angezeigt.

    Eigenschaftenfenster

  3. Fügen Sie die folgenden Namespaces oberen Rand der ToDoItem.cs- oder ToDoItem.vb-Datei, nachdem das vorhandene using/Imports-Anweisungen hinzu.

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

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

  4. Beginnen Sie mit ToDoItem-Klasse wie folgt implementiert. Stellen Sie sicher, den public Zugriffsmodifizierer der Klassendeklaration hinzugefügt werden soll.

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

    Beachten Sie, dass dieser Code zwei Eigenschaften, DueDate und Namen verfügt. Dies sind die beiden Eigenschaften, die im Eigenschaften Fenster angezeigt werden, wie in der vorherigen Abbildung dargestellt. Jede Eigenschaft wird der description-Eigenschaft und Kategorien attributen voraus, die die Informationen für die Anzeige im Fenster Eigenschaften bereitstellen. Überprüfen Sie diese beiden Attribute für die Name-Eigenschaft; Zeichenfolgen sind die im Bild entsprechen.

  5. Fügen Sie die folgende Konstruktorfunktion am Anfang der Klasse hinzugefügt.

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

    Zuerst deklariert dieser Code einen privaten Member mit dem Namen _parent, das dem Benutzersteuerelement entspricht, TextBox die Schaltfläche und die ListBox-Steuerelemente enthält, die Sie zuvor erstellt haben. Der Konstruktor nimmt das Benutzersteuerelement als Parameter zusammen mit einer Zeichenfolge, die den Namen für diese Aufgabe wird. Die ersten drei Zeilen im Konstruktor des Benutzersteuerelements speichern, den Namen und das aktuelle Datum und die aktuelle Uhrzeit.

    Sie können das aktuelle Datum und die aktuelle Uhrzeit als Grundlage zum Aktivieren der DaysAhead-Option auf der Seite Optionen verwenden, die Sie zuvor erstellt haben. Da das aktuelle Datum und die aktuelle Uhrzeit in der Regel nicht als Fälligkeitsdatum verwendet werden, können Sie das aktuelle Datum durch die Anzahl der Tage setzen, die auf der Seite Optionen angegeben sind. .

    Der Code aufgerufen daysAhead eine lokale Variable deklariert, die festgelegt wird, indem der Wert in der DaysAhead-Option verwendet. Die nächste Zeile erhält das übergeordnete Element des Benutzersteuerelements und von dort mit dem Paket Member. (Dies ist im _parent Member verwenden, die Sie zur MyControl.xaml.cs-Klasse zuvor hinzugefügt haben.)

    Wenn dieser Member Paket nicht NULL ist, wird ein Objekt deklariert, das die ToolsOptions-Instanz enthält. Um die Instanz abzurufen, führt den Code ruft der GetAutomationObject-Member des Pakets und den Namen der Kategorie und der Unterkategorie als einzelne durch Punkte getrennte Zeichenfolge, To-Do.General. Die Ergebnisse werden als Ausgabeparameter zurück in die obj Variable übergeben.

    Die obj Variable wird dann zur ToolsOptions-Klasse umgewandelt und in einer Variablen gespeichert, die optionsbenannt ist. Wenn diese Variable nicht NULL ist, ruft der Code der DaysAhead-Member und speichert sie in die _daysAhead-Variablen.

    Der Code verschiebt anschließend die _duedate-Variablen um die Anzahl von Tagen voran, indem die AddDays-Methode.

  6. Da Instanzen der ToDoItem-Klasse im Listenfeld gespeichert werden und das Listenfeld die ToString-Funktion aufruft, die diese Klasse von der Object-Klasse erbt, um die Zeichenfolge zu erhalten, die für das Element angezeigt werden soll, müssen Sie die ToString-Funktion überladen.

    Fügen Sie den folgenden Code ToDoItem.cs, die nach dem Konstruktor und vor dem Ende der Klasse hinzu.

    Public Overloads Overrides Function ToString() As String 
    Return (_name & " Due: ") + _dueDate.ToShortDateString()
End Function

    public override string ToString()
{
    return _name + " Due: " + _dueDate.ToShortDateString();
}

  7. Öffnen Sie MyControl.xaml.cs oder MyControl.xaml.vb.

  8. Fügen Sie die Methoden der Stub MyControl-Klasse für die CheckForError und UpdateList-Methoden hinzu. Setzen Sie nach dem ProcessDialogChar und vor dem Ende der Datei.

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

    Die CheckForError-Methode ruft eine Methode auf, die den gleichen Namen im übergeordneten Objekt verfügt und die Methode überprüft, ob Fehler aufgetreten sind und sie ordnungsgemäß behandeln. Die UpdateList-Methode wird das Listenfeld im übergeordneten Steuerelement. Die Methode wurde aufgerufen, nachdem die Name und DueDate-Eigenschaften in dieser Klasse ändern. Implementieren Sie diese Methode in einem späteren Schritt.

Integrieren Sie im Eigenschaftenfenster

Schreiben Sie nun den Code, der das Listenfeld verwaltet, das am Eigenschaften Fenster gebunden ist.

Sie müssen ein Handle der Schaltfläche hinzu, die TextBox liest eine ToDoItem-Instanz erstellt, und die Instanz dem Listenfeld hinzugefügt wird.

So fügen Sie mit dem Eigenschaftenfenster zu integrieren

  1. Wechseln Sie zur Entwurfsansicht, doppelklicken MyControl.xaml von dann auf das Button-Steuerelement

  2. Ersetzen Sie die vorhandene button1_Click-Handlerfunktion, indem Sie folgenden Code verwenden.

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

    Dieser Code erstellt eine neue ToDoItem-Instanz und führt die Instanz des Benutzersteuerelements als Parameter zusammen mit dem Text, den der Benutzer im TextBox-Steuerelement eingetreten ist. Anschließend fügt der Code das Element dem Listenfeld hinzu. (Das Listenfeld ruft die ToString-Methode der ToDoItem-Instanz auf, um die Zeichenfolge zu erhalten, die im Listenfeld anzuzeigen.) Anschließend ruft der Code die TrackSelections-Funktion an, die Sie in einem späteren Schritt schreiben. Schließlich überprüft der Code für Fehler.

  3. Wechseln Sie in die Entwurfsansicht von MyControl.xaml, für den Code hinzuzufügen, der Benutzerauswahl eines neuen Elements im Listenfeld behandelt.

  4. Klicken Sie auf das ListBox-Steuerelement. Im Eigenschaften Fensters doppelklicken Sie auf das SelectionChanged-Ereignis. Das zu, fügt einen Stub für einen SelectionChanged-Handler hinzu und weist ihn dem Ereignis zugeordnet.

  5. Geben Sie den SelectionChanged-Handler wie folgt und Stub in der Methode, in der sie aufgerufen wird.

    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()
{
}

  6. Speichern Sie Ihre Arbeit. Sie können das Projekt erstellen und nach Typos suchen.

  7. Anschließend füllen Sie die TrackSelections-Funktion aus, die Integration mit dem Eigenschaften Fenster bereitstellt. Diese Funktion wird aufgerufen, wenn der Benutzer ein Element hinzufügt oder dem Listenfeld auf ein Element im Listenfeld klickt.

    Nachdem Sie eine Klasse, die das Eigenschaften Fenster verwendet werden kann, können Sie das Eigenschaften Fenster mit dem Toolfenster integrieren. Wenn der Benutzer auf ein Element im Listenfeld im Toolfenster klickt, wird das Fenster entsprechend aktualisiert werden Eigenschaften . Auch wenn der Benutzer eine Aufgabe im Fenster Eigenschaften ändert, sollte das zugeordnete Element aktualisiert werden.

    Hinweis

    Alternativ können Sie PropertyChanged-Ereignisse direkt generieren, indem Sie die INotifyPropertyChanged-Schnittstelle implementieren.

    Geben Sie den Code für die Aktualisierung des Eigenschaften Fensters in die TrackSelections-Funktion ein. Auf diese Weise bindet das ToDoItem-Objekt zum Eigenschaften Windows; Sie müssen keinen zusätzlichen Code schreiben, um das ToDoItem zu ändern, wenn der Benutzer einen Wert im Eigenschaften Fenster ändert. Das Eigenschaften Fenster wird automatisch die set-Eigenschaftenaccessoren aufrufen, um die Werte zu aktualisieren. Sie müssen jedoch die UpdateList-Methode beenden, die Sie erstellt haben, als Sie den Code für die ToDoItem-Klasse geschrieben haben.

  8. Fügen Sie die folgenden Namespacedeklarationen oberen Rand der MyControl.xaml.cs- oder MyControl.vb-Datei, nachdem das vorhandene using/Imports-Anweisungen hinzu.

    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;

  9. Implementieren Sie die TrackSelections-Funktion wie folgt.

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

  10. Fügen Sie folgenden Code direkt nach dem Ende der TrackSelections-Funktion hinzu.

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

    Dieser Code ruft die GetService-Funktion an. Diese Funktion versucht zunächst, der Dienst vom übergeordneten Toolfenster zu erhalten, indem sie ihre GetService-Funktion aufruft. Wenn dies fehlschlägt, versucht es, diese aus der GetService-Funktion des Objekts abzurufen. Da die GetService-Funktion im übergeordneten Toolfenster nicht öffentlich ist, ruft der Code GetVsService sondern stattdessen an. Sie müssen die GetVsService-Funktion hinzufügen.

  11. Öffnen Sie MyToolWindow.cs oder MyToolWindow.vb. Fügen Sie den folgenden Code am Ende der Klasse direkt vor dem Ende der Datei hinzu.

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

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

  12. Speichern Sie die Datei.

    Beim ersten Mal die TrackSelections-Funktion ausgeführt wird, ruft sie auf GetService zum Abrufen einer Instanz der Visual Studio Shells. Anschließend werden mit dieser Instanz, um ein Objekt abzurufen Eigenschaften für das Fenster. Um das Eigenschaften Fensterobjekt, die Code beginnt mit dem GUID abzurufen, das das Eigenschaften Fensters darstellt. (Die GUID für die Toolfenster ist Mitglied der ToolWindowGuids80-Klasse.) Der Code ruft dann die FindToolWindow-Funktion der Shells an, indem er die GUID übergeben wird, um das Eigenschaften Fensterobjekt abzurufen. Das zu, speichert es in der Zielframe, damit variable, wenn die Funktion erneut aufgerufen wird, abgerufen aus dieser Vorgang nicht Eigenschaften das Fenster erneut ausgeführt werden muss.

    Als Nächstes die Methode ruft die Show-Methode des Frames die Variable, um das Eigenschaften Fensters anzuzeigen.

    Der folgende Code ermittelt die ausgewählten Elemente im Listenfeld. Das Listenfeld ist nicht konfiguriert, um eine Mehrfachauswahl zu aktivieren. Um das ausgewählte Element in den Eigenschaften Fenster zu übergeben, müssen Sie einen Container verwenden. Daher ermittelt der Code das ausgewählte Element und fügt dieses an ArrayList und fügt dieses dann eine ArrayList in einen Container Typ SelectionContainer ein.

    Anschließend ruft der Code auf GetService zum Abrufen einer Instanz von ITrackSelection, das das Visual Studio-Objekt ist, dass ausgewählte Objekte in der Benutzeroberfläche und zeigt ihre Eigenschaften nachverfolgt. Anschließend ruft der Code direkt den Ereignishandler ITrackSelection OnSelectChange an und führt die SelectionContainer, das das ausgewählte Element enthält. Das Ergebnis ist, dass das Eigenschaften Fenster Eigenschaften für das ausgewählte Element angezeigt wird.

    Wenn der Benutzer ein ToDoItem-Objekt im Eigenschaften Fenster ändert, wird das Fenster automatisch Eigenschaften die set Accessorfunktionen im ToDoItem-Objekt an. Dadurch wird das Objekt. Sie müssen jedoch weiterhin das Listenfeld aktualisieren.

  13. In einem vorherigen Schritt fügen Sie Code in den set Accessorfunktionen hinzu, um eine UpdateList-Funktion in MyControl.xaml.cs oder MyControl.xaml.vb aufzurufen. Fügen Sie nun den Rest des Codes UpdateList-Funktions hinzu.

  14. Von MyControl.xaml.cs oder MyControl.xaml.vb implementieren Sie die UpdateList-Methode wie folgt.

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

    Dieser Code bestimmt, welches Element ausgewählt wurde und auf den ToDoItem entsprechen, das geändert wurde. Der Code entfernt das Element im Listenfeld und fügt dieses dann wiederein. Das zu, aktualisiert die Zeile im Listenfeld für das Element. Anschließend legt der Code die Auswahl wieder in demselben Element.

  15. Speichern Sie Ihre Arbeit.

Einfügen von Text im Ausgabefenster und der Aufgabenliste Elemente hinzu

Um Zeichenfolgen und Aufgabenliste dem Fenster Ausgabe hinzuzufügen, müssen Sie zuerst die Objekte erhalten diese beiden Fenster verweisen. Anschließend können Sie Methoden für Objekte aufrufen. Für Aufgabenlisteerstellen Sie ein neues Objekt vom Typ Aufgabe und dann dieses Taskobjekt zu Aufgabenliste aufrufen, indem Sie das Hinzufügen von Method. Um das Fenster geschrieben werden soll Ausgabe , rufen Sie seine GetPane-Methode an zum Abrufen eines Bereichs Objekt, und rufen Sie die OutputString-Methode des Bereichs Objekts an.

So fügen Sie Text im Ausgabefenster und der Aufgabenliste hinzufügen

  1. Öffnen Sie MyControl.xaml.cs oder MyControl.xaml.vb.

  2. Erweitern Sie die button1_Click-Methode, indem Sie den folgenden Code vor dem Aufruf von TrackSelection()einfügen.

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

    Dieser Code ruft das Objekt zum Ausgabe Fenster. Das Objekt macht eine IVsOutputWindow-Schnittstelle. Der Code ruft dann ein IVsOutputWindowPane-Objekt, das die OutputString-Funktion enthält, die Ausgabe letztlich das Fenster geschrieben wird.

  3. Implementieren Sie jetzt die CheckForErrors-Methode wie folgt.

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

    Dieser Code ruft die ReportError-Methode, die Sie als Nächstes erstellen, zusammen mit einigen anderen Methoden auf, die AufgabenlisteElemente hinzuzufügen.

  4. Fügen Sie den folgenden Code am Ende der Klasse, unmittelbar vor den zwei schließende Klammer hinzu.

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

    Zu Beginn dieses Codes ist ein spezielles TaskProvider Klasse mit dem Namen MyTaskProvider, der eine GUID enthält. Ist als Nächstes eine Membervariable dieses neuen Klassentyps, gefolgt von einer Methode, mit der die neue Instanz erstellt, wenn dies erforderlich ist.

    Weiter Kommen zwei wichtige Methoden, ClearError, das die vorhandenen Aufgabenelemente Löschen und ReportError, das AufgabenlisteElemente hinzugefügt werden.

    Die ReportError-Methode erstellt eine neue Instanz der Aufgabe die Instanz initialisiert, und dann die Instanz Aufgabenlistehinzu. Die neuen Aufgabenliste Einträge sind nur sichtbar, wenn der Benutzer die Aufgabe in der Dropdownliste oben Aufgabenlisteauswählt. Die letzten beiden Zeilen im Code wählen automatisch die Aufgabe aus der Dropdownliste aus, und öffnen die neuen Aufgabenelemente sichtbar gemacht. Die GUID ist erforderlich, wenn die TaskProvider-Klasse geerbt wird, da die SetActiveProvider-Methode eine GUID als Parameter erfordert.

Sie versuchen

So testen Sie die Erweiterung

  1. Drücken Sie STRG+F5, um die experimentelle Erstellung von Visual Studiozu öffnen.

  2. In der experimentellen Build auf dem Extras Menü auf ToDo-Manager.

    Das Toolfenster, in dem Sie entwarfen, sollte geöffnet werden.

  3. Geben Sie in TextBox ein, und klicken Sie dann auf Hinzufügen.

    Sie sollten überprüfen, ob das Element dem Listenfeld hinzugefügt wird.

  4. Geben Sie etwas Anderes ein, und klicken Sie dann auf Hinzufügen erneut.

    Wenn Sie Elemente hinzufügen, wird das ursprüngliche Datum auf das aktuelle Datum und die aktuelle Zeit festgelegt. Dies startet einen Fehler und auch einen Eintrag in Aufgabenliste.

  5. Zeigen Sie im Menü AnsichtAusgabe , um den Ausgabe Fensters zu öffnen.

    Beachten Sie, dass jedes Mal, dass Sie ein Element hinzufügen, um eine Meldung im Aufgabenliste Bereich angezeigt wird.

  6. Klicken Sie auf eines der Elemente im Listenfeld.

    Das Eigenschaften Fenster zeigt die beiden Eigenschaften für das Element an.

  7. Ändern Sie eine der Eigenschaften und drücken Sie dann die EINGABETASTE.

    Das Element wird im Listenfeld aktualisiert.

Weitere Informationen

In dieser exemplarischen Vorgehensweise haben Sie ein Toolfenster, das mit einem anderen Toolfenstern in Visual Studiointegriert ist. Visual Studio hat einige Toolfenster, mit der Sie arbeiten können, und die GUID für diese in der ToolWindowGuids-Klasse gefunden werden kann. Sie haben außerdem eine Klasse, die die Eigenschaften enthält, die die Eigenschaften Fenster zugreifen kann. Sie stellen Accessorfunktionen bereit, die das Eigenschaften Fenster verwendet. In der set Accessorfunktion namens Sie in Ihren eigenen Code auf, um Änderungen zu verarbeiten, die im Eigenschaften Fenster vorgenommen wurden. Auf diese Weise stellt einen Mechanismus der bidirektionalen Kommunikation. Schließlich haben Sie erfahren, wie AufgabenlisteElemente hinzufügt, wie die Elemente in der Ansicht bewegt und im Fenster Ausgabe Text hinzufügt.

Siehe auch

Konzepte

Ausgabefenster (Visual Studio SDK)

Aufgabenliste

Weitere Ressourcen

Befehle, Menüs und Symbolleisten

Toolfenster

Eigenschaftenfenster und Eigenschaftenseiten