Freigeben über

Exemplarische Vorgehensweise: Toolboxelemente automatisch laden

  • Artikel

Diese exemplarische Vorgehensweise veranschaulicht das verwaltete VSPackages Reflektion verwenden kann, um alle ToolboxItem-Elemente automatisch zu laden, die von ihrer eigenen Assembly zur Verfügung gestellt werden.

Hinweis

Es wird empfohlen, benutzerdefinierte Steuerelement der Toolbox hinzufügen, die Toolbox-Steuerelementvorlagen zu verwenden, die mit dem Visual Studio 10 SDK enthalten sind, die Unterstützung des automatischen Laden beinhalten.In diesem Thema wird aus Gründen der Abwärtskompatibilität und für das Hinzufügen von vorhandenen Steuerelementen zur Toolbox und für erweiterte Toolbox entwicklung beibehalten.

Weitere Informationen zum Erstellen von Toolbox Steuerelemente, indem Sie die Vorlagen verwenden, finden Sie unter Gewusst wie: Erstellen Sie ein Toolbox-Steuerelement, die Windows Forms verwendet und Gewusst wie: Erstellen Sie ein Toolbox-Steuerelement, die WPF verwendet.

Diese exemplarische Vorgehensweise führt Sie durch die folgenden Schritte:

  1. Hinzufügen und registrieren Sie Toolbox ordnungsgemäß alle Steuerelemente in den VSPackage-Objekten, indem Sie ToolboxItemAttribute, ToolboxBitmapAttributeund DisplayNameAttributeverwenden.

  2. Erstellen Sie die folgenden beiden Steuerelemente, und fügen Sie Symbole für jedes Toolboxhinzu:

    • Fügen Sie ein Steuerelement hinzu, indem Sie eine standardmäßige ToolboxItem-Klasse verwenden.

    • Fügen Sie ein weiteres Steuerelement hinzu, indem Sie eine benutzerdefinierte Klasse verwenden, die von der ToolboxItem-Klasse abgeleitet ist.

  3. Registrieren von VSPackages als Bereitstellen von ToolboxItem-Objekten, die die ProvideToolboxItemsAttribute-Klasse.

  4. Verwendet Reflektion, um eine Liste aller ToolboxItem-Objekte zu generieren, die ein VSPackage bereitstellt, wenn es geladen wird.

  5. Erstellen Sie einen Handler für die ToolboxInitialized und ToolboxUpgraded-Ereignisse. Auf diese Weise wird sichergestellt, dass die ToolboxItem-Objekte ordnungsgemäß VSPackages geladen werden.

  6. Implementieren Sie einen Befehl für ein VSPackage, Reinitialisierung Toolboxzu erzwingen.

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

Verwaltetes VSPackage erstellen

So erstellen LoadToolboxMembers VSPackage

  1. Erstellen Sie ein VSPackage, das LoadToolboxMembersbenannt ist. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Wenn Sie einen Menübefehl mit der Visual Studio-Paket-Vorlage erstellen.

  2. Fügen Sie einen Menübefehl hinzu.

    Nennen Sie den Befehl Initialisieren Sie LoadToolboxMembers-VB für Initialisieren Sie LoadToolboxMembers CS für Visual Basic oder Visual C#.

Wenn Sie in dieser exemplarischen Vorgehensweise für mehrere Sprachen ausführen, müssen Sie das Projekt so aktualisieren, dass den generierten Assemblys zu unterscheiden.

So führen Sie Visual Basic und Visual C# VSPackages unterscheiden

  1. Für Visual Basic:

    • Öffnen Sie im Projektmappen-Explorer die Projekteigenschaften, und wählen Sie die Registerkarte Anwendung aus.

      Ändern Sie den Assemblynamen zu LoadToolboxMembersVB, und ändern Sie den Standardnamespace zu Company.LoadToolboxMembersVB.

  2. Für Visual C#:

    1. Öffnen Sie im Projektmappen-Explorer die Projekteigenschaften, und wählen Sie die Registerkarte Anwendung aus.

      Ändern Sie den Assemblynamen zu LoadToolboxMembersCS, und ändern Sie den Standardnamespace zu Company.LoadToolboxMembersCS.

    2. Öffnen Sie die LoadToolboxMembersPackage-Klasse im Code-Editor.

      Um die Bereitstellungstools Umgestaltung mit Umbenennen von vorhandenen Namespace, zeigen Sie mit der rechten Maustaste auf den vorhandenen Namespacename, LoadToolboxMembersUmgestalten, und klicken Sie dann auf Umbenennen. Ändern Sie den Namen in LoadToolboxMembersCS.

  3. Speichern Sie die Änderungen.

Verwenden Sie zum Sichern der Verweise hinzufügen

  1. Im LoadToolboxMembers-Projekt fügen Sie einen Verweis auf die Komponente folgendermaßen System.Drawing.Design .NET Framework hinzu.

    1. In Projektmappen-Explorermit der rechten Maustaste auf das LoadToolboxMembers-Projekt, und klicken Sie dann auf Verweis hinzufügen.

    2. Auf der Registerkarte des Dialogfelds Verweise hinzufügen.NET Doppelklicken Sie auf System.Drawing.Design.

  2. Fügen Sie für Visual Basic die folgenden Namespaces der Liste Importierte Namespaces im Projekt hinzu:

    • Company.LoadToolboxMembersVB

    • System

    • System.ComponentModel

    • System.Drawing

    • System.Windows.Forms

So testen Sie den generierten Code

  1. Kompilieren und starten Sie den experimentellen Hiven in einem VSPackage von Visual Studio.

  2. Zeigen Sie im Menü ExtrasLoadToolboxMembers initialisieren VB oder klicken Sie auf LoadToolboxMembers initialisieren CS.

    Dadurch wird ein Meldungsfeld mit dem Text, der angibt, ob das Menüelement Handler des Pakets aufgerufen wurde.

  3. Schließen Sie die experimentelle Version von Visual Studio.

Ein Toolbox-Steuerelement erstellen

In diesem Abschnitt erstellen Sie ein Benutzersteuerelement, und registrieren Control1, das ein zugeordnetes Standardwert Toolboxelement deklariert. Weitere Informationen dazu, wie Sie Windows Form-Steuerelemente und die ToolboxItem-Klasse finden Sie unter Entwickeln von Windows Forms-Steuerelementen zur Entwurfszeiterstellt.

So erstellen Sie die Toolbox ein, der mit einem Standardwert ToolboxItem verwendet wird

  1. In Projektmappen-Explorerfügen Sie ein UserControl-Objekt, das LoadToolboxMembers-Projekt wie folgt hinzu:

    1. In Projektmappen-ExplorerLoadToolboxMembers mit der rechten Maustaste auf das Projekt, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Benutzersteuerelement.

    2. Geben Sie im Dialogfeld Neues Element hinzufügen ändern Sie den Namen in Control1.vb für Visual Basic oder Control1.cs für Visual C#.

      Weitere Informationen zum Hinzufügen neuer Elemente zu einem Projekt finden Sie unter How to: Add New Project Itemshinzugefügt wird.

    Das neue Steuerelement wird in der Entwurfsansicht.

  2. Von Toolboxziehen Sie ein Schaltfläche-Steuerelement (in der Kategorie Allgemeine Steuerelemente in den Designer).

  3. Doppelklicken Sie auf die Schaltfläche, die Sie gerade erstellt haben. Auf diese Weise Click generiert einen Ereignishandler für das Ereignis der Schaltfläche. Aktualisieren Sie den Ereignishandler durch den folgenden Code:

    Private Sub Button1_Click(ByVal sender As Object, ByVal e As EventArgs) _
    Handles Button1.Click

    MessageBox.Show("Hello world from " & Me.ToString())
End Sub

    private void button1_Click(object sender, EventArgs e)
{
    MessageBox.Show("Hello world from " + this.ToString());
}

  4. Ändern Sie den Konstruktor des Steuerelements, um den Schaltflächentext festzulegen, nachdem die InitializeComponent-Methode aufgerufen wurde:

    Public Sub New()

    InitializeComponent()

    Button1.Text = Me.Name + " Button" 
End Sub

    public Control1()
{
    InitializeComponent();

    button1.Text = this.Name + " Button";
}

  5. Fügen Sie Attribute der Datei hinzu, um zu ermöglichen, dass ein VSPackage über die angegebene ToolboxItem-Klasse abzufragen:

    ' Set the display name and custom bitmap to use for this item. 
' The build action for the bitmap must be "Embedded Resource".
<DisplayName("ToolboxMember 1 VB")> _
<Description("Custom toolbox item from package LoadToolboxMembers.")> _
<ToolboxItem(True)> _
<ToolboxBitmap(GetType(Control1), "Control1.bmp")> _
Public Class Control1

    // Set the display name and custom bitmap to use for this item. 
// The build action for the bitmap must be "Embedded Resource".
[DisplayName("ToolboxMember 1 CS")]
[Description("Custom toolbox item from package LoadToolboxMembers.")]
[ToolboxItem(true)]
[ToolboxBitmap(typeof(Control1), "Control1.bmp")]
public partial class Control1 : UserControl
{

  6. Speichern Sie die Datei.

In der folgenden Prozedur erstellen Sie ein zweites Benutzersteuerelement, und registrieren Control2und ein zugeordnetes benutzerdefiniertes Toolboxelement, Control2_ToolboxItem, das von der ToolboxItem-Klasse abgeleitet ist.

So fügen Sie ein Toolbox die Steuerung zur Verwendung einer benutzerdefinierten ToolboxItem-abgeleiteten Klasse erstellen

  1. Erstellen Sie zweites Benutzersteuerelement mit dem Namen Control2. Doppelklick auf das Formular, um die Codedatei zu bringen.

  2. Fügen Sie System.Drawing.DesignSystem.Globalization und Namespaces hinzu, die in der Klasse verwendet werden.

    Imports System.Drawing.Design
Imports System.Globalization

    using System.Drawing.Design;
using System.Globalization;

  3. Hinzufügen einer Schaltfläche und einen Schaltflächenklick-Ereignishandler hinzu, und aktualisieren Sie den Konstruktor des Steuerelements genau wie Sie aktualisierte das erste Steuerelement.

  4. Fügen Sie DisplayNameAttribute, DescriptionAttribute, ToolboxItemAttributeund ToolboxBitmapAttribute-Attribute der Datei hinzu.

    Diese Attribute ermöglichen einem VSPackage, um für eine ToolboxItem-Klasse abzufragen.

    Weitere Informationen und Beispiele zum Erstellen von benutzerdefinierten ToolboxItem-Objekte finden Sie in der Erläuterung in der ToolboxItem Referenzseite schreibt.

    Zusammen mit den vorherigen Änderungen sollte die zweite Steuerelementklasse dem folgenden Code ähneln. Das Symbol Control2_ToolboxMenu wird nach dem nächsten Schritt nicht definiert.

    ' Set the display name and custom bitmap to use for Me item. 
' The build action for the bitmap must be "Embedded Resource". 
' Also declare a custom toolbox item implementation.
<DisplayName("ToolboxMember 2 VB")> _
<Description("Custom toolbox item from package LoadToolboxMembers.")> _
<ToolboxItem(GetType(Control2_ToolboxItem))> _
<ToolboxBitmap(GetType(Control2), "Control2.bmp")> _
Public Class Control2

    Public Sub New()
        InitializeComponent()

        Button1.Text = Me.Name + " Button" 
    End Sub 

    Private Sub Button1_Click(ByVal sender As Object, ByVal e As EventArgs) _
        Handles Button1.Click

        MessageBox.Show("Hello world from " & Me.ToString())
    End Sub 
End Class

    // Set the display name and custom bitmap to use for this item. 
// The build action for the bitmap must be "Embedded Resource".
// Also declare a custom toolbox item implementation.
[DisplayName("ToolboxMember 2 CS")]
[Description("Custom toolbox item from package LoadToolboxMembers.")]
[ToolboxItem(typeof(Control2_ToolboxItem))]
[ToolboxBitmap(typeof(Control2), "Control2.bmp")]
public partial class Control2 : UserControl
{
    public Control2()
    {
        InitializeComponent();

        button1.Text = this.Name + " Button";
    }

    private void button1_Click(object sender, EventArgs e)
    {
        MessageBox.Show("Hello world from " + this.ToString());
    }
}

  5. Erstellen Sie eine Klasse, die Control2_ToolboxItembenannt ist. Dieses ToolboxItem wird für das zweite Steuerelement erstellt und dem Projektmappen-Explorer hinzugefügt Toolboxsoll. Die Klasse muss SerializableAttribute verfügen, das zuvor angewendet wird.

    <Serializable()> _
Friend Class Control2_ToolboxItem
    Inherits ToolboxItem

    Public Sub New(ByVal toolType As Type)
        MyBase.New(toolType)
    End Sub 

    Public Overrides Sub Initialize(ByVal toolType As Type)

        If Not toolType.Equals(GetType(Control2)) Then 
            Throw New ArgumentException( _
                String.Format(CultureInfo.CurrentCulture, _
                    "The {0} constructor argument must be of type {1}.", _
                    Me.GetType().FullName, GetType(Control2).FullName))
        End If 

        MyBase.Initialize(toolType)
    End Sub 
End Class

    [Serializable()]
internal class Control2_ToolboxItem : ToolboxItem
{
    public Control2_ToolboxItem(Type toolType)
        : base(toolType) { }

    public override void Initialize(Type toolType)
    {
        if (!toolType.Equals(typeof(Control2)))
        {
            throw new ArgumentException(
                string.Format(CultureInfo.CurrentCulture,
                    "The {0} constructor argument must be of type {1}.",
                    this.GetType().FullName, typeof(Control2).FullName));
        }

        base.Initialize(toolType);
    }
}

  6. Speichern Sie die Datei.

Bitmapdatei einbetten Symbole

Die zwei Instanzen von ToolboxBitmapAttribute zuvor angegeben haben, dass das Projekt die beiden Steuerelemente darstellt, indem sie die folgenden Symbole verwenden:

  • Control1.bmpim Namespace, der das erste Steuerelement enthält.

  • Control2.bmpim Namespace, der dem zweiten Steuerelement enthält.

Um Symbole für das Einbetten ToolboxItem Bitmapdatei

  1. Fügen Sie zwei neue Bitmap wie folgt dem Projekt hinzu.

    1. Klicken Sie mit der rechten Maustaste auf das LoadToolboxMembers Projekt.

    2. Zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element.

    3. Wählen Sie im Dialogfeld Neues Element hinzufügen Namen Bitmapdateiund die Datei Control1.bmp.

    4. Wiederholen Sie diese Schritte für die zweite Bitmap und nennen Sie ihn Control2.bmp.

      Auf diese Weise wird eine Bitmap im Bitmap-Editor Visual Studio .

  2. Legen Sie die Größe jedes Symbols bis 16 x 16 wie folgt fest.

    1. Für jede Bitmap im Menü Ansicht auf Eigenschaftenfenster .

    2. Legen Sie im Fenster EigenschaftenHöhe und Breite auf 16 fest.

  3. Verwenden Sie den Bitmap-Editor in Visual Studio , um ein Bild für jedes Symbol zu erstellen.

  4. In Projektmappen-Explorerklicken Sie auf jede Bitmapdatei im Fenster, und klicken Sie dann EigenschaftenBuildvorgang , legen Sie die Eigenschaft auf Eingebettete Ressource.

  5. Speichern Sie alle geöffneten Dateien.

Die VSPackage-Implementierung ändern

Die Standardimplementierung VSPackages muss geändert werden, um die folgenden Aufgaben auszuführen:

Das folgende Verfahren zeigt, wie Sie die Implementierung des Pakets ändern kann.

So ändern Sie die Implementierung des Pakets ein Toolboxelement Info-Anbieter für ein VSPackage ist

  1. Öffnen Sie die LoadToolboxMembersPackage.cs- oder LoadToolboxMembersPackage.vb-Datei im Code-Editor.

  2. Ändern Sie die Deklaration der LoadToolboxMembersPackage-Klasse, die die Implementierung der Package-Klasse in der Lösung lautet wie folgt.

    1. Fügen Sie die folgenden Direktiven Namespace der LoadToolboxMembersPackage-Klassendatei hinzu.

      Imports System.Collections
Imports System.ComponentModel
Imports System.Drawing.Design
Imports System.Reflection

      using System.Collections;
using System.ComponentModel;
using System.Drawing.Design;
using System.Reflection;

    2. Registrieren von VSPackages als ToolboxItem-Klasse, indem Sie eine Instanz von ProvideToolboxItemsAttributehinzufügen.

      Hinweis

      Das einzige Argument von ProvideToolboxItemsAttribute ist die Version von ToolboxItem , die von einem VSPackage bereitgestellt wird.Diesen Wert ändern, erzwingt die IDE, um VSPackages zu laden, auch wenn es sich um eine frühere zwischengespeicherte Version von ToolboxItem-Klasse hat.

    3. Fügen Sie die folgenden beiden neuen privateLoadToolboxMembersPackage Felder der Klasse hinzu:

      Ein ArrayList-Member mit dem Namen ToolboxItemList, eine Liste der ToolboxItem-Objekte enthalten, die die LoadToolboxMembersPackage-Klasse verwaltet.

      StringNamen CategoryTab, das die Toolbox Kategorie oder - Registerkarte, mit der die ToolboxItem-Objekte enthält, die durch die LoadToolboxMembersPackage-Klasse verwaltet werden.

    Das Ergebnis dieser Änderung ähnelt dem folgenden Code:

    Imports Microsoft.VisualBasic
Imports System
Imports System.Diagnostics
Imports System.Globalization
Imports System.Runtime.InteropServices
Imports System.ComponentModel.Design
Imports Microsoft.Win32
Imports Microsoft.VisualStudio.Shell.Interop
Imports Microsoft.VisualStudio.OLE.Interop
Imports Microsoft.VisualStudio.Shell

Imports System.Collections
Imports System.ComponentModel
Imports System.Drawing.Design
Imports System.Reflection

' ...
<PackageRegistration(UseManagedResourcesOnly:=True), _
DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\9.0"), _
InstalledProductRegistration(False, "#110", "#112", "1.0", IconResourceID:=400), _
ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1), _
ProvideMenuResource(1000, 1), _
Guid(GuidList.guidLoadToolboxMembersPkgString)> _
<ProvideToolboxItems(1)> _
Public NotInheritable Class LoadToolboxMembersPackage
    Inherits Package

    ' List for the toolbox items provided by this package. 
    Private ToolboxItemList As ArrayList

    ' Name for the Toolbox category tab for the package's toolbox items. 
    Private CategoryTab As String = "LoadToolboxMembers Walkthrough VB" 

    ' ...

    using System;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.ComponentModel.Design;
using Microsoft.Win32;
using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Shell;

using System.Collections;
using System.ComponentModel;
using System.Drawing.Design;
using System.Reflection;

namespace Company.LoadToolboxMembersCS
{
    // ...
    [PackageRegistration(UseManagedResourcesOnly = true)]
    // ...
    [DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\9.0")]
    // ...
    [InstalledProductRegistration(false, "#110", "#112", "1.0", IconResourceID = 400)]
    // ...
    [ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1)]
    // ...
    [ProvideMenuResource(1000, 1)]
    [Guid(GuidList.guidLoadToolboxMembersPkgString)]
    [ProvideToolboxItems(1)]
    public sealed class LoadToolboxMembersPackage : Package
    {
        // List for the toolbox items provided by this package. 
        private ArrayList ToolboxItemList;

        // Name for the Toolbox category tab for the package's toolbox items. 
        private string CategoryTab = "LoadToolboxMembers Walkthrough CS";

        // ...

  3. Erweitern Sie den Bereich Paket-Member, um die Initialize zu ändern, um die folgenden Aufgaben auszuführen:

    • Für Visual C#abonnieren Sie den ToolboxInitialized und ToolboxUpgraded-Ereignissen.

    • Rufen Sie die CreateItemList-Methode auf, um das ArrayList-Objekt ToolboxItemListauszufüllen. ToolboxItemList enthält eine Liste aller Toolboxelemente, die LoadToolboxMembersPackage verwaltet.

    Protected Overrides Sub Initialize()
    Trace.WriteLine(String.Format(CultureInfo.CurrentCulture, _
        "Entering Initialize() of: {0}", Me.GetType().Name))
    MyBase.Initialize()

    ' Add our command handlers for menu (commands must exist in the .vsct file) 
    Dim mcs As OleMenuCommandService = _
        TryCast(GetService(GetType(IMenuCommandService)), OleMenuCommandService)
    If Not mcs Is Nothing Then 

        ' Create the command for the menu item. 
        Dim menuCommandID As New CommandID( _
            GuidList.guidLoadToolboxMembersCmdSet, CInt(PkgCmdIDList.cmdidMyCommand))
        Dim menuItem As New MenuCommand( _
            New EventHandler(AddressOf MenuItemCallback), menuCommandID)
        mcs.AddCommand(menuItem)
    End If 

    ' Use reflection to get the toolbox items provided in this assembly.
    ToolboxItemList = CreateItemList(Me.GetType().Assembly)
    If ToolboxItemList Is Nothing Then 
        ' Unable to generate the list. 
        ' Add error handling code here. 
    End If 
End Sub

    protected override void Initialize()
{
    Trace.WriteLine (string.Format(CultureInfo.CurrentCulture,
        "Entering Initialize() of: {0}", this.ToString()));
    base.Initialize();

    // Add our command handlers for menu (commands must exist in the .vsct file)
    OleMenuCommandService mcs =
        GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    if ( null != mcs )
    {
        // Create the command for the menu item.
        CommandID menuCommandID =
            new CommandID(GuidList.guidLoadToolboxMembersCmdSet,
                (int)PkgCmdIDList.cmdidMyCommand);
        MenuCommand menuItem =
            new MenuCommand(MenuItemCallback, menuCommandID );
        mcs.AddCommand( menuItem );

        // Subscribe to the toolbox intitialized and upgraded events.
        ToolboxInitialized += new EventHandler(OnRefreshToolbox);
        ToolboxUpgraded += new EventHandler(OnRefreshToolbox);
    }

    // Use reflection to get the toolbox items provided in this assembly.
    ToolboxItemList = CreateItemList(this.GetType().Assembly);
    if (null == ToolboxItemList)
    {
        // Unable to generate the list. 
        // Add error handling code here.
    }
}

  4. Fügen Sie zwei Möglichkeiten, und CreateItemList Konstrukt, CreateToolboxItemwie folgt hinzu, indem Sie Instanzen der Metadaten ToolboxItem-Objekte, die in der LoadToolboxMembers Assembly verfügbar sind, verwenden:

    ' Scan for toolbox items in the assembly and return the list of 
' toolbox items. 
Private Function CreateItemList(ByVal asmbly As Assembly) As ArrayList

    Dim list As New ArrayList()
    For Each possibleItem As Type In asmbly.GetTypes()

        Dim item As ToolboxItem = CreateToolboxItem(possibleItem)
        If item IsNot Nothing Then
            list.Add(item)
        End If 
    Next 

    Return list
End Function 

' If the type represents a toolbox item, return an instance of the type 
' otherwise, return Nothing. 
Private Function CreateToolboxItem(ByVal possibleItem As Type) As ToolboxItem

    ' A toolbox item must implement IComponent and must not be abstract. 
    If Not GetType(IComponent).IsAssignableFrom(possibleItem) Or _
        possibleItem.IsAbstract Then 

        Return Nothing 
    End If 

    ' A toolbox item must have a constructor that takes a parameter of 
    ' type Type or a constructor that takes no parameters. 
    If possibleItem.GetConstructor(New Type() {GetType(Type)}) Is Nothing And _
        possibleItem.GetConstructor(New Type() {}) Is Nothing Then 

        Return Nothing 
    End If 

    Dim item As ToolboxItem = Nothing 

    ' Check the custom attributes of the candidate type and attempt to 
    ' create an instance of the toolbox item type. 
    Dim attribs As AttributeCollection = _
        TypeDescriptor.GetAttributes(possibleItem)
    Dim tba As ToolboxItemAttribute = TryCast( _
        attribs(GetType(ToolboxItemAttribute)), ToolboxItemAttribute)
    If tba IsNot Nothing And Not tba.Equals(ToolboxItemAttribute.None) Then 

        If Not tba.IsDefaultAttribute() Then 

            ' This type represents a custom toolbox item implementation. 
            Dim itemType As Type = tba.ToolboxItemType
            Dim ctor As ConstructorInfo = _
                itemType.GetConstructor(New Type() {GetType(Type)})
            If ctor IsNot Nothing And itemType IsNot Nothing Then

                item = CType(ctor.Invoke(New Object() {possibleItem}), ToolboxItem)
            Else

                ctor = itemType.GetConstructor(New Type() {})
                If ctor IsNot Nothing Then

                    item = CType(ctor.Invoke(New Object() {}), ToolboxItem)
                    item.Initialize(possibleItem)
                End If 
            End If 
        Else 

            ' This type represents a default toolbox item.
            item = New ToolboxItem(possibleItem)
        End If 

        If item Is Nothing Then 

            Throw New ApplicationException("Unable to create a ToolboxItem " & _
                "object from " & possibleItem.FullName & ".")
        End If 
    End If 

    ' Update the display name of the toolbox item and add the item to 
    ' the list. 
    Dim displayName As DisplayNameAttribute = TryCast( _
        attribs(GetType(DisplayNameAttribute)), DisplayNameAttribute)
    If displayName IsNot Nothing And Not displayName.IsDefaultAttribute() Then

        item.DisplayName = displayName.DisplayName
    End If 

    Return item
End Function

    // Scan for toolbox items in the assembly and return the list of 
// toolbox items. 
private ArrayList CreateItemList(Assembly assembly)
{
    ArrayList list = new ArrayList();
    foreach (Type possibleItem in assembly.GetTypes())
    {
        ToolboxItem item = CreateToolboxItem(possibleItem);
        if (item != null)
        {
            list.Add(item);
        }
    }
    return list;
}

// If the type represents a toolbox item, return an instance of the type; 
// otherwise, return null. 
private ToolboxItem CreateToolboxItem(Type possibleItem)
{
    // A toolbox item must implement IComponent and must not be abstract. 
    if (!typeof(IComponent).IsAssignableFrom(possibleItem) ||
        possibleItem.IsAbstract)
    {
        return null;
    }

    // A toolbox item must have a constructor that takes a parameter of 
    // type Type or a constructor that takes no parameters. 
    if (null == possibleItem.GetConstructor(new Type[] { typeof(Type) }) &&
        null == possibleItem.GetConstructor(new Type[0]))
    {
        return null;
    }

    ToolboxItem item = null;

    // Check the custom attributes of the candidate type and attempt to 
    // create an instance of the toolbox item type.
    AttributeCollection attribs =
        TypeDescriptor.GetAttributes(possibleItem);
    ToolboxItemAttribute tba =
        attribs[typeof(ToolboxItemAttribute)] as ToolboxItemAttribute;
    if (tba != null && !tba.Equals(ToolboxItemAttribute.None))
    {
        if (!tba.IsDefaultAttribute())
        {
            // This type represents a custom toolbox item implementation.
            Type itemType = tba.ToolboxItemType;
            ConstructorInfo ctor =
                itemType.GetConstructor(new Type[] { typeof(Type) });
            if (ctor != null && itemType != null)
            {
                item = (ToolboxItem)ctor.Invoke(new object[] { possibleItem });
            }
            else
            {
                ctor = itemType.GetConstructor(new Type[0]);
                if (ctor != null)
                {
                    item = (ToolboxItem)ctor.Invoke(new object[0]);
                    item.Initialize(possibleItem);
                }
            }
        }
        else
        {
            // This type represents a default toolbox item.
            item = new ToolboxItem(possibleItem);
        }
    }
    if (item == null)
    {
        throw new ApplicationException("Unable to create a ToolboxItem " +
            "object from " + possibleItem.FullName + ".");
    }

    // Update the display name of the toolbox item and add the item to 
    // the list.
    DisplayNameAttribute displayName =
        attribs[typeof(DisplayNameAttribute)] as DisplayNameAttribute;
    if (displayName != null && !displayName.IsDefaultAttribute())
    {
        item.DisplayName = displayName.DisplayName;
    }

    return item;
}

  5. Implementieren Sie die OnRefreshToolbox-Methode, um die ToolboxInitialized und ToolboxUpgraded-Ereignisse zu behandeln.

    Die OnRefreshToolbox-Methode verwendet die Liste der ToolboxItem-Objekten, die im ToolboxItemList-Member der LoadToolboxMembersPackage-Klasse enthalten ist. Sie führt außerdem die folgenden Punkte:

    • Entfernt alle ToolboxItem-Objekte, die bereits in der Toolboxkategorie vorhanden sind, die durch die Variable CategoryTabdefiniert ist.

    • Fügt neue Instanzen aller ToolboxItem-Objekte hinzu, die in ToolboxItemList auf die Registerkarte Kategorie für das VSProject aufgeführt sind.

    • Legt die aktive Registerkarte Toolbox auf die Registerkarte Kategorie für das VSProject fest.

    Private Sub OnRefreshToolbox(ByVal sender As Object, ByVal e As EventArgs) _
    Handles Me.ToolboxInitialized, Me.ToolboxUpgraded

    ' Add new instances of all ToolboxItems contained in ToolboxItemList. 
    Dim service As IToolboxService = TryCast( _
            GetService(GetType(IToolboxService)), IToolboxService)
    Dim toolbox As IVsToolbox = TryCast( _
        GetService(GetType(IVsToolbox)), IVsToolbox)

    'Remove target tab and all controls under it. 
    For Each oldItem As ToolboxItem In service.GetToolboxItems(CategoryTab)
        service.RemoveToolboxItem(oldItem)
    Next
    toolbox.RemoveTab(CategoryTab)

    For Each itemFromList As ToolboxItem In ToolboxItemList
        service.AddToolboxItem(itemFromList, CategoryTab)
    Next
    service.SelectedCategory = CategoryTab

    service.Refresh()
End Sub

    void OnRefreshToolbox(object sender, EventArgs e)
{
    // Add new instances of all ToolboxItems contained in ToolboxItemList.
    IToolboxService service =
        GetService(typeof(IToolboxService)) as IToolboxService;
    IVsToolbox toolbox = GetService(typeof(IVsToolbox)) as IVsToolbox;

    //Remove target tab and all controls under it. 
    foreach (ToolboxItem oldItem in service.GetToolboxItems(CategoryTab))
    {
        service.RemoveToolboxItem(oldItem);
    }
    toolbox.RemoveTab(CategoryTab);

    foreach (ToolboxItem itemFromList in ToolboxItemList)
    {
        service.AddToolboxItem(itemFromList, CategoryTab);
    }
    service.SelectedCategory = CategoryTab;

    service.Refresh();
}

    Hinweis

    Als Übung konnte Erstellen eines Mechanismus zum Testen der Version von VSPackages oder der Elemente entwickeln und aktualisiert nur VSPackages, wenn die Version geändert wurde oder wenn die Version ToolboxItem geändert hat.

Die Toolbox initialisieren

So fügen Sie einen Befehl implementieren, die Toolbox nicht initialisiert werden

  • Ändern Sie die befehls-Handler Menüelement MenuItemCallBackMethode wie folgt.

    1. Ersetzen Sie die vorhandene Implementierung von MenuItemCallBack durch den folgenden Code:

      Private Sub MenuItemCallback(ByVal sender As Object, ByVal e As EventArgs)
    Dim pkg As IVsPackage = TryCast(GetService(GetType(Package)), Package)
    pkg.ResetDefaults(CUInt(__VSPKGRESETFLAGS.PKGRF_TOOLBOXITEMS))
End Sub

      private void MenuItemCallback(object sender, EventArgs e)
{
    IVsPackage pkg = GetService(typeof(Package)) as Package;
    pkg.ResetDefaults((uint)__VSPKGRESETFLAGS.PKGRF_TOOLBOXITEMS);
}

Erstellen und Ausführen der Projektmappe

Sie können das Produkt dieser exemplarischen Vorgehensweise testen, indem Sie eine Instanz von Visual Studio verwenden, auf das in der experimentellen Hive ausgeführt wird.

Um diese exemplarische Vorgehensweise testen

  1. Klicken Sie in Visual Studio im Menü Erstellen auf Projektmappe neu erstellen.

  2. Drücken Sie F5, um eine zweite Instanz von Visual Studio in der experimentellen Registrierungshiven zu starten.

    Weitere Informationen zur Verwendung der experimentellen Hive finden Sie unter Experimentelle Instanz von Visual Studioverwendet.

  3. Klicken Sie auf das Menü Extras.

    Ein Befehl benannte LoadToolboxMembers initialisieren VB , oder LoadToolboxMembers initialisieren CS sollte am Anfang des Menüs, zusammen mit einem Symbol angezeigt, das das Zahl1 aufweist.

  4. Erstellen Sie eine neue Visual C# oder eine Visual Basic Windows Forms-Anwendung.

    Ein er-basiert Designer Formsollte angezeigt werden.

  5. Ziehen Sie eine oder beide der neuen Steuerelemente in der Exemplarische Vorgehensweisen für LoadToolboxMembers VB oder Exemplarische Vorgehensweisen für LoadToolboxMembers CS Kategorie Toolbox Sie dem Formular im Designer.

    Hinweis

    Wenn Toolbox nicht angezeigt wird, klicken Sie auf Toolbox im Menü Ansicht .Wenn die Registerkarte Kategorien für Toolboxnicht in einem VSPackage wird, initialisieren Sie Toolbox , indem Sie LoadToolboxMembers initialisieren VB oder auf LoadToolboxMembers initialisieren CS im Menü Extras .

  6. Erstellen Sie die Windows-Anwendung auf, indem Sie auf Projektmappe neu erstellen im Menü Erstellen .

  7. Führen Sie die Anwendung aus, indem Sie entweder Start oder auf Mit Debugging beginnen im Menü Debuggen .

  8. Wenn die Anwendung ausgeführt wird, klicken Sie auf eine der Steuerelemente, die Sie zur Anwendung hinzugefügt haben.

    Ein Meldungsfeld wird angezeigt. Er enthält entweder "Hello world from Company.LoadToolboxMembers.Control1" oder"Hello world from Company.LoadToolboxMembers.Control2"an.

Die Analyse der Implementierung

Erstellen Toolbox-Kontrollen

Die Attribute, die Control1 und Control2 zugewiesen sind, werden von der Methode CreateItemList zum Verschlüsseln von Abfragen, die für Assembly verfügbar Toolbox steuert.

  • ToolboxItemAttribute werden die folgenden zwei Funktionen aus:

    • Die Zuweisung von ToolboxItemAttribute zu Control1 und Control2, die angibt, dass jedes einen Toolbox die Steuerung ist.

    • Das Argument für den ToolboxItemAttribute-Konstruktor, der angibt, ob ToolboxItem standardmäßige oder eine benutzerdefinierte Klasse, die von ToolboxItem abgeleitete verwendet wird, wenn das Steuerelement Toolboxhinzugefügt wird.

      Die Instanz von ToolboxItemAttribute , die Control1 zugewiesen wird, wird erstellt, indem ein Argument von trueverwendet, das angibt, dass es sich um eine standardmäßige ToolboxItem-Klasse verwendet, wenn es in Toolboxhinzugefügt wird.

      Die Instanz von ToolboxItemAttribute , die Control2 zugewiesen wird, wird erstellt, indem Type einer Klasse veranschaulicht, die von ToolboxItem, Control2_ToolboxItemabgeleitet ist.

  • Die ToolboxBitmapAttribute-Klasse gibt Bitmaps an, die von der Umgebung verwendet werden, um die Steuerelemente zu identifizieren.

    Das Einbetten einer Bitmap in einer Assembly, indem ihre Buildvorgang-Eigenschaft auf Eingebettete Ressource festgelegt wird, wird die Bitmap in den Namespace der Assembly ein. Daher kann Control1.bmp als Company.LoadToolboxMembers.Control1.bmpbezeichnet.

    ToolboxBitmapAttribute unterstützt einen Konstruktor, der den vollständigen Pfad als Argument verwendet. Beispielsweise könnte eine ToolboxBitmapAttribute-Klasse Control1 angewendet werden, indem [ToolboxBitmap("Company.LoadToolboxMembers.Control1.bmp")]übergeben wird.

    Um eine größere Flexibilität zu unterstützen, verwendet dieser exemplarischen Vorgehensweise einen Konstruktor, der dem ToolboxBitmapAttribute-Konstruktor eine Type-Klasse als Erstes Argument akzeptiert. Der Namespace, der verwendet wird, um die Bitmapdatei zu identifizieren, wird von Type abgerufen und eingefügt vor dem Basisnamen der Bitmap.

    Da das Type-Objekt, das Packageimplementiert, LoadToolboxMembersim Company.LoadToolboxMembers-Namespace [ToolboxBitmap(typeof(Control1), "Control1.bmp")] ist entsprechend [ToolboxBitmap("Company.LoadToolboxMembers.Control1.bmp")]ist.

  • DisplayNameAttribute gibt den Namen des Steuerelements in Toolboxan.

Registrieren eines Toolbox-Steuer Textanbieter

Durch Anwenden der ProvideToolboxItemsAttribute-Klasse auf die Klasse an, die Package implementiert, wirkt sich die Registrierungseinstellungen resultierenden VSPackages. Weitere Informationen zu den Registrierungseinstellungen für einen ToolboxItem Anbieter finden Sie unter Registrieren von Toolbox-Stütz.

Die Visual Studio Umgebung verwendet das Argument mit Versionsangaben für den ProvideToolboxItemsAttribute-Konstruktor, um die Zwischenspeicherung von VSPackages zu verwalten, das Elemente Toolboxbereitstellen. Nachdem VSPackages geladen wurde, um Toolboxelemente bereitzustellen, wird eine zwischengespeicherte Version VSPackages verwendet, bis die registrierte Version des Anbieters ändert. Wenn Sie das Produkt dieser exemplarischen Vorgehensweise ändern möchten, nachdem Sie es erstellt haben, dass Sie das Argument Version des Konstruktors ProvideToolboxItemsAttribute zu ändern, der AddToolboxItemangewendet wird. Beispielsweise sollte [ProvideToolboxItems(1)] zu [ProvideToolboxItems(2)]geändert werden. Wenn die Version nicht geändert wird, lädt die Visual Studio Umgebung keine Änderungen vorgenommen werden.

In dieser exemplarischen Vorgehensweise wird ein VSPackage so konfiguriert, dass nur Toolbox-Steuerelemente bereitzustellen, die das standardmäßige Zwischenablageformat unterstützen. Eine Liste der standardmäßigen Zwischenablageformaten finden Sie unter Toolbox (Visual Studio SDK). Wenn Sie andere Zwischenablageformate unterstützen möchten oder entscheiden, um ein Standardformat nicht zu unterstützen, wenden Sie das Attribut ProvideToolboxFormatAttribute zur LoadToolboxMembersPackage-Klasse. Weitere Informationen zum Registrieren eines Steuerelements Toolbox Anbieters finden Sie unter Erweiterte Toolbox-Steuerentwicklung.

Hinzufügen von Steuerelementen zur Toolbox

Die Funktionalität in CreateItemList emuliert, was in System#Drawing#Design#IToolboxService#GetToolboxItemsverfügbar ist.

Die CreateItemList-Methode überprüft nur nicht abstrakte Type-Objekten, die die IComponent-Schnittstellen implementieren.

Nächste Schritte

Verwenden System#Drawing#Design#IToolboxService#GetToolboxItems statt CreateItemList würde das Produkt aus dieser exemplarischen Vorgehensweise robuster erstellen.

Sie können CreateItemList auch ändern, um ParseToolboxResource auf Laststeuerungen in Toolbox Text auf Grundlage einer Liste zu verwenden, die in der LoadToolboxMembers Assembly eingebettet ist.

Siehe auch

Aufgaben

Erweiterte Toolbox-Steuerentwicklung

Konzepte

Registrieren von Toolbox-Stütz

Weitere Ressourcen

Toolbox (Visual Studio SDK)

Toolbox-exemplarische Vorgehensweisen