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

Article
05/17/2015

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.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 contrôle de la 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.

Un VSPackage en fonction de managed package peut étendre les fonctionnalités de boîte à outils de Visual Studio en ajoutant des contrôles, des objets dérivés des objets d' ToolboxItem . chaque ToolboxItem est implémenté par un objet dérivé d' Component.

fournisseur VSPackage d'élément de boîte à outils

Un VSPackage en fonction de managed package doit stocker comme un fournisseur de contrôle de boîte à outils via des attributs de .NET Framework et des événements Boîte à outils-mis en relation par handle.

Pour configurer un VSPackage en tant que fournisseur d'élément de boîte à outils

créez une instance d' ProvideToolboxItemsAttribute appliqué à la classe implémentant Package. Par exemple :

Namespace Vsip.LoadToolboxMembers 
    <ProvideToolboxItems(14)> _ 
    <DefaultRegistryRoot("Software\Microsoft\VisualStudio\8.0")> _ 
    <InstalledProductRegistration(False, "#100", "#102", "1.0", IconResourceID := 400)> _ 
    <ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1)> _ 
    <ProvideMenuResource(1000, 1)> _ 
    <Guid("YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY")> _ 
    Public Class LoadToolboxMembers 
        Inherits Package 
    End Class 
End Namespace

namespace Vsip.LoadToolboxMembers {
    [ProvideToolboxItems(14)]
    [DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\8.0")]
    [InstalledProductRegistration(false, "#100", "#102", "1.0", IconResourceID = 400)]
    [ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1)]
    [ProvideMenuResource(1000, 1)]
    [Guid("YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY")]
    public class LoadToolboxMembers : Package {

Notes

le constructeur pour ProvideToolboxItemsAttribute prend un numéro de version entier comme argument.l'environnement de Visual Studio utilise ce numéro de version pour déterminer si un VSPackage fournissant des objets d' ToolboxItem doit être rechargé ou si les informations mises en cache peuvent être utilisées par la boîte à outils.Pour garantir recharger d'un VSPackage en fournissant ToolboxItem qui est en cours de développement, incrémentez toujours ce numéro de version après toute modification.

Si les objets d' ToolboxItem fournissent des formats de presse-papiers non de boîte à outils standard, une instance d' ProvideToolboxFormatAttribute doit être appliquée à la classe implémentant l'objet d' Package pour chaque format de presse-papiers pris en charge par les objets d' ToolboxItem que le VSPackage fournit.

Pour plus d'informations sur les formats de presse-papiers pris en charge par la boîte à outils, consultez Boîte à outils (kit de développement Visual Studio SDK).

Notes

Si un VSPackage indique qu'il fournit à tous les objets d' ToolboxItem les formats de presse-papiers non standard, l'environnement de Visual Studio suppose que seules ces formats indiqués par les instances d' ProvideToolboxFormatAttribute appliquées à l'implémentation de classe d'Package d'un VSPackage sont pris en charge par le VSPackage.Si un VSPackage doit prendre en charge les formats de presse-papiers par défaut ainsi qu'un format non standard, il doit implémenter une instance d' ProvideToolboxFormatAttribute pour chaque format par défaut ainsi que le format non standard.
Si le VSPackage fournit la possibilité de configuration dynamique d' ToolboxItem, il doit :
1. Appliquez une instance d' ProvideToolboxItemConfigurationAttribute a généré en utilisant Type que le package utilise pour implémenter l'interface de IConfigureToolboxItem .
2. Sur une indépendante de classe d' public d' Packagedu VSPackage, le VSPackage doit implémenter l'interface d' IConfigureToolboxItem .
  
  Une instance d' ProvideAssemblyFilterAttribute doit être appliquée à la classe implémentant IConfigureToolboxItem, à l'aide d'une chaîne contenant les critères d'une sélection (filtre) en tant qu'argument au constructeur de l'instance d' ProvideToolboxItemConfigurationAttribute .

Pour plus d'informations sur la façon de signaler à l'environnement de Visual Studio qu'un VSPackage fournit les contrôles de boîte à outils, consultez Stocker des fonctionnalités de prise en charge de la boîte à outils.

Pour obtenir un exemple illustrant comment il peut implémenter la prise en charge d' IConfigureToolboxItem , consultez Procédure pas - à - pas : Personnalisation de la configuration de ToolboxItem dynamiquement.

VSPackages fournissant ToolboxItem doit gérer ToolboxInitialized les événements et d' ToolboxUpgraded .

implémentez les gestionnaires pour les événements d' ToolboxInitialized et d' ToolboxUpgraded :

Private Sub OnToolboxUpgraded(ByVal sender As Object, ByVal e As EventArgs) 
    OnToolboxInitialized(send, e) 
End Sub 
Private Sub OnToolboxInitialized(ByVal sender As Object, ByVal e As EventArgs) 
    'Make sure all toolbox items are added. 
End Sub

private void OnToolboxUpgraded(object sender, EventArgs e) {
    OnToolboxInitialized(send,e);
}
private void OnToolboxInitialized(object sender, EventArgs e) {
    //Make sure all toolbox items are added.
}

Abonnez -vous aux événements d' ToolboxInitialized et d' ToolboxUpgraded .

Cela est généralement fait dans la méthode d' Initialize de l'implémentation d' Package :

Protected Overloads Overrides Sub Initialize() 
    AddHandler ToolboxInitialized, AddressOf OnToolboxInitialized 
    AddHandler ToolboxUpgraded, AddressOf OnToolboxUpgraded 
End Sub

protected override void Initialize() {
    ToolboxInitialized += new EventHandler(OnToolboxInitialized);
    ToolboxUpgraded += new EventHandler(OnToolboxUpgraded);
}

Pour obtenir un exemple d'implémentation des gestionnaires pour ToolboxInitialized les événements et d' ToolboxUpgraded , consultez Procédure pas - à - pas : charger automatiquement des éléments de boîte à outils.

Conception du contrôle de boîte à outils

L'implémentation sous-jacente d'un contrôle de boîte à outils doit être dérivée d' Component et être encapsulé dans la valeur par défaut ou une implémentation de l'objet dérivé d' ToolboxItem .

La façon la plus facile de fournir Component- l'implémentation dérivée les contrôles de boîte à outils est en étendant un objet dérivé d' Control, en particulier, la classe d' UserControl .

Pour créer les contrôles de boîte à outils

Utilisez la commande pour Ajouter un nouvel élément De l'Explorateur de Solutions de créer un objet de boîte à outils qui implémente UserControl.

Public Partial Class ToolboxControl1 
    Inherits UserControl 
    Public Sub New() 
        InitializeComponent() 
    End Sub 
    Private Sub button1_Click(ByVal sender As Object, ByVal e As EventArgs) 
        MsgBox("Hello world from" & Me.ToString()) 
    End Sub 

    Private Sub ToolboxItem1_Load(ByVal sender As Object, ByVal e As EventArgs) 

    End Sub 
End Class

public partial class ToolboxControl1 : UserControl {
        public ToolboxControl1() {
            InitializeComponent();
        }

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

        private void ToolboxItem1_Load(object sender, EventArgs e) {

        }
    }

Pour plus d'informations sur la création de contrôles Windows Forms et les contrôles de boîte à outils, consultez Développement de contrôles Windows Forms personnalisés avec le .NET Framework ou le Procédure pas - à - pas : charger automatiquement des éléments de boîte à outils.

(Facultatif) une application peut choisir d'utiliser un objet personnalisé dérivé de l'objet d' ToolboxItem fournisse son contrôle de boîte à outils à boîte à outils.

Notes

Toute classe dérivée de l'objet d' ToolboxItem doit avoir une instance d' SerializableAttribute appliqué à celui-ci.

Une implémentation personnalisée dérivée d' ToolboxItem peut étendre une application en fournissant un meilleur contrôle de la façon dont les données d' ToolboxItem est sérialisée, une gestion comprendre les métadonnées de concepteur, une prise en charge pour les formats de presse-papiers non standard, et une fonctionnalité qui permet l'interaction utilisateur.

Dans l'exemple, les utilisateurs sont appelés par une boîte de dialogue à sélectionner les fonctions :

<ToolboxItemAttribute(GetType(CustomControl))> _ 
<Serializable()> _ 
Class CustomControl 
    Inherits ToolboxItem 

    Public Sub New(ByVal type As Type) 
        MyBase.New(GetType(CustomControl)) 
    End Sub 
    Public Sub New(ByVal type As Type, ByVal icon As Bitmap) 
        MyBase.New(GetType(SCustomControl)) 
        Me.DisplayName = "CustomContorl" 
        Me.Bitmap = icon 
    End Sub 

    Private Sub New(ByVal info As SerializationInfo, ByVal context As StreamingContext) 
        Deserialize(info, context) 
    End Sub 
    Protected Overloads Overrides Function CreateComponentsCore(ByVal host As IDesignerHost) As IComponent() 
        Dim dialog As New CustomControlDialog(host) 
        Dim dialogResult__1 As DialogResult = dialog.ShowDialog() 
        If dialogResult__1 = DialogResult.OK Then 
            Dim component As IComponent = DirectCast(dialog.CustomInstance, IComponent) 
            Dim container As IContainer = host.Container 
            container.Add(component) 
            Return New IComponent() {component} 
        Else 
            Return New IComponent() {} 
        End If 
    End Function 
End Class

[ToolboxItemAttribute(typeof(CustomControl))]
[Serializable]
class CustomControl : ToolboxItem {

    public CustomControl(Type type) : base(typeof(CustomControl)) {}
        public CustomControl(Type type, Bitmap icon) : base(typeof(SCustomControl)) {
        this.DisplayName = "CustomContorl";
        this.Bitmap = icon;
    }

    private CustomControl(SerializationInfo info, StreamingContext context) {
        Deserialize(info, context);
    }
    protected override IComponent[] CreateComponentsCore(IDesignerHost host) {
        CustomControlDialog dialog = new CustomControlDialog(host);
        DialogResult dialogResult = dialog.ShowDialog();
        if (dialogResult == DialogResult.OK) {
            IComponent component = (IComponent)dialog.CustomInstance;
            IContainer container = host.Container;
            container.Add(component);
            return new IComponent[] { component };
        }
        else {
            return new IComponent[] {};
        }
    }
}

Notes

il est également possible pour une classe dérivée de l'objet d' ToolboxItem pour fournir sa propre implémentation autonome du contrôle sous-jacent.Cette classe est ensuite chargé de créer et de fournir tous les composants sous-jacents.

ajout explicite des éléments de boîte à outils

Pour être ajouté à la boîte à outils, un contrôle doit être inclus dans une instance d' ToolboxItem ou d'un objet dérivé d' ToolboxItem puis être ajouté à boîte à outils à l'aide de l'interface d' IToolboxService .

pour encapsuler et ajouter des contrôles de boîte à outils

Incluez l'implémentation d' Component dans une instance d'un objet d' ToolboxItem ou ToolboxItemobjet dérivé en appelant la méthode d' Initialize de cet objet avec Typedu composant implémentant :
```
Dim customItem As New ToolboxItem() 
If customItem IsNot Nothing Then 
    customItem.Initialize(userControl) 
End If
```
```
ToolboxItem customItem = new ToolboxItem() ;
if (customItem != null) {
    customItem.Initialize(userControl);
}
```
Est supérieure un exemple d'objet userControl dérivé d' UserControl (une instance de l'objet d' ToolboxControl1 montré ci-dessus) utilisé pour construire nouvel ToolboxItem.

Notes

L'implémentation par défaut du constructeur d' ToolboxItem prend un argument d' Type (le constructeur d'#ctor(Type) appelle la méthode d' Initialize de l'objet d' ToolboxItem .

Utilisez le service de boîte à outils (IToolboxService) pour ajouter l'objet d' ToolboxItem construit de l'implémentation du contrôle sous-jacente.

Dans l'exemple ci-dessous, l'accès au service de boîte à outils est obtenu, certaines des propriétés de l'instance customItem d' ToolboxItem sont définies, puis customItem est ajouté à boîte à outils:

Dim toolboxService As IToolboxService = TryCast(GetService(GetType(IToolboxService)), IToolboxService)
customItem.Bitmap = New System.Drawing.Bitmap(ToolBoxControl1, "Control1.bmp")
customItem.DisplayName = "Custom Item" 
toolboxService.AddToolboxItem(item, "Custom Tab")

IToolboxService toolboxService = GetService(typeof(IToolboxService)) as IToolboxService;
customItem.Bitmap = new System.Drawing.Bitmap(ToolboxControl1,"Control1.bmp");
customItem.DisplayName= "Custom Item";
toolboxService.AddToolboxItem(item, "Custom Tab");

À l'aide de la réflexion pour ajouter des contrôles de boîte à outils

Appliquer des attributs à la classe implémentant un contrôle de boîte à outils permet l'environnement de Visual Studio ou une application basée sur une Kit de développement logiciel Visual Studio d'utiliser la réflexion pour détecter automatiquement et ajouter correctement des contrôles à boîte à outils.

pour appliquer la réflexion et les attributs aux contrôles de boîte à outils

Identifiez tous les objets utilisés pour implémenter les contrôles de boîte à outils à des instances d' ToolboxItemAttribute.

Le type d'instance d' ToolboxItemAttribute à une valeur d'objet détermine si et comment ToolboxItem est construit à partir de celui-ci.
1. Appliquant une instance d' ToolboxItemAttribute est construit avec une valeur d' BOOLEAN d' false à un objet rend cet objet non disponible à la boîte à outils par réflexion.
  
  Cela peut être utile pour isoler un objet, tel qu' UserControl de boîte à outils pendant le développement.
2. Appliquant une instance d' ToolboxItemAttribute est construit avec une valeur d' BOOLEAN d' true à un objet fait qu'objet disponible à la boîte à outils par réflexion et requiert que l'objet soit ajouté à la boîte à outils à l'aide d'un objet par défaut d' ToolboxItem .
3. Appliquant une instance d' ToolboxItemAttribute est construit avec Type d'un objet personnalisé dérivé d' ToolboxItem rend l'objet disponible à boîte à outils par réflexion et le requiert que l'objet soit ajouté à la boîte à outils en utilisant cet objet personnalisé dérivé d' ToolboxItem.
Spécifiez (au mécanisme de la réflexion de l'environnement de Visual Studio ) la bitmap à utiliser pour afficher le contrôle de boîte à outils dans boîte à outils en ajoutant une instance d' ToolboxBitmapAttribute à l'implémentation du contrôle de boîte à outils.

Si nécessaire, appliquez les instances d' ToolboxItemFilterAttribute aux objets d' ToolboxItem à utilisent la réflexion pour les marquer statiquement à utiliser avec les objets qui ont un attribut correspondant.

Dans l'exemple ci-dessous, l'implémentation d'un contrôle de boîte à outils contient une instance d' ProvideAssemblyFilterAttribute appliquée à lui, ce qui rend ce contrôle disponible dans boîte à outils uniquement lorsque le document de travail actuel est de générateurs d' UserControl

<ToolboxItemFilter(System.Windows.Forms.UserControl, ToolboxItemFilterType.Require)> _ 
<SerializableAttribute()> _ 
<GuidAttribute("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")> _ 
Friend Class CustomToolboxItem 
    Inherits ToolboxItem 
End Class

[ToolboxItemFilter(System.Windows.Forms.UserControl,ToolboxItemFilterType.Require)]
[SerializableAttribute()]  //ToolboxItem implementations much has this attribute.
[GuidAttribute("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")]
internal class CustomToolboxItem : ToolboxItem

Il existe trois techniques de base pour l'utilisation de la réflexion à charger automatiquement ToolboxItem.

Utilisation des fonctionnalités de ToolService pour récupérer les contrôles de boîte à outils

ToolboxService fournit à des VSPackages les méthodes statiques d' GetToolboxItems qui utilisent la réflexion pour analyser des assemblys pour tous les types qui prennent en charge des éléments de boîte à outils, et retournent des éléments de ces types. pour être retourné, un élément de boîte à outils doit :

Être public.
implémentez la classe d' IComponent .
Ne pas être abstrait.
Avez ToolboxItemAttribute sur son type.
ne pas avoir ToolboxItemAttribute défini à false sur son type
Ne pas contenir de paramètres génériques.

pour obtenir cette liste

Créez une instance d' Assembly faisant référence à l'assembly qui doit être analysé pour les objets d' ToolboxItem .

Notes

Pour obtenir une instance d' Assembly pour l'assembly actuel, utilisez la méthode statique GetExecutingAssembly.
Appelez GetToolboxItems, en retournant un objet d' ICollection contenant une liste des objets appropriés.

Notes

Si un objet de ICollection retourné a une instance valide d' ToolboxBitmapAttribute avez assigné à son implémentation, la méthode d' GetToolboxItems définira la propriété d' Bitmap de l'objet d' ToolboxItem .

Utilisez GetService pour obtenir l'accès à IToolboxService, et utilisez sa méthode d' AddToolboxItem pour ajouter des éléments de l'objet retourné d' ICollection à la boîte à outils.

Le code suivant interroge l'application active et obtient une liste de tous ses objets d' ToolboxItem et les charge. Pour obtenir un exemple en illustrant cela en exécution du code, consultez la méthode d' Initialization dans Procédure pas - à - pas : Personnalisation de la configuration de ToolboxItem dynamiquement.

Protected ToolboxItemList As ICollection = Nothing
ToolboxItemList = ToolboxService.GetToolboxItems(Assembly.GetExecutingAssembly(), "")
If ToolboxItemList Is Nothing Then 
    Throw New ApplicationException("Unable to generate a toolbox Items listing for " & [GetType]().FullName) 
End If 
Dim toolboxService As IToolboxService = TryCast(GetService(GetType(IToolboxService)), IToolboxService) 
For Each itemFromList As ToolboxItem In ToolboxItemList 
    toolboxService.AddToolboxItem(itemFromList, CategoryTab) 
Next

protected ICollection ToolboxItemList = null;
ToolboxItemList = ToolboxService.GetToolboxItems(Assembly.GetExecutingAssembly(), "");
if (ToolboxItemList == null){
    throw new ApplicationException("Unable to generate a toolbox Items listing for "
+ GetType().FullName);
}
IToolboxService toolboxService = GetService(typeof(IToolboxService)) as IToolboxService;
foreach (ToolboxItem itemFromList in ToolboxItemList){
    toolboxService.AddToolboxItem(itemFromList, CategoryTab);
}

Utiliser les ressources incorporées de texte pour charger automatiquement les contrôles de boîte à outils

Une ressource de texte dans un assembly contenant une liste correctement mise en forme de contrôles de boîte à outils peut être utilisée par ParseToolboxResource pour charger automatiquement un contrôle de boîte à outils si correctement mise en forme.

Une ressource de texte contenant une liste d'objets au chargement doit être disponible dans un assembly accessible au VSPackage.

Pour ajouter et rendre disponible une ressource de texte à l'assembly

Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet.
Le point à Ajouter, cliquez sur Nouvel élément.
dans la boîte de dialogue d' Ajouter un nouvel élément , sélectionnez Fichier texte et fournissez un nom.
Dans Explorateur de solutions, cliquez avec le bouton droit sur le fichier texte venant d'être créé et définissez la propriété d' Action de génération à la ressource incorporée.

Les entrées pour que le contrôle de boîte à outils soit chargé doivent contenir le nom de la classe d'implémentation, le nom de l'assembly contenant la.

Pour plus d'informations sur le format des entrées de contrôles de boîte à outils à la ressource incorporée en texte, consultez la page de référence d' ParseToolboxResource .
Installez un chemin de recherche des fichiers contenant les assemblys qui héberge les objets de contrôle de boîte à outils.

ParseToolboxResource, dossiers de recherche uniquement spécifiés dans l'entrée du Registre HKEY_CURRENT_USER \Software\Microsoft\VisualStudio \ <version> \AssemblyFolders, où <version> est le numéro de version de la version Visual Studio (par exemple, 8,0).

Notes

Le chemin d'accès racine HKEY_LOCAL_MACHINE \SOFTWARE\Microsoft\VisualStudio \ <Version> peut être substitué par une autre racine lorsque le shell Visual Studio est initialisé, ou l'utilisation d' DefaultRegistryRootAttribute.Pour plus d'informations, consultez Commutateurs de la ligne de commande (Kit de développement logiciel Visual Studio).

Pour plus d'informations sur le format correct des entrées du Registre d'AssemblyFolder, consultez la page de référence d' ParseToolboxResource .
Obtenez une instance d' Synchronized accès à la ressource incorporée de texte, et, si la prise en charge de la localisation est nécessaire pour les noms de catégories, une instance d' ResourceManager, puis utilise ces derniers pour appeler la méthode d' ParseToolboxResource .
```
Dim rm As New ResourceManager("TbxCategories", Assembly.GetExecutingAssembly())
Dim toolboxStream As Stream = TbxItemProvider.[GetType]().Assembly.GetManifestResourceStream("ToolboxItems.txt")
If toolboxStream IsNot Nothing Then 
    Using reader As TextReader = New StreamReader(toolboxStream) 
        ParseToolboxResource(reader, rm) 
    End Using 
End If
```
```
ResourceManager rm = new ResourceManager("TbxCategories", Assembly.GetExecutingAssembly());
Stream toolboxStream = TbxItemProvider.GetType().Assembly.GetManifestResourceStream("ToolboxItems.txt");
if (toolboxStream != null) {
    using (TextReader reader = new StreamReader(toolboxStream)) {
    ParseToolboxResource(reader, rm);
}
}
```
Dans l'exemple ci-dessus, une liste contenue dans une ressource incorporée en texte dans l'assembly contenant la classe TbxItemProvider est passée à ParseToolboxResource avec les ressources de type chaîne en TbxCategories .

La méthode recherche tous les fichiers qui contiennent les assemblys dans les répertoires spécifiés sous l'entrée du Registre d'AssemblyFolders pour les contrôles de boîte à outils répertoriés dans la ressource et les chargera.

Notes

Si un contrôle de boîte à outils trouvé par ParseToolboxResource a une instance valide d' ToolboxBitmapAttribute avez assigné à son implémentation, ParseToolboxResource définira la bitmap utilisée pour afficher le contrôle de boîte à outils.

Explicitement à l'aide de la réflexion pour charger automatiquement les contrôles de boîte à outils

S'il est nécessaire d'interroger explicitement des assemblys pour plus d'informations sur les contrôles de boîte à outils qu'ils contiennent, plutôt que déléguant la tâche à GetToolboxItems, vous pouvez le faire.

Pour utiliser explicitement la réflexion pour charger automatiquement les contrôles de boîte à outils

Créez une instance d' Assembly, en faisant référence à chaque assembly qui doit être analysé pour les objets d' ToolboxItem .

Notes

Pour obtenir une instance d' Assembly pour l'assembly actuel, utilisez la méthode statique GetExecutingAssembly.
Pour chaque assembly soit analysé, utilisez la méthode d' GetTypes de l'objet d' Assembly pour obtenir une liste de chaque Type dans l'assembly.
Vérifiez que le type n'est pas abstraite et ne prend pas en charge l'interface d' IComponent (toutes les implémentations des contrôles de boîte à outils utilisés pour instancier un objet d' ToolboxItem doivent implémenter cette interface).
Obtenir les attributs d' Type et utilisez ces informations pour déterminer si le VSPackage souhaite charger l'objet.

Notes

Bien que dans l'entité de sécurité qu'il est possible de créer un objet d' ToolboxItem d'une implémentation d'interface d' IComponent sans instance d' ToolboxItemAttribute non définie à false est appliqué à lui, nous déconseillons de le faire.
Utilisez GetConstructor pour obtenir des constructeurs pour les objets d' ToolboxItem que les contrôles de boîte à outils requièrent.
Construisez des objets d' ToolboxItem et ajoutez -les à boîte à outils.

Pour voir un exemple illustrer l'utilisation explicite de la réflexion pour obtenir et charger automatiquement les contrôles de boîte à outils, consultez CreateItemList décrit dans Procédure pas - à - pas : charger automatiquement des éléments de boîte à outils.

Configuration du contrôle de boîte à outils supplémentaires

Un VSPackage peut avoir de mieux contrôler le moment où et comment un contrôle de boîte à outils est affiché par boîte à outils, via l'implémentation d' IConfigureToolboxItem, et l'utilisation d' ProvideAssemblyFilterAttribute, et l' ProvideToolboxItemConfigurationAttribute.

Appliquer des instances d' ToolboxItemFilterAttribute à une classe fournit uniquement le contrôle statique moment où et comment un contrôle de boîte à outils est disponible.

Pour créer la prise en charge dynamique de configuration des contrôles de boîte à outils

Créez une classe qui implémente l'interface d' IConfigureToolboxItem dans le cadre d'un VSPackage.

Notes

l'interface d' IConfigureToolboxItem ne doit pas être implémentée sur la même classe qui fournit l'implémentation d'un VSPackage d' Package.

Associez l'implémentation d' IConfigureToolboxItem avec les objets des assemblys spécifiques en appliquant une instance d' ProvideAssemblyFilterAttribute lui.

L'exemple suivant fournit la possibilité de configuration dynamique pour les assemblys d'objet contrôle de boîte à outils dans l'espace de noms et requièrent d' Vsip.* que certains objets d' ToolboxItem soient visibles uniquement avec les concepteurs basés sur d' UserControlet autre jamais visible avec les concepteurs basés sur d' UserControl.

<ProvideAssemblyFilterAttribute("Vsip.*, Version=*, Culture=*, PublicKeyToken=*")> _ 
<GuidAttribute("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")> _ 
Public NotInheritable Class ToolboxConfig 
    Implements IConfigureToolboxItem 
    Public Sub New() 
    End Sub 


    ''' <summary> 
    ''' Adds extra configuration information to this toolbox item. 
    ''' </summary> 
    Public Sub ConfigureToolboxItem(ByVal item As ToolboxItem) 
        If item Is Nothing Then 
            Exit Sub 
        End If 

        'hide from .NET Compact Framework on the device designer. 
        Dim newFilter As ToolboxItemFilterAttribute = Nothing 
        If item.TypeName = GetType(ToolboxControl1).ToString() Then 
            newFilter = New ToolboxItemFilterAttribute("System.Windows.Forms.UserControl", ToolboxItemFilterType.Require) 
        ElseIf item.TypeName = GetType(ToolboxControl2).ToString() Then 

            newFilter = New ToolboxItemFilterAttribute("System.Windows.Forms.UserControl", ToolboxItemFilterType.Prevent) 
        End If 
        If newFilter IsNot Nothing Then 
            Dim array As New ArrayList() 
            array.Add(newFilter) 
            item.Filter = DirectCast(array.ToArray(GetType(ToolboxItemFilterAttribute)), ToolboxItemFilterAttribute()) 
        End If 
    End Sub 
End Class

[ProvideAssemblyFilterAttribute("Vsip.*, Version=*, Culture=*, PublicKeyToken=*")]
    [GuidAttribute("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")]
    public sealed class ToolboxConfig : IConfigureToolboxItem {
        public ToolboxConfig() {
        }


        /// <summary>
        ///     Adds extra configuration information to this toolbox item.
        /// </summary>
        public void ConfigureToolboxItem(ToolboxItem item) {
            if (item == null)
                return;

            //hide from .NET Compact Framework  on the device designer.
            ToolboxItemFilterAttribute newFilter = null;
            if (item.TypeName == typeof(ToolboxControl1).ToString()) {
                newFilter = new ToolboxItemFilterAttribute("System.Windows.Forms.UserControl",
                                                      ToolboxItemFilterType.Require);
            } 
            else if (item.TypeName == typeof(ToolboxControl2).ToString()) {

                newFilter = new ToolboxItemFilterAttribute("System.Windows.Forms.UserControl",
                                                      ToolboxItemFilterType.Prevent);
            }
            if (newFilter != null) {
                ArrayList array = new ArrayList();
                array.Add(newFilter);
                item.Filter = (ToolboxItemFilterAttribute[])
                        array.ToArray(typeof(ToolboxItemFilterAttribute));
            }
        }
    }
}

Enregistrez un VSPackage comme fourniture d'une implémentation spécifique d' IConfigureToolboxItem en appliquant une instance d' ProvideToolboxItemConfigurationAttribute à l'implémentation du VSPackage d' Package.

L'exemple ci-dessous informerait à l'environnement de Visual Studio que le package implémenté par Vsip.ItemConfiguration.ItemConfiguration fournit la classe Vsip.ItemConfiguration.ToolboxConfiguration à la dynamique ToolboxItemde stockage.

<ProvideToolboxItemsAttribute(3)> _ 
<DefaultRegistryRoot("Software\Microsoft\VisualStudio\8.0")> _ 
<InstalledProductRegistration(False, "#100", "#102", "1.0", IconResourceID := 400)> _ 
<ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1)> _ 
<ProvideMenuResource(1000, 1)> _ 
<ProvideToolboxItemConfigurationAttribute(GetType(ToolboxConfig))> _ 
<GuidAttribute("YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY")> _ 
Public Class ItemConfiguration 
    Inherits Package 
End Class

[ProvideToolboxItemsAttribute(3)]
[DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\8.0")]
[InstalledProductRegistration(false, "#100", "#102", "1.0", IconResourceID = 400)]
[ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1)]
[ProvideMenuResource(1000, 1)]
[ProvideToolboxItemConfigurationAttribute(typeof(ToolboxConfig))]

[GuidAttribute("YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY")]
public class ItemConfiguration : Package

Prise en charge du glisser-déplacer personnalisée

En plus de être ajouté à boîte à outils lui-même, des objets d' ToolboxItem et leurs implémentations peuvent être utilisés pour étendre la prise en charge du glisser-déplacer dans Visual Studio l'IDE. Cela peut permettre les formats de presse-papiers arbitraires à exposer à boîte à outils et dans les éditeurs.

VSPackages en fonction de managed package doit stocker en tant que spécification des formats de presse-papiers personnalisés d'élément de boîte à outils , en appliquant une instance d' ProvideToolboxFormatAttribute à la classe implémentant Package.

Pour plus d'informations sur l'enregistrement comme fournisseur de boîte à outils , consultez Stocker des fonctionnalités de prise en charge de la boîte à outils.

Pour fournir aux formats de presse-papiers personnalisés et à la prise en charge du glisser-déplacer les contrôles de boîte à outils

créez une implémentation du délégué d' ToolboxItemCreatorCallback .

Cette implémentation doit retourner un objet d' ToolboxItem qui prend en charge le format de presse-papiers non standard.

Pour obtenir un exemple d'implémentation d'un délégué d' ToolboxItemCreatorCallback , consultez les pages de référence de ToolboxItem et d' ToolboxItemCreatorCallback .

Faites cette implémentation du délégué d' ToolboxItemCreatorCallback disponible à Visual Studio boîte à outils pour une boîte à outils non standard en appelant AddCreator.

<GuidAttribute("7D91995B-A799-485e-BFC7-C52545DFB5DD")> _ 
<ProvideToolboxFormatAttribute("MyFormat")> _ 
Public Class ItemConfiguration 
    Inherits MSVSIP.Package 
    Public Overloads Overrides Sub Initialize() 
        '"Adding this class as a ToolboxItemCreator"); 
        Dim toolbox As IToolboxService = DirectCast(host.GetService(GetType(IToolboxService)), IToolboxService) 
        If toolbox IsNot Nothing Then 
            toolboxCreator = New ToolboxItemCreatorCallback(Me.OnCreateToolboxItem) 
            toolbox.AddCreator(toolboxCreator, "MyFormat", host) 
        End If 
    End Sub 
End Class

[GuidAttribute("7D91995B-A799-485e-BFC7-C52545DFB5DD")]
[ProvideToolboxFormatAttribute("MyFormat")]
public class ItemConfiguration : MSVSIP.Package
{
    public override void Initialize() { 
        /*
        */
        //"Adding this class as a ToolboxItemCreator");
        IToolboxService toolbox = (IToolboxService)host.GetService(typeof(IToolboxService));
        if (toolbox != null) {
            toolboxCreator = new ToolboxItemCreatorCallback(this.OnCreateToolboxItem);
            toolbox.AddCreator(toolboxCreator, "MyFormat", host);
        }
        private ToolboxItem OnCreateToolboxItem(object serializedData, string format) {
           /*
            */
        }
    }
}

Dans cette section

Comment : fonctionnalité de glisser-déplacer de boîte à outils de support
Décrit comment implémenter la prise en charge du glisser-déplacer dans une vue du document.
Comment : Fournissez des éléments de boîte à outils personnalisés à l'aide de les assemblys d'interopérabilité
Décrit l'ajout de nouveaux contrôles ActiveX et nouveaux éléments à Visual Studio boîte à outils. ces nouveaux éléments peuvent avoir un format de presse-papiers standard ou un format personnalisé pris en charge par le VSPackage.
Stocker des fonctionnalités de prise en charge de la boîte à outils
Décrit comment inscrire un VSPackage comme fournisseur de boîte à outils. parle également de prendre en charge ou d'utiliser d'autres fonctionnalités de boîte à outils.

Voir aussi

Partager via

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

fournisseur VSPackage d'élément de boîte à outils

Pour configurer un VSPackage en tant que fournisseur d'élément de boîte à outils

Conception du contrôle de boîte à outils

Pour créer les contrôles de boîte à outils

ajout explicite des éléments de boîte à outils

pour encapsuler et ajouter des contrôles de boîte à outils

À l'aide de la réflexion pour ajouter des contrôles de boîte à outils

pour appliquer la réflexion et les attributs aux contrôles de boîte à outils

Utilisation des fonctionnalités de ToolService pour récupérer les contrôles de boîte à outils

pour obtenir cette liste

Utiliser les ressources incorporées de texte pour charger automatiquement les contrôles de boîte à outils

Pour ajouter et rendre disponible une ressource de texte à l'assembly

Explicitement à l'aide de la réflexion pour charger automatiquement les contrôles de boîte à outils

Pour utiliser explicitement la réflexion pour charger automatiquement les contrôles de boîte à outils

Configuration du contrôle de boîte à outils supplémentaires

Pour créer la prise en charge dynamique de configuration des contrôles de boîte à outils

Prise en charge du glisser-déplacer personnalisée

Pour fournir aux formats de presse-papiers personnalisés et à la prise en charge du glisser-déplacer les contrôles de boîte à outils

Dans cette section

Voir aussi

Tâches

Concepts

Autres ressources

Ressources supplémentaires