Exemplarische Vorgehensweise: ToolboxItem-Konfiguration dynamisch anpassen

In dieser exemplarischen Vorgehensweise wird erläutert, wie verwaltete VSPackages dynamische Unterstützung für die Konfiguration ToolboxItem-Objekte bereitstellen kann.

Hinweis

Die einfachste Möglichkeit, benutzerdefinierte Steuerelement der Toolbox hinzufügen, die Toolbox-Steuerelementvorlagen zu verwenden, die mit dem Visual Studio 10 SDK enthalten sind.Dieses Thema bezieht zur erweiterten Toolbox entwicklung.

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 die ToolboxItemAttribute und ToolboxBitmapAttribute-Klassen verwenden.

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

   • Ein Steuerelement, das zugehörige Standardwert ToolboxItemdeklariert.

   • Ein Steuerelement, das ein zugeordnetes benutzerdefiniertes Toolboxelement deklariert, das von der ToolboxItem-Klasse abgeleitet ist.

3. Schreiben Sie eine Implementierung von IConfigureToolboxItem, und registrieren Sie diese, indem Sie die folgenden Schritte ausführen:

   1. Eine Filter Klasse definieren, die von der IConfigureToolboxItem-Klasse abgeleitet ist und die ToolboxItem-Instanzen angibt, die nach dieser Implementierung wird.

   2. ProvideToolboxItemConfigurationAttribute, die die Filter Klasse verweist auf die Klasse anwenden, die die Package-Klasse für ein VSPackage implementieren.

4. Registrieren von VSPackages als Anbieter von ToolboxItem-Objekten, indem Sie ProvideToolboxItemsAttribute auf die Klasse anwenden, die die Package-Klasse für ein VSPackage implementieren.

5. Verwendet Reflektion ladezeit Paket an der eine Liste aller ToolboxItem-Objekte zu generieren, die ein VSPackage bereitstellt.

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

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

Führen Sie die folgenden Schritte aus, um einen verwalteten VSPackages zu erstellen.

Um einen verwalteten VSPackages erstellen, um Toolboxelemente bereitzustellen

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

2. In der Visual Studio-Paket Vorlage fügen Sie einen Menübefehl hinzu.

   Nennen Sie den Befehl Initialisieren Sie ItemConfigurationVB für Initialisieren Sie ItemConfigurationCS für Visual Basic oder Visual C#.

3. Für Visual Basicfügen Sie die folgenden Namespaces der Liste Importierte Namespaces im generierten Projekt hinzu:

   • Company.ItemConfiguration

   • System

   • System.ComponentModel

   • System.Drawing

   • System.Windows.Forms

4. Fügen Sie einen Verweis auf die Komponente System.Drawing.Design .NET Framework hinzu.

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:

   1. Öffnen Sie die Projekteigenschaften, und wählen Sie die Registerkarte Anwendung aus.

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

   2. Wählen Sie die Registerkarte Verweise aus.

      Aktualisieren Sie die Liste Importierte Namespaces.

      Entfernen Sie Company.ItemConfiguration.

      Fügen Sie Company.ItemConfigurationVB hinzu.

2. Für Visual C#:

   1. Öffnen Sie die Projekteigenschaften, und wählen Sie die Registerkarte Anwendung aus.

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

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

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

3. Speichern Sie die Änderungen.

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ü ExtrasElementkonfiguration initialisieren VB oder klicken Sie auf Elementkonfiguration initialisieren CS.

   Auf diese Weise 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.

Erstellen Toolbox-Kontrollen

In diesem Abschnitt erstellen Sie ein Benutzersteuerelement, und registrieren Control1, das ein zugeordnetes Standardwert Toolboxelement deklariert. Sie erstellen und registrieren Benutzersteuerelement ein zweites Control2und ein zugeordnetes benutzerdefiniertes Toolboxelement, Control2_ToolboxItem, das von der ToolboxItem-Klasse abgeleitet ist. Weitere Informationen dazu, wie Sie Windows Forms-Steuerelemente und ToolboxItem-Klassen finden Sie unter Entwickeln von Windows Forms-Steuerelementen zur Entwurfszeiterstellt.

So zeigen Sie die standardmäßigen und benutzerdefinierten Toolboxelemente erstellen

1. Verwenden Sie die Anweisungen unter Exemplarische Vorgehensweise: Toolboxelemente automatisch laden , ein standardmäßiges Toolboxelement und ein benutzerdefiniertes Toolboxelement erstellt werden soll, wie folgt aus.

   1. Schließen Sie die Prozedur ab Toolbox „, um ein Steuerelement zu erstellen, das verwendet wird ToolboxItem mit einem Standardwert“. Aktualisieren Sie DescriptionAttribute , um das Projekt zu verweisen.

      Der resultierende Code für die Control1-Klasse sollte dem folgenden Code ähneln.

      ' 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 ItemConfiguration.")> _
      <ToolboxItem(True)> _
      <ToolboxBitmap(GetType(Control1), "Control1.bmp")> _
      Public Class Control1
      
          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
      

      using System;
      using System.ComponentModel;
      using System.Drawing;
      using System.Windows.Forms;
      
      namespace Company.ItemConfigurationCS
      {
          // 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 ItemConfiguration.")]
          [ToolboxItem(true)]
          [ToolboxBitmap(typeof(Control1), "Control1.bmp")]
          public partial class Control1 : UserControl
          {
              public Control1()
              {
                  InitializeComponent();
      
                  button1.Text = this.Name + " Button";
              }
      
              private void button1_Click(object sender, EventArgs e)
              {
                  MessageBox.Show("Hello world from " + this.ToString());
              }
          }
      }
      

   2. Schließen Sie die Prozedur ab Toolbox „, um ein Steuerelement zur Verwendung einer benutzerdefinierten ToolboxItem-abgeleiteten Klasse zu erstellen.“ Aktualisieren Sie DescriptionAttribute , um das Projekt zu verweisen.

      Der resultierende Code für die Control2 und Control2_ToolboxItem-Klassen sollte dem folgenden Code ähneln.

      Imports System.Drawing.Design
      Imports System.Globalization
      
      ' 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 ItemConfiguration.")> _
      <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
      
      <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
      

      using System;
      using System.ComponentModel;
      using System.Drawing;
      using System.Windows.Forms;
      
      using System.Drawing.Design;
      using System.Globalization;
      
      namespace Company.ItemConfigurationCS
      {
          // 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 ItemConfigurationPackage.")]
          [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());
              }
          }
      
          [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);
              }
          }
      }
      

2. Speichern Sie die Dateien.

Bitmapdatei einbetten Symbole

Das ToolboxBitmapAttribute-Attribut, das für jedes Steuerelement angewendet wird, gibt das Symbol an, das dem Steuerelement zugeordnet werden soll. Erstellen Sie die Bitmaps für beide Steuerelemente, und nennen Sie sie wie folgt:

• Control1.bmp, für die Control1-Klasse.

• Control2.bmp, für die Control2-Klasse.

So legen Sie ein Symbol Bitmap für ein Toolboxelement einbetten

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

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

   2. Wählen Sie im Dialogfeld Neues Element hinzufügenBitmapdateiund geben den Namen der Bitmap.

2. Verwenden Sie den Bitmap-Editor zum Erstellen 16∝16 ein Symbol wie folgt.

   1. Klicken Sie im Menü Ansicht auf Eigenschaftenfenster.

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

   3. Verwenden Sie den Editor, um das Symbolbild zu erstellen.

3. In Projektmappen-ExplorerBitmap mit der rechten Maustaste auf das Element, und klicken Sie dann auf Eigenschaften.

4. Legen Sie die Eigenschaft auf Eingebettete RessourceBuildvorgang fest.

5. Speichern Sie alle geöffneten Dateien.

Hinzufügen eines dynamischen Toolbox-Konfigurationsanbieter

In diesem Abschnitt erstellen und registrieren Sie eine Klasse, die die IConfigureToolboxItem-Schnittstelle implementiert. Diese Klasse wird von der Visual Studio integrierte Entwicklungsumgebung (IDE) instanziiert und verwendet wird, um Steuerelemente zu Toolbox konfigurieren.

Hinweis

Da die Visual Studio Umgebung eine Instanz der Implementierung von IConfigureToolboxIteminstanziiert, implementieren Sie nicht die IConfigureToolboxItem-Schnittstelle für die Klasse, diePackage für ein VSPackage implementieren.

So steuer Toolbox ein konfigurations Objekt erstellen und registrieren

1. In Projektmappen-Explorerfügen Sie dem ItemConfigurations-Projekt eine Klasse hinzu, und nennen Sie sie ToolboxConfig.

2. Fügen Sie der Datei die folgenden Namespaces Anweisungen hinzu.

   Imports Microsoft.VisualStudio.Shell
   Imports System.Collections
   Imports System.ComponentModel
   Imports System.Drawing.Design
   Imports System.Reflection
   Imports System.Runtime.InteropServices
   Imports System.Security.Permissions
   

   using Microsoft.VisualStudio.Shell;
   using System.Collections;
   using System.ComponentModel;
   using System.Drawing.Design;
   using System.Reflection;
   using System.Runtime.InteropServices;
   using System.Security.Permissions;
   

3. Stellen Sie sicher, dass die ToolboxConfig-Klasse public ist und die IConfigureToolboxItem-Schnittstelle implementiert.

4. Wenden Sie GuidAttribute und ProvideAssemblyFilterAttribute zur ToolboxConfig-Klasse.

   • Für Visual Basicverwenden Sie einen Assemblynamen aus „ItemConfigurationVB, Version=*, Culture=*, PublicKeyToken=*“.

   • Für Visual C#verwenden Sie einen Assemblynamen aus „ItemConfigurationCS, Version=*, Culture=*, PublicKeyToken=*“.

   Das zu ToolboxConfig , wird auch die Klasse zum Arbeiten ToolboxItem-Objekten, auf die von der Assembly bereitgestellt werden, die aktuelle VSPackage enthält.

   <ProvideAssemblyFilter("ItemConfigurationVB, Version=*, Culture=*, PublicKeyToken=*")> _
   <Guid("4DDC7895-442A-45e7-82E7-4E85F243C321")> _
   Public Class ToolboxConfig
       Implements IConfigureToolboxItem
   

   [ProvideAssemblyFilter("ItemConfigurationCS, Version=*, Culture=*, PublicKeyToken=*")]
   [Guid("E6832593-BF07-4de1-AA0F-7F9B94887DB8")]
   public class ToolboxConfig : IConfigureToolboxItem
   

   Sie können eine GUID generieren, indem Sie auf GUID erstellen im Menü Extras . Wählen Sie auf das Format mit eckigen KlammernKopierenund anschließend das GUID im Code ein. ändern Sie das Schlüsselwort GUID zu Guid.

5. Implementieren Sie die ConfigureToolboxItem-Methode der IConfigureToolboxItem-Schnittstelle, dass die Methode nur nach den beiden ToolboxItemControl1-Klassen und - Control2ausgeführt wird.

   Die Implementierung von ConfigureToolboxItem wendet Instanzen von ToolboxItemFilterAttribute zu den beiden ToolboxItem-Objekten, sodass:

   • ToolboxItem , das von Control1 implementiert wird, ist in Toolbox nur für Designer zur Verfügung, die UserControl-Objekte behandeln.

   • ToolboxItem , das von Control2 implementiert wird, befindet sich nicht in Toolbox für Designer zur Verfügung, die UserControl-Objekte behandeln.

   <PrincipalPermission(SecurityAction.Demand)> Public Sub _
       ConfigureToolboxItem(ByVal item As ToolboxItem) _
       Implements IConfigureToolboxItem.ConfigureToolboxItem
   
       If item Is Nothing Then Return 
   
       ' Create a filter for the Toolbox. 
       Dim newFilter As ToolboxItemFilterAttribute
       If GetType(Control1).ToString() = item.TypeName Then 
   
           ' For Control1, only show it when editing a UserControl.
           newFilter = New ToolboxItemFilterAttribute( _
               "System.Windows.Forms.UserControl", _
               ToolboxItemFilterType.Require)
   
       ElseIf GetType(Control2).ToString() = item.TypeName Then 
   
           ' For Control2, only show it when not editing a UserControl.
           newFilter = New ToolboxItemFilterAttribute( _
               "System.Windows.Forms.UserControl", _
               ToolboxItemFilterType.Prevent)
   
       Else 
   
           ' Don't apply a filter to other classes. 
           Return 
   
       End If
   
       item.Filter = CType(New ToolboxItemFilterAttribute() {newFilter}, ICollection)
   End Sub
   

   [PrincipalPermission(SecurityAction.Demand)]
   public void ConfigureToolboxItem(ToolboxItem item)
   {
       if (null == item) return;
   
       // Create a filter for the Toolbox.
       ToolboxItemFilterAttribute newFilter;
       if (typeof(Control1).ToString() == item.TypeName)
       {
           // For Control1, only show it when editing a UserControl.
           newFilter = new ToolboxItemFilterAttribute(
               "System.Windows.Forms.UserControl",
               ToolboxItemFilterType.Require);
       }
       else if (typeof(Control2).ToString() == item.TypeName)
       {
           // For Control2, only show it when not editing a UserControl.
           newFilter = new ToolboxItemFilterAttribute(
               "System.Windows.Forms.UserControl",
               ToolboxItemFilterType.Prevent);
       }
       else
       {
           // Don't apply a filter to other classes. 
           return;
       }
   
       item.Filter = (ICollection)(new ToolboxItemFilterAttribute[] { newFilter });
   }
   

Die VSPackage-Implementierung ändern

Die Standardimplementierung VSPackages die von der Vorlage Visual Studio Paket bereitgestellt wird, muss geändert werden, um die folgenden Aufgaben auszuführen:

• Register als Toolboxelement.

• Registrieren Sie die Klasse, die die dynamische Toolbox-Steuerelements Bereitstellungskonfiguration für ein VSPackage bereitstellt.

• Verwenden Sie ToolboxService , um alle ToolboxItem-Objekte zu laden, die von der VSPackage-Assembly bereitgestellt werden.

• Behandeln Sie ToolboxInitialized und ToolboxUpgraded-Ereignisse.

Um die Implementierung des Pakets Toolboxelement für einen Anbieter in einem VSPackage ändern

1. Öffnen Sie die ItemConfigurationPackage-Klasse im Code-Editor.

2. Ändern Sie die Deklaration der ItemConfigurationPackage-Klasse, die die Implementierung der Package-Klasse in der Projektmappe ist.

   1. Fügen Sie der Datei die folgenden Namespaces Anweisungen 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. Um ein VSPackage als Bereitstellen von Toolboxelementen zu registrieren, wenden Sie ProvideToolboxItemsAttribute auf das Paket. Um die ToolboxConfig-Klasse als Bereitstellen einer Toolbox-Steuerelements dynamischen Konfiguration zu registrieren, wenden Sie ProvideToolboxItemConfigurationAttribute auf das Paket.

      ' ...
      <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.guidItemConfigurationPkgString)> _
          <ProvideToolboxItems(1)> _
          <ProvideToolboxItemConfiguration(GetType(ToolboxConfig))> _
      Public NotInheritable Class DynamicToolboxMembersPackage
          Inherits Package
      

      // ...
      [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.guidItemConfigurationPkgString)]
      [ProvideToolboxItems(1)]
      [ProvideToolboxItemConfiguration(typeof(ToolboxConfig))]
      public sealed class DynamicToolboxMembersPackage : Package
      

      Hinweis

      Das einzige Argument von ProvideToolboxItemsAttribute ist die Version von ToolboxItem , die von einem VSPackage bereitgestellt wird.Wenn Sie diesen Wert ändern, setzen Sie die IDE, um VSPackages zu laden, auch wenn es sich um eine frühere zwischengespeicherte Version von ToolboxItemverfügt.

   3. Erstellen Sie zwei neue private Felder in der ItemConfiguration-Klasse wie folgt:

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

      StringNamen CategoryTab, das die Registerkarte Toolbox enthält, die verwendet wird, um die ToolboxItem-Objekte enthält, die die ItemConfiguration-Klasse verwaltet.

      Private ToolboxItemList As ArrayList
      Private Shared ReadOnly CategoryTab As String = _
          "ItemConfiguration Walkthrough VB"
      

      private ArrayList ToolboxItemList;
      private static readonly string CategoryTab =
          "ItemConfiguration Walkthrough CS";
      

   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.guidItemConfigurationPkgString)> _
       <ProvideToolboxItems(1)> _
       <ProvideToolboxItemConfiguration(GetType(ToolboxConfig))> _
   Public NotInheritable Class DynamicToolboxMembersPackage
       Inherits Package
   
       Private ToolboxItemList As ArrayList
       Private Shared ReadOnly CategoryTab As String = _
           "ItemConfiguration 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.ItemConfigurationCS
   {
       // ...
       [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.guidItemConfigurationPkgString)]
       [ProvideToolboxItems(1)]
       [ProvideToolboxItemConfiguration(typeof(ToolboxConfig))]
       public sealed class DynamicToolboxMembersPackage : Package
       {
           private ArrayList ToolboxItemList;
           private static readonly string CategoryTab =
               "ItemConfiguration Walkthrough CS";
   
           // ...
   

3. Definieren Sie eine OnRefreshToolbox-Methode, um die ToolboxInitialized und ToolboxUpgraded-Ereignisse zu behandeln.

   Die OnRefreshToolbox-Methode verwendet die Liste der ToolboxItem-Objekten, die für das Feld. ToolboxItemList und führt die folgenden Aufgaben aus:

   • Entfernt alle ToolboxItem-Objekte aus der Toolboxregisterkarte, die vom CategoryTab Feld definiert ist.

   • Fügt den neuen Instanzen der Toolboxregisterkarte aller ToolboxItem-Objekte hinzufügen, die im ToolboxItemList Feld aufgeführt sind.

   • Legt die Toolbox Register als die aktive Registerkarte fest.

   ' Add new instances of all ToolboxItems to the toolbox item list. 
   Private Sub OnRefreshToolbox(ByVal sender As Object, ByVal e As EventArgs) _
   Handles Me.ToolboxInitialized, Me.ToolboxUpgraded
   
       Dim service As IToolboxService = _
           TryCast(GetService(GetType(IToolboxService)), IToolboxService)
       Dim toolbox As IVsToolbox = _
            TryCast(GetService(GetType(IVsToolbox)), IVsToolbox)
   
       ' Remove target tab and all items under it. 
       For Each item As ToolboxItem In service.GetToolboxItems(CategoryTab)
           service.RemoveToolboxItem(item)
       Next
       toolbox.RemoveTab(CategoryTab)
   
       ' Recreate the target tab with the items from the current list.  
       For Each item As ToolboxItem In ToolboxItemList
           service.AddToolboxItem(item, CategoryTab)
       Next
       service.SelectedCategory = CategoryTab
   
       service.Refresh()
   End Sub
   

   // Add new instances of all ToolboxItems to the toolbox item list. 
   void OnRefreshToolbox(object sender, EventArgs e)
   {
       IToolboxService service =
           GetService(typeof(IToolboxService)) as IToolboxService;
       IVsToolbox toolbox =
           GetService(typeof(IVsToolbox)) as IVsToolbox;
   
       // Remove target tab and all items under it. 
       foreach (ToolboxItem item in service.GetToolboxItems(CategoryTab))
       {
           service.RemoveToolboxItem(item);
       }
       toolbox.RemoveTab(CategoryTab);
   
       // Recreate the target tab with the items from the current list.  
       foreach (ToolboxItem item in ToolboxItemList)
       {
           service.AddToolboxItem(item, CategoryTab);
       }
       service.SelectedCategory = CategoryTab;
   
       service.Refresh();
   }
   

4. Für Visual C#im Konstruktor, registrieren Sie die OnRefreshToolboxMethode als das Ereignis hander für die ToolboxInitialized und ToolboxUpgraded-Ereignisse.

   this.ToolboxInitialized += new EventHandler(OnRefreshToolbox);
   this.ToolboxUpgraded += new EventHandler(OnRefreshToolbox);
   

5. Ändern Sie die Initialize-Methode in ItemConfigurationPackage , um das ToolboxItemList Feld auszufüllen, indem Sie die GetToolboxItems-Methode der ToolboxService-Klasse aufrufen. Der Toolbox Dienst ruft alle Toolboxelement Klassen ab, die in der aktuell ausgeführten Assembly definiert sind. Das ToolboxItemList Feld wird von Toolbox-Ereignishandlern verwendet, um die Toolboxelemente zu laden.

   Fügen Sie am Ende der Initialize-Methode den folgenden Code hinzu:

   ' Use the toolbox service to get a list of all toolbox items in 
   ' this assembly.
   ToolboxItemList = New ArrayList( _
       ToolboxService.GetToolboxItems(Me.GetType().Assembly, ""))
   If ToolboxItemList Is Nothing Then 
       Throw New ApplicationException( _
           "Unable to generate a toolbox item listing for " & _
           Me.GetType().FullName)
   End If 
   
   ' Update the display name of each toolbox item in the list. 
   Dim thisAssembly As Assembly = Me.GetType().Assembly
   For Each item As ToolboxItem In ToolboxItemList
   
       Dim underlyingType As Type = thisAssembly.GetType(item.TypeName)
       Dim attribs As AttributeCollection = _
           TypeDescriptor.GetAttributes(underlyingType)
       Dim displayName As DisplayNameAttribute = _
           TryCast(attribs(GetType(DisplayNameAttribute)), DisplayNameAttribute)
   
       If displayName IsNot Nothing AndAlso Not displayName.IsDefaultAttribute() Then
           item.DisplayName = displayName.DisplayName
       End If 
   Next
   

   // Use the toolbox service to get a list of all toolbox items in 
   // this assembly.
   ToolboxItemList = new ArrayList(
       ToolboxService.GetToolboxItems(this.GetType().Assembly, ""));
   if (null == ToolboxItemList)
   {
       throw new ApplicationException(
           "Unable to generate a toolbox item listing for " +
           this.GetType().FullName);
   }
   
   // Update the display name of each toolbox item in the list.
   Assembly thisAssembly = this.GetType().Assembly;
   foreach (ToolboxItem item in ToolboxItemList)
   {
       Type underlyingType = thisAssembly.GetType(item.TypeName);
       AttributeCollection attribs =
           TypeDescriptor.GetAttributes(underlyingType);
       DisplayNameAttribute displayName =
           attribs[typeof(DisplayNameAttribute)] as DisplayNameAttribute;
       if (displayName != null && !displayName.IsDefaultAttribute())
       {
           item.DisplayName = displayName.DisplayName;
       }
   }
   

   Hinweis

   Als Übung konnte Erstellen eines Mechanismus zum Testen der Version der Elemente entwickeln und VSPackages oder nur aktualisiert, wenn die VSPackage-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

• In der ItemConfigurationPackage-Klasse ändern Sie die MenuItemCallBack-Methode, die der Befehlshandler des Menüelements ist.

  Ersetzen Sie die vorhandene Implementierung der MenuItemCallBack-Methode durch den folgenden Code:

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

  private void MenuItemCallback(object sender, EventArgs e)
  {
      IVsPackage pkg = GetService(typeof(Package)) as IVsPackage;
      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 ItemConfiguration initialisieren VB , oder ItemConfiguration initialisieren CS wird am oberen Rand des Menüs, zusammen mit einem Symbol, das das Zahl1 aufweist.

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

   Ein er-basiert FormDesigner angezeigt wird.

5. Fügen Sie dem Projekt ein Benutzersteuerelement hinzu.

   Ein Benutzersteuerelement Designer angezeigt wird.

6. fixieren Toolbox geöffnet, und wechseln Sie zwischen den beiden Entwurfsansichten.

   Beachten Sie, dass das Toolboxelement angezeigt wird und welche ausgeblendet ist, hängt davon ab, welcher Designer den Fokus besitzt.

7. Ziehen Sie das erste Toolboxelement für das Benutzersteuerelement, um eine Instanz von Control1 dem Benutzersteuerelement hinzuzufügen.

8. Ziehen Sie das zweite Toolboxelement auf das Formular, um eine Instanz von Control2 dem Formular hinzuzufügen.

9. Erstellen Sie die Windows-Anwendung auf.

   Das Benutzersteuerelement für die Anwendung ist jetzt verfügbar. Toolbox

10. Fügen Sie dem Formular der Anwendung das Benutzersteuerelement hinzu, und dann neu erstellen Sie die Anwendung, und führen Sie sie aus.

    Wenn die Anwendung ausgeführt wird, klicken Sie auf jedes Steuerelement im Formular, um das zugeordnete Meldung ab.

Die Analyse der Implementierung

Da der assemblyFilter-Parameter im ProvideAssemblyFilterAttribute-Klassenkonstruktor vorhanden ist, nur ToolboxItem-Objekte in der Assembly, die in dieser exemplarischen Vorgehensweise erstellt wird, durch die ConfigureToolboxItem-Methode der ToolboxConfg-Klasse verarbeitet werden.

Daher wenn die Exemplarische Vorgehensweisen für ItemConfiguration Kategorie auf Toolboxaktiv ist, wird die ConfigureToolboxItem-Methode der ToolboxConfg-Klasse aufgerufen, und ToolboxItemFilterAttribute-Instanzen werden in den ToolboxItem-Objekte angewendet, die von Control1 und Control2implementiert werden.

Siehe auch

Aufgaben

Erweiterte Toolbox-Steuerentwicklung

Konzepte

Registrieren von Toolbox-Stütz

Weitere Ressourcen

Toolbox (Visual Studio SDK)

Toolbox-exemplarische Vorgehensweisen