Partager via

Procédure pas - à - pas : charger automatiquement des éléments de boîte à outils

  • Article

Cette procédure pas - à - pas illustre un VSPackage managé peut utiliser la réflexion pour charger automatiquement tous les éléments d' ToolboxItem fournis par son propre assembly.

Notes

La méthode recommandée pour ajouter des contrôles personnalisés à la boîte à outils est d'utiliser des modèles de contrôle de la boîte à outils fournis avec Visual Studio 10 SDK, qui incluent la prise en charge de chargement automatique.Cette rubrique est conservé pour la compatibilité descendante, pour ajouter des contrôles existants à la boîte à outils, et pour le développement avancées de boîte à outils.

Pour plus d'informations sur la création de contrôles de boîte à outils en utilisant des modèles, consultez Comment : créez un contrôle de boîte à outils qui utilise Windows Forms et le Comment : créez un contrôle de boîte à outils qui utilise WPF.

Cette procédure pas - à - pas vous guide à travers les étapes suivantes :

  1. Ajoutez et inscrit correctement tous les contrôles de boîte à outils dans les objets d'un VSPackage à l'aide de ToolboxItemAttribute, d' ToolboxBitmapAttribute, et d' DisplayNameAttribute.

  2. Créez les deux contrôles suivants, puis ajoutez les icônes pour chacun à boîte à outils:

    • Ajoutez un contrôle à l'aide d'une classe par défaut d' ToolboxItem .

    • Ajoutez un autre contrôle à l'aide d'une classe personnalisée dérivée de la classe d' ToolboxItem .

  3. Enregistrez le VSPackage en tant que spécification des objets d' ToolboxItem qui ont la classe d' ProvideToolboxItemsAttribute .

  4. Utilisez la réflexion pour générer une liste de tous les objets d' ToolboxItem que le VSPackage fournit lorsqu'il est chargé.

  5. créez un gestionnaire pour les événements d' ToolboxInitialized et d' ToolboxUpgraded . Cela garantit que les objets d' ToolboxItem du VSPackage sont correctement chargés.

  6. Implémentez une commande dans le VSPackage de forcer la réinitialisation de boîte à outils.

Composants requis

Pour exécuter cette procédure, vous devez installer Kit de développement logiciel Visual Studio 2010.

Notes

Pour plus d'informations sur le kit de développement Visual Studio, consultez Étendre la présentation de Visual Studio.Pour savoir comment télécharger le kit de développement Visual Studio, consultez Visual Studio Extensibility Developer Center sur le site Web MSDN.

Emplacements du modèle de projet de package Visual Studio

Le modèle de projet de package Visual Studio se trouve dans trois emplacements différents dans la boîte de dialogue Nouveau projet :

  1. Sous l'extensibilité Visual Basic. Le langage par défaut du projet est en Visual Basic.

  2. Sous l'extensibilité c#. Le langage par défaut du projet est c#.

  3. Sous d'autres projets contenus l'extensibilité. Le langage par défaut du projet est en C++.

créer un VSPackage managé

pour créer le LoadToolboxMembers VSPackage

  1. créez un VSPackage nommé LoadToolboxMembers. Pour plus d'informations, consultez Procédure pas - à - pas : Créer une commande de menu à l'aide de le modèle de package Visual Studio.

  2. ajoutez une commande de menu.

    Nommez la commande initialisez LoadToolboxMembers VB pour Visual Basic ou initialisez le CS de LoadToolboxMembers pour Visual c#.

Si vous suivez cette procédure pas - à - pas pour le plusieurs langues, vous devez mettre à niveau le projet pour lever l'ambiguïté entre des assemblys générés.

Pour supprimer l'ambiguïté Visual Basic et Visual c# VSPackages

  1. pour Visual Basic:

    • Dans l'explorateur de solutions, ouvrez les propriétés du projet, puis sélectionnez l'onglet d' Application .

      Modifiez le nom de l'assembly à LoadToolboxMembersVB, et modifier l'espace de noms par défaut à Company.LoadToolboxMembersVB.

  2. pour Visual C#:

    1. Dans l'explorateur de solutions, ouvrez les propriétés du projet, puis sélectionnez l'onglet d' Application .

      Modifiez le nom de l'assembly à LoadToolboxMembersCS, et modifier l'espace de noms par défaut à Company.LoadToolboxMembersCS.

    2. ouvrez la classe de LoadToolboxMembersPackage dans l'éditeur de code.

      Pour utiliser les outils de refactorisation pour renommer l'espace de noms existant, cliquez avec le bouton droit sur le nom de l'espace de noms existant, LoadToolboxMembers, pointez sur Refactoriser, puis cliquez sur Renommer. Remplacez le nom à LoadToolboxMembersCS.

  3. Enregistrer toutes les modifications.

Pour ajouter la prise en charge des références

  1. dans le projet de LoadToolboxMembers, ajoutez une référence au composant.NET Framework d' System.Drawing.Design , comme suit.

    1. Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet de LoadToolboxMembers, puis cliquez sur Ajouter une référence.

    2. Sous l'onglet de .NET de la boîte de dialogue d' Ajouter des références , double-cliquez sur System.Drawing.Design.

  2. Pour Visual Basic, ajoutez les espaces de noms suivants aux espaces de noms importés jusque dans le projet :

    • Company.LoadToolboxMembersVB

    • Système

    • System.ComponentModel

    • System.Drawing

    • System.Windows.Forms

Pour tester le code généré

  1. compilez et commencez le VSPackage dans la ruche expérimentale de Visual Studio.

  2. Dans le menu d' Outils , cliquez sur initialisez LoadToolboxMembers VB ou initialisez le CS de LoadToolboxMembers.

    Cela ouvre une boîte de message contenant le texte qui indique que le gestionnaire de l'élément de menu du package a été appelé.

  3. fermez la version expérimentale de Visual Studio.

créer un contrôle de boîte à outils

Dans cette section, vous créez et enregistrez un contrôle utilisateur, Control1, qui déclare un élément par défaut associé de boîte à outils . Pour plus d'informations sur la création de contrôles Windows formes et la classe d' ToolboxItem , consultez Développement de contrôles Windows Forms au moment du design.

pour créer un contrôle de boîte à outils qui sera utilisé avec un ToolboxItem par défaut

  1. dans Explorateur de solutions, ajoutez un objet d' UserControl au projet de LoadToolboxMembers, comme suit :

    1. Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet de LoadToolboxMembers , pointez sur Ajouter, puis cliquez sur Contrôle utilisateur.

    2. Dans la boîte de dialogue d' Ajouter un nouvel élément , remplacez le nom à Control1.vb pour Visual Basic ou à Control1.cs pour Visual C#.

      Pour plus d'informations sur l'ajout de nouveaux éléments à un projet, consultez How to: Add New Project Items.

    Le nouveau contrôle s'ouvre en mode Design.

  2. De boîte à outils, faites glisser un contrôle de bouton (trouve dans la catégorie de Contrôles communs ) vers le concepteur.

  3. Double-cliquez sur le bouton que vous venez de créer. Cela génère un gestionnaire d'événements pour l'événement d' Click du bouton. Mettre à jour le gestionnaire d'événements à l'aide de le code suivant :

    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. Modifiez le constructeur du contrôle pour définir le texte du bouton après la méthode d' InitializeComponent soit appelée :

    Public Sub New()

    InitializeComponent()

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

    public Control1()
{
    InitializeComponent();

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

  5. Ajoutez des attributs au fichier pour activer le VSPackage pour interroger la classe fournie d' ToolboxItem :

    ' 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. Enregistrez le fichier.

dans la procédure suivante, vous créez et enregistrez un deuxième contrôle utilisateur, Control2, et un élément personnalisé associé de boîte à outils , Control2_ToolboxItem, qui est dérivé de la classe d' ToolboxItem .

Pour créer un contrôle de boîte à outils pour l'utilisation d'une classe ToolboxItem-dérivée personnalisée

  1. Créez Control2nommé le deuxième contrôle par utilisateur. Double-cliquez sur le formulaire pour afficher le fichier de code.

  2. Ajoutez System.Drawing.Design et System.Globalization aux espaces de noms utilisés dans la classe.

    Imports System.Drawing.Design
Imports System.Globalization

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

  3. Ajoutez un bouton et un gestionnaire d'événements button-click et mettez à jour le constructeur du contrôle comme vous l'avez mis à jour le premier contrôle.

  4. ajoutez DisplayNameAttribute, DescriptionAttribute, ToolboxItemAttribute, et les attributs d' ToolboxBitmapAttribute au fichier.

    Ces attributs permettent au VSPackage pour rechercher une classe d' ToolboxItem .

    Pour plus d'informations et d'exemples sur l'écriture d'objets personnalisés d' ToolboxItem , consultez la discussion dans la page de référence d' ToolboxItem .

    En combinaison avec les modifications précédentes, votre deuxième classe de contrôle doit ressembler au code suivant. Le symbole Control2_ToolboxMenu sera indéfini tant que l'étape suivante.

    ' 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. créez une classe nommée Control2_ToolboxItem. cet ToolboxItem est construit pour le deuxième contrôle et ajouté à boîte à outils. La classe doit avoir SerializableAttribute appliqué à celui-ci.

    <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. Enregistrez le fichier.

L'incorporation des icônes de bitmap

Les deux instances d' ToolboxBitmapAttribute les utilisaient indiquent antérieure au projet représente les deux contrôles à l'aide de les icônes suivantes :

  • Control1.bmp, trouve dans l'espace de noms qui contient le premier contrôle.

  • Control2.bmp, trouve dans l'espace de noms qui contient le deuxième contrôle.

Pour inclure des icônes de bitmap pour le ToolboxItem

  1. ajoutez deux nouvelles bitmap au projet, comme suit.

    1. Cliquez avec le bouton droit sur le projet de LoadToolboxMembers .

    2. Le point à Ajouter, puis cliquez sur Nouvel élément.

    3. Dans la boîte de dialogue d' Ajouter un nouvel élément , sélectionnez fichier bitmap, puis nommez le fichier Control1.bmp.

    4. répétez ces étapes pour la deuxième bitmap et nommez-les Control2.bmp.

      Cela ouvre chaque bitmap dans l'éditeur de bitmaps de Visual Studio .

  2. Définir la taille de chaque icône à 16 16 apparaîtra, comme suit.

    1. Pour chaque bitmap, cliquez sur Fenêtre Propriétés dans le menu d' Afficher .

    2. dans la fenêtre de Propriétés , définissez Height et Width à 16.

  3. Utilisez l'éditeur de bitmaps dans Visual Studio  pour créer une image pour chaque icône.

  4. Dans Explorateur de solutions, cliquez sur chaque fichier bitmap, puis, dans la fenêtre de Propriétés , définit la propriété d' Action de génération à Ressource incorporée.

  5. Enregistrez tous les fichiers ouverts.

Modifier l'implémentation d'un VSPackage

L'implémentation par défaut du VSPackage doit être modifiée pour effectuer des tâches :

  • Enregistrez la prise en charge d'être un fournisseur d'élément de boîte à outils .

  • obtenez une liste d'objets d' ToolboxItem que le VSPackage prend en charge.

  • Chargez l'objet d' ToolboxItem dans Visual Studio boîte à outils lorsque ToolboxInitialized les événements et d' ToolboxUpgraded sont gérés.

La procédure suivante indique comment modifier l'implémentation de package.

pour modifier l'implémentation de package pour être un fournisseur d'élément de boîte à outils pour le VSPackage

  1. ouvrez le fichier de LoadToolboxMembersPackage.cs ou de LoadToolboxMembersPackage.vb dans l'éditeur de code.

  2. modifiez la déclaration de la classe d' LoadToolboxMembersPackage , qui est l'implémentation de la classe d' Package dans la solution, comme suit.

    1. ajoutez les directives suivantes de l'espace de noms au fichier de classe d' LoadToolboxMembersPackage .

      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. enregistrez le VSPackage comme classe d' ToolboxItem en ajoutant une instance d' ProvideToolboxItemsAttribute.

      Notes

      L'argument unique d' ProvideToolboxItemsAttribute est la version d' ToolboxItem fournie par le VSPackage.Modifiant cette valeur force l'IDE pour charger le VSPackage même si elle a une version mise en cache précédemment de classe d' ToolboxItem .

    3. ajoutez les deux nouveaux champs suivants d' private à la classe d' LoadToolboxMembersPackage :

      Un membre d' ArrayList , ToolboxItemListnommé, pour stocker une liste des objets d' ToolboxItem que la classe d' LoadToolboxMembersPackage gère.

      String, CategoryTabnommé, qui contient la catégorie ou l'onglet de boîte à outils utilisés pour stocker des objets d' ToolboxItem qui sont gérés par la classe d' LoadToolboxMembersPackage .

    Le résultat de cette modification ressemble au code suivant :

    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. Développez la région de membres de package pour modifier la méthode d' Initialize d'effectuer les opérations suivantes :

    • Pour Visual C#, abonnez -vous aux événements d' ToolboxInitialized et d' ToolboxUpgraded .

    • Appelez la méthode d' CreateItemList pour remplir l'objet ToolboxItemListd' ArrayList . ToolboxItemList contiendra une liste de tous les éléments de boîte à outils qu' LoadToolboxMembersPackage gère.

    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. Ajoutez deux méthodes, CreateItemList et CreateToolboxItem, à l'élément, à l'aide de les métadonnées, les instances d'objets d' ToolboxItem qui sont disponibles dans l'assembly d' LoadToolboxMembers , comme suit :

    ' 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. Implémentez la méthode d' OnRefreshToolbox pour gérer les événements d' ToolboxInitialized et d' ToolboxUpgraded .

    La méthode d' OnRefreshToolbox utilise la liste d'objets d' ToolboxItem contenue dans le membre d' ToolboxItemList de la classe d' LoadToolboxMembersPackage . Il rend également les éléments suivants :

    • Supprime tous les objets d' ToolboxItem déjà présents dans la catégorie de boîte à outils définie par CategoryTabvariable.

    • Ajoute de nouvelles instances de tous les objets d' ToolboxItem répertoriés dans ToolboxItemList à l'onglet de catégorie du VSProject.

    • Définit l'onglet actif de boîte à outils à l'onglet de catégorie du VSProject.

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

    Notes

    En guise de exercice, il peut développer un mécanisme pour tester la version du VSPackage ou des éléments, et met à jour uniquement si la version du VSPackage a changé, ou si la version d' ToolboxItem a changé.

initialiser la boîte à outils

pour implémenter une commande d'initialiser la boîte à outils

  • modifiez la méthode de gestionnaire de commandes d'élément de menu, MenuItemCallBack, comme suit.

    1. Remplacez l'implémentation existante d' MenuItemCallBack par le code suivant :

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

Génération et exécution de la solution

Vous pouvez tester le produit de cette procédure pas - à - pas en utilisant une instance de Visual Studio qui s'exécute dans la ruche expérimentale.

Pour effectuer cette procédure pas - à - pas

  1. Dans Visual Studio, dans le menu de Générer , cliquez sur Régénérer la solution.

  2. Appuyez sur F5 pour démarrer une deuxième instance de  Visual Studiodans la ruche expérimentale de Registre.

    Pour plus d'informations sur l'utilisation de la ruche expérimentale, consultez l' instance expérimentale de Visual Studio.

  3. Cliquez sur le menu Outils.

    Une commande nommée initialisez LoadToolboxMembers VB ou initialisez le CS de LoadToolboxMembers doit s'afficher en haut du menu, avec une icône qui a la valeur 1. numérique.

  4. créez nouvel Visual C# ou application Windows Forms de Visual Basic .

    Un concepteur basé sur d' Formdoit apparaître.

  5. Faites glisser l'un ou les deux des nouveaux contrôles dans la catégorie de Procédure pas - à - pas VB de LoadToolboxMembers ou de CS de procédure pas - à - pas de LoadToolboxMembers de boîte à outils au formulaire dans le concepteur.

    Notes

    Si boîte à outils n'est pas affiché, cliquez sur boîte à outils dans le menu d' Afficher .Si l'onglet de catégorie pour le VSPackage n'apparaît pas dans boîte à outils, réinitialisez boîte à outils en cliquant sur initialisez LoadToolboxMembers VB ou initialisez le CS de LoadToolboxMembers dans le menu d' Outils .

  6. Générez l'application windows en cliquant sur Régénérer la solution dans le menu de Générer .

  7. Exécutez l'application en cliquant sur Démarrer ou Commencez par le débogage dans le menu de Débogage .

  8. Lorsque l'application s'exécute, cliquez sur l'un des contrôles que vous avez ajoutés à l'application.

    un message apparaît et affiche "Hello world from Company.LoadToolboxMembers.Control1" ou"Hello world from Company.LoadToolboxMembers.Control2".

analyse de l'implémentation

Créer les contrôles de boîte à outils

Les attributs assignés à Control1 et à Control2 sont utilisés par la méthode CreateItemList lorsqu'il interroge Assembly pour les contrôles disponibles de boîte à outils .

  • ToolboxItemAttribute exécute les deux fonctions suivantes :

    • L'assignation d' ToolboxItemAttribute à Control1 et à Control2, ce qui indique que chaque est un contrôle de boîte à outils.

    • L'argument au constructeur d' ToolboxItemAttribute , qui indique si ToolboxItem par défaut ou une classe personnalisée dérivée d' ToolboxItem est utilisé lorsque le contrôle est ajouté à boîte à outils.

      L'instance d' ToolboxItemAttribute assignée à Control1 est créé avec un argument d' true, qui indique qu'il utilise une classe par défaut d' ToolboxItem lorsqu'il est ajouté à boîte à outils.

      L'instance d' ToolboxItemAttribute assignée à Control2 est créé à l'aide de Type d'une classe dérivée d' ToolboxItem, Control2_ToolboxItem.

  • La classe d' ToolboxBitmapAttribute spécifie les bitmaps utilisées par l'environnement pour identifier les contrôles.

    incorporer une bitmap dans un assembly en définissant sa propriété d' Action de génération à Ressource incorporée met la bitmap dans l'espace de noms de l'assembly. Par conséquent, Control1.bmp peut être désigné sous le nom de Company.LoadToolboxMembers.Control1.bmp.

    ToolboxBitmapAttribute prend en charge un constructeur qui utilise ce chemin d'accès complet comme argument. Par exemple, une classe d' ToolboxBitmapAttribute peut être appliquée à Control1 à l'aide de [ToolboxBitmap("Company.LoadToolboxMembers.Control1.bmp")].

    Pour prendre en charge la souplesse, cette procédure pas - à - pas utilise un constructeur qui prend une classe d' Type comme premier argument au constructeur d' ToolboxBitmapAttribute . L'espace de noms qui est utilisé pour identifier le fichier bitmap est obtenu à partir de Type et inséré devant le nom de base de la bitmap.

    Étant donné que l'objet d' Type qui implémente Package, LoadToolboxMembers, se trouve dans l'espace de noms [ToolboxBitmap(typeof(Control1), "Control1.bmp")] d' Company.LoadToolboxMembers équivaut à [ToolboxBitmap("Company.LoadToolboxMembers.Control1.bmp")].

  • DisplayNameAttribute spécifie le nom du contrôle dans boîte à outils.

enregistrer un fournisseur de contrôle de boîte à outils

L'application de la classe d' ProvideToolboxItemsAttribute à la classe qui implémente affecte d' Package les paramètres du Registre du VSPackage résultant. Pour plus d'informations sur les paramètres du Registre pour un fournisseur d' ToolboxItem , consultez Stocker des fonctionnalités de prise en charge de la boîte à outils.

L'environnement de Visual Studio utilise l'argument de version au constructeur d' ProvideToolboxItemsAttribute pour gérer la mise en cache des VSPackages qui fournissent des éléments à boîte à outils. Une fois qu'un VSPackage chargé pour fournir des éléments de boîte à outils , une version mise en cache du VSPackage est utilisée jusqu'à ce que la version enregistrée du fournisseur change. Par conséquent, si vous souhaitez modifier le produit de cette procédure pas - à - pas après l'avoir générée, veillez à modifier l'argument de version du constructeur d' ProvideToolboxItemsAttribute qui est appliqué à AddToolboxItem. Par exemple, [ProvideToolboxItems(1)] doit être modifié en[ProvideToolboxItems(2)]. Si la version n'est pas modifiée, l'environnement de Visual Studio ne charge pas les modifications apportées.

Dans cette procédure pas - à - pas, le VSPackage est configuré pour fournir uniquement les contrôles de boîte à outils qui prennent en charge le format de presse-papiers par défaut. Pour obtenir une liste de formats de presse-papiers par défaut, consultez Boîte à outils (kit de développement Visual Studio SDK). Si vous souhaitez prendre en charge d'autres formats de presse-papiers, ou décidez de ne pas prendre en charge un format par défaut, appliquez l'attribut ProvideToolboxFormatAttribute à la classe d' LoadToolboxMembersPackage . Pour plus d'informations sur l'inscription un fournisseur de contrôle de boîte à outils , consultez Développement avancées de contrôle de la boîte à outils.

Ajouter des contrôles à la boîte à outils

la fonctionnalité dans CreateItemList émule ce qui est disponible dans System#Drawing#Design#IToolboxService#GetToolboxItems.

La méthode d' CreateItemList examine uniquement les objets non abstraits d' Type qui implémentent les interfaces d' IComponent .

Étapes suivantes

À l'aide de System#Drawing#Design#IToolboxService#GetToolboxItems plutôt qu' CreateItemList rendrait le produit de cette procédure pas - à - pas plus fiable.

Vous pouvez également modifier CreateItemList pour utiliser ParseToolboxResource aux contrôles de charge dans boîte à outils selon une liste de texte incorporé dans l'assembly d' LoadToolboxMembers .

Voir aussi

Tâches

Développement avancées de contrôle de la boîte à outils

Concepts

Stocker des fonctionnalités de prise en charge de la boîte à outils

Autres ressources

Boîte à outils (kit de développement Visual Studio SDK)

Procédures pas - à - pas de boîte à outils