Erweiterte Toolbox-Steuerentwicklung

Artikel
05/16/2015

Hinweis

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

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

VSPackage auf das verwaltete Paketframework kann Visual Studio-Funktionen erweitern, indem Sie der Toolbox Steuerelemente, die auf Objekte hinzufügen, die von ToolboxItem-Objekten abgeleitet sind. Jedes ToolboxItem wird von einem Objekt implementiert, das von Componentabgeleitet ist.

Toolboxelement-Anbieter VSPackage

VSPackage auf das verwaltete Paketframework muss als Anbieter steuer Toolbox von .NET Framework-Attribute und Handle Toolbox-verknüpfte Ereignisse registrieren.

So konfigurieren Toolboxelement-Anbieter als VSPackage

Erstellen Sie eine Instanz ProvideToolboxItemsAttribute , das auf die Klasse angewendet wird, die Packageimplementiert. Beispiele:

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 {

Hinweis

Der Konstruktor für ProvideToolboxItemsAttribute nimmt eine ganzzahlige Versionsnummer als Argument.Die Visual Studio-Versionsnummer dieser Umgebung verwendet, um zu bestimmen, ob ein VSPackage, das ToolboxItem-Objekte bereitstellt, neu geladen werden muss oder wenn zwischengespeicherte Informationen über die Toolbox verwendet werden können.Um das Laden von VSPackages zu gewährleisten, wenn Sie ToolboxItem bereitstellen das in der Entwicklungsphase befindet, inkrementieren Sie immer diese Version nach einer beliebigen Änderung.

Wenn die ToolboxItem-Objekte nichtstandardisierte Toolbox-Zwischenablageformate angeben, muss eine Instanz von ProvideToolboxFormatAttribute auf die Klasse angewendet werden, die das Package-Objekt für jedes Zwischenablageformat implementiert, das von der ToolboxItem-Objekten unterstützt wird, die einem VSPackage bereitstellt.

Weitere Informationen zu unterstützten Toolbox-Zwischenablageformate finden Sie unter Toolbox (Visual Studio SDK).

Hinweis

Wenn ein VSPackage angibt, dass alle ToolboxItem-Objekte mit nicht standardmäßigen Zwischenablageformaten erhält, nimmt die Visual Studio Umgebung an, dass nur diejenigen Formate, die von den Instanzen ProvideToolboxFormatAttribute VSPackages zu einer angewendetenPackage-Klassenimplementierung angegeben werden, durch ein VSPackage unterstützt werden.Wenn ein VSPackage die standardmäßige Zwischenablageformate sowie ein nichtstandardisiertes Format unterstützen muss, muss er eine Instanz von ProvideToolboxFormatAttribute sowie das Standardformat aller nichtstandardisierte Format anwenden.
Wenn ein VSPackage die dynamische Konfiguration von ToolboxItembereitstellt, muss sie:
1. Wenden Sie eine Instanz von ProvideToolboxItemConfigurationAttribute erstellte mit Type , dem das Paket verwendet, um die IConfigureToolboxItem-Schnittstelle zu implementieren.
2. Auf einem public-Klassen unabhängige von VSPackages Package, muss ein VSPackage die IConfigureToolboxItem-Schnittstelle implementieren.
  
  Eine Instanz ProvideAssemblyFilterAttribute muss auf die Klasse angewendet werden, die IConfigureToolboxItem, wobei eine Zeichenfolge implementiert, die Auswahlkriterien (Filter) enthält als Argument an den Konstruktor der ProvideToolboxItemConfigurationAttribute-Instanz.

Weitere Informationen dazu, wie Sie die Visual Studio Umgebung, dass ein VSPackage Toolbox Steuerelemente bereitstellt, finden Sie unter Registrieren von Toolbox-Stützbenachrichtigt.

Ein Beispiel, veranschaulichend, wie Sie möglicherweise IConfigureToolboxItem Unterstützung implementiert, finden Sie unter Exemplarische Vorgehensweise: ToolboxItem-Konfiguration dynamisch anpassen.

VSPackages das ToolboxItem bereitstellt, muss ToolboxInitialized und ToolboxUpgraded-Ereignisse behandeln.

Klassenhandler implementieren und ToolboxInitialized für die ToolboxUpgraded-Ereignisse:

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

Abonnieren Sie ToolboxInitialized und ToolboxUpgraded-Ereignissen.

Dies ist in der Package Initialize-Methode Implementierung normalerweise durchgeführt:

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

Ein Beispiel dafür, wie Handler für ToolboxInitialized und ToolboxUpgraded-Ereignissen finden Sie unter Exemplarische Vorgehensweise: Toolboxelemente automatisch ladenimplementiert.

Erstellen Toolbox-Steuer

Die zugrunde liegende Implementierung eines Steuerelements Toolbox aus Component abgeleitet werden muss und dem Standard- oder in einer abgeleiteten Implementierung des ToolboxItem-Objekt gekapselt werden.

Die einfachste Möglichkeit, Componentbereitzustellen abgeleiteten Implementierung der Toolbox die Steuerelemente ist, indem ein Objekt erweitert, das von Controlinsbesondere die UserControl-Klasse abgeleitet ist.

So erstellen Sie Steuerelemente Toolbox

Verwenden Sie den Projektmappen-Explorer, Neues Element hinzufügen Befehl Toolbox ein Objekt zu erstellen, das UserControlimplementiert.

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

        }
    }

Weitere Informationen zur Erstellung von Windows Forms-Steuerelemente und Toolbox Steuerelemente finden Sie unter Entwickeln benutzerdefinierter Windows Forms-Steuerelemente mit .NET Framework oder Exemplarische Vorgehensweise: Toolboxelemente automatisch laden.

(Optional) kann eine Anwendung die Möglichkeit, ein benutzerdefiniertes Objekt zu verwenden, das vom ToolboxItem-Objekt, um dessen Toolbox die Steuerung an Toolboxbereitzustellen.

Hinweis

Jede Klasse, die aus dem ToolboxItem-Objekt abgeleitet wird, muss eine Instanz SerializableAttribute verfügen, das zuvor angewendet wird.

Eine benutzerdefinierte Implementierung, die von ToolboxItem abgeleitet wurde, kann eine Anwendung mithilfe von größeres Steuerelement ermöglicht darüber, wie die Daten ToolboxItem Designermetadaten, verbesserte Behandlung von Unterstützung für nichtstandardisierte Zwischenablageformate und Funktionalität serialisiert wird, kann die Endbenutzer interaktion.

Im Beispiel werden Benutzer mithilfe eines Dialogfelds aufgefordert, Funktionen auszuwählen:

<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[] {};
        }
    }
}

Hinweis

Es ist auch möglich, für eine Klasse vom ToolboxItem-Objekt, eine eigene unabhängige Implementierung des zugrunde liegenden Steuerelements bereitzustellen abgeleitet ist.Diese Klasse wird dann zum Erstellen und Angeben aller zugrunde liegenden Komponenten zuständig.

Explizite Einführung von Toolboxelementen

So zeigen Sie anschließend hinzugefügten der Toolbox hinzugefügt werden soll, muss ein Steuerelement in einer Instanz von ToolboxItem oder eines Objekts enthalten sein, das von ToolboxItem abgeleitet wird und mit der Toolbox zu IToolboxService-Schnittstelle.

So kapseln und Steuerelemente Toolbox hinzu

Kapseln die Component Implementierung in eine Instanz eines ToolboxItem-Objekts oder ToolboxItemabgeleitete Objekt, indem Sie Initialize-Methode des Objekts mit implementierenden Typeder Komponente aufrufen:
```
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);
}
```
Im Beispiel oben userControl eines Objekts, das von UserControl abgeleitet ist (eine Instanz des Objekts ToolboxControl1 oben), das verwendet wird, um ein neues ToolboxItemzu erstellen.

Hinweis

Die Standardimplementierung des ToolboxItem-Konstruktors, der ein Type-Argument akzeptiert (#ctor(Type)-Konstruktor ruft die ToolboxItem Initialize-Methode des Objekts aufgerufen.

Verwenden Sie den Toolboxdienst (IToolboxService), um das ToolboxItem-Objekt hinzuzufügen, das von der zugrunde liegenden Steuerelementimplementierung erstellt wird.

Im folgenden Beispiel wird der Zugriff auf den Toolboxdienst erhalten, werden einige Eigenschaften der ToolboxItem-Instanz customItem festgelegt, und anschließend wird customItem zu Toolboxhinzugefügt:

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

Verwenden der Reflektion zum Hinzufügen von Toolbox-Kontrollen

Das Anwenden von Attributen auf die Klasse an, die ein Toolbox die Steuerung implementiert, ermöglicht die Visual Studio Umgebung oder eine Visual Studio SDK basierte Anwendung, Reflektion verwenden, um Steuerelemente Toolboxautomatisch erkannt und ordnungsgemäß hinzugefügt werden soll.

So Reflektion und Attribute in Toolbox Steuerelemente anwenden

Identifizieren Sie alle Objekte, die zum Implementieren der Toolbox die Steuerelemente mit Instanzen von ToolboxItemAttributeverwendet werden.

Der Typ der Instanz von ToolboxItemAttribute auf ein Objekt willen bestimmt, ob und wie ToolboxItem von ihm erstellt wird.
1. Eine Instanz von ToolboxItemAttribute erstellten Anwenden BOOLEAN mit einem Wert von false auf ein Objekt macht dieses Objekt nicht durch Reflektion zur Toolbox verfügbar.
  
  Dies kann hilfreich sein, ein Objekt als UserControl von Toolbox während der Entwicklung zu suchen.
2. Eine Instanz von ToolboxItemAttribute erstellten Anwenden BOOLEAN mit einem Wert von true auf ein Objekt macht, dass das Objekt, das einem der Toolbox durch Reflektion verfügbar ist, und setzt voraus, dass das Objekt der Toolbox mit einem Standardwert ToolboxItem-Objekts hinzugefügt wird.
3. Eine Instanz von ToolboxItemAttribute erstellten mit Type Anwenden eines benutzerdefinierten Objekts, das von ToolboxItem abgeleitetes Objekt bereitstellt, und über Reflektion auf Toolbox erfordert, dass das Objekt der Toolbox mit diesem benutzerdefinierten Objekts hinzugefügt wird, das von ToolboxItemabgeleitet ist.
Geben Sie Reflektions (um die Visual Studio Mechanismus zur Umgebung die Bitmap) an, die zum Anzeigen des Steuerelements Toolbox in Toolbox zu verwenden, indem Sie eine Instanz von ToolboxBitmapAttribute Implementierung der steuer zur Toolbox hinzufügen.

Falls erforderlich, wenden Sie Instanzen von ToolboxItemFilterAttribute zu ToolboxItem-Objekten, die Reflektion verwenden, um sie für die Verwendung mit Objekten als statisch markiert, die ein übereinstimmendes Attribut verfügen.

Im folgenden Beispiel verfügt die Implementierung eines Toolbox steuer eine Instanz von ProvideAssemblyFilterAttribute darauf angewendeten, die dieses Steuerelement in Toolbox bereitstellt Arbeitsdokument nur, wenn es sich beim aktuellen Designer 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

Es gibt drei grundlegende Verfahren für die Verwendung von Reflektion zum Automatisches Laden von ToolboxItem.

Verwenden von ToolService-Funktionalität zum Abrufen von Toolbox-Kontrollen

ToolboxService stellt GetToolboxItems VSPackages mit den statischen Methoden, die Reflektion verwenden, um Assembly nach allen Typen, die Toolboxelemente unterstützen überprüfen und Elemente für diese Typen zurück. So zurückgegeben werden soll, muss ein Toolboxelement:

Er muss öffentlich sein.
Implementieren Sie die IComponent-Klasse.
Er darf nicht abstrakt sein.
Haben Sie ToolboxItemAttribute in seinem Typ.
ToolboxItemAttribute nicht festgelegt haben false in seinem Typ
Er darf keine generischen Parameter enthalten.

So rufen Sie diese Liste

Erstellen Sie eine Instanz von Assembly die Assembly ansprechend, die für ToolboxItem-Objekte überprüft werden soll.

Hinweis

Zum Abrufen einer Instanz von Assembly für die aktuelle Assembly, verwenden Sie die statische Methode GetExecutingAssembly.
GetToolboxItemsAufruf eines ICollection-Objekt zurückgibt, das eine Liste der entsprechenden Objekte enthält.

Hinweis

Wenn ein Objekt in der zurückgegebenen ICollection verfügt, die eine gültige Instanz von ToolboxBitmapAttribute zu ihrer Implementierung, die GetToolboxItems-Methode festgelegt wird Bitmap-Eigenschaft des ToolboxItem .

Verwenden Sie GetService abzurufen, um Zugriff auf IToolboxService, und legen Sie seine AddToolboxItem-Methode, um Elemente aus dem zurückgegebenen ICollection-Objekt zur Toolbox hinzugefügt werden soll.

Der Code unter der Abfragen und die ausgeführte Anwendung ruft eine Liste aller seiner ToolboxItem-Objekte und lädt sie. Ein Beispiel, das die Ausführung von Code in veranschaulichend finden Sie in der Initialization-Methode in Exemplarische Vorgehensweise: ToolboxItem-Konfiguration dynamisch anpassen.

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

Verwenden von eingebetteten Text-Betriebsmittel, um Toolbox-Kontrollen automatisch zu laden

Eine Text Ressource in einer Assembly, die eine richtig formatierte Liste der Toolbox die Steuerelemente enthält, kann durch ParseToolboxResource verwendet werden, um ein Toolbox die Steuerung automatisch geladen werden sollen, wenn sie richtig formatiert ist.

Eine Text Ressource, die eine Liste von Objekten enthält, muss das Laden einer Assembly verfügbar sein, die zu einem VSPackage zugegriffen werden kann.

So fügen Sie Text eine Ressource hinzufügen verfügbar machen und der Assembly

Klicken Sie mit der rechten Maustaste auf das Projekt Projektmappen-Explorer.
Zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element.
Wählen Sie im Dialogfeld Neues Element hinzufügen stellen einen Namen und Textdatei .
In Projektmappen-Explorerhat der rechten Maustaste auf die neu erstellte Textdatei und die Buildvorgang-Eigenschaft auf Eingebettete Ressource fest.

Einträge, für das Toolbox-Steuerelement geladen werden kann, muss der Name der implementierenden Klasse den Namen der Assembly, die sie enthält.

Weitere Informationen über das Format der Toolbox Steuerelemente Einträgen Text der eingebetteten Ressource finden Sie in der ParseToolboxResource Referenzseite.
Installieren Sie einen Suchpfad für Dateien, die die Assemblys enthalten, die Toolbox steuer Objekte.

ParseToolboxResource, Verzeichnisse der Suche nur im angegebenen Registrierungseintrag HKEY_CURRENT_USER \ Software \ Microsoft \ VisualStudio \ <version> \ AssemblyFolders, wo <version> die Versionsnummer der Version von Visual Studio ist (z. B. 8.0).

Hinweis

Der Stammpfad von HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ VisualStudio \ <Version> kann mit einem alternativen Stamm, wenn die Visual Studio-Shell initialisiert wird oder Verwendung von DefaultRegistryRootAttributeüberschrieben werden.Weitere Informationen finden Sie unter Befehlszeilenschalter (Visual Studio SDK).

Ausführliche Informationen über das richtige Format der AssemblyFolder-Registrierungseinträge finden Sie in der ParseToolboxResource Referenzseite.
Rufen Sie eine Instanz von Synchronized der eingebetteten Ressource Text und Zugreifen auf, wenn Lokalisierungsunterstützung für den angegebenen Kategorienamen, eine Instanz von ResourceManagererforderlich ist und diese verwendet wird, um die ParseToolboxResource-Methode aufzurufen.
```
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);
}
}
```
Im Beispiel oben wird eine Liste mit Text in einer eingebetteten Ressource in der Assembly enthalten TbxItemProvider-Klasse enthält die ParseToolboxResource wird zusammen mit den TbxCategories Zeichenfolgenressourcen übergeben.

Die Methode durchsucht alle Dateien in Verzeichnissen, die Assemblys enthalten, die unter dem AssemblyFolders-Registrierungseintrag für die Toolbox die Steuerelemente angegeben werden, die in der Ressource aufgeführten und lädt sie.

Hinweis

Wenn ein Toolbox die Steuerung, das durch ParseToolboxResource gefunden wird, verfügt, die eine gültige Instanz von ToolboxBitmapAttribute zu ihrer Implementierung, die festlegt ParseToolboxResource Bitmap, die verwendet wurde, um die Toolbox die Steuerung anzuzeigen.

Explizit durch Reflektion, um Toolbox-Kontrollen automatisch zu laden

Wenn es erforderlich ist, Assemblys zu Informationen über die Toolbox-Steuerelemente explizit abzufragen, die sie enthalten, anstatt die Aufgabe zu GetToolboxItemsdelegierend, kann dies geschehen.

Um explizit Reflektion verwenden, um Toolbox auf Steuerelemente automatisch laden

Erstellen Sie eine Instanz von Assemblyund jede Assembly verweisen, die für ToolboxItem-Objekte überprüft werden soll.

Hinweis

Zum Abrufen einer Instanz von Assembly für die aktuelle Assembly, verwenden Sie die statische Methode GetExecutingAssembly.
Für jede Assembly überprüft werden soll, verwenden Sie die Assembly des Objekts GetTypes-Methode zum Abrufen einer Liste von jedem Type in der Assembly.
Stellen Sie sicher, dass der Typ nicht abstrakt ist und die IComponent-Schnittstelle unterstützt (alle Implementierungen der Toolbox Steuerelemente, mit denen ein ToolboxItem-Objekt zu instanziieren, müssen diese Schnittstelle implementieren).
Rufen Sie die Attribute aus Type und verwenden diese Informationen, um zu bestimmen, ob ein VSPackage das Objekt geladen werden soll.

Hinweis

Obwohl in den Prinzipal kann ein ToolboxItem-Objekt aus einer IComponent-Schnittstellenimplementierung ohne eine Instanz von ToolboxItemAttribute zu erstellen false nicht festgelegt, es empfiehlt es sich, angewendeten nicht.
Verwenden Sie zum Abrufen GetConstructor-Konstruktoren für die ToolboxItem-Objekten, die die Toolbox steuert, erfordert.
Erstellen Sie die ToolboxItem-Objekte und fügen Sie sie hinzu. Toolbox

Zum Beispiel zu sehen, explizite Verwendung der Reflektion abzurufen und zu illustrieren Steuerelemente Toolbox automatisch zu laden, finden Sie unter CreateItemList , das in Exemplarische Vorgehensweise: Toolboxelemente automatisch ladenbeschrieben wird.

Weitere Toolbox-Steuer Bereitstellungskonfiguration

VSPackage können zusätzliche Kontrolle darüber, wann und wie ein Toolbox die Steuerung durch Toolbox, durch die Implementierung von IConfigureToolboxItemund Verwendung von ProvideAssemblyFilterAttributeangezeigt wird, und ProvideToolboxItemConfigurationAttributeabdecken.

Das Anwenden von ToolboxItemFilterAttribute-Instanzen einer Klasse stellt nur statisches Steuerelement darüber, ob und wie ein Toolbox-Steuerelement verfügbar ist.

Um dynamische Steuerelemente Toolbox Unterstützung für Konfiguration erstellen

Erstellen Sie eine Klasse, die die Schnittstelle als Teil IConfigureToolboxItem VSPackages implementiert.

Hinweis

Die IConfigureToolboxItem-Schnittstelle darf nicht in derselben Klasse implementiert werden, die eine Implementierung von VSPackages Packagebereitstellt.

Ordnen Sie die Implementierung von IConfigureToolboxItem mit den Objekten in bestimmten Assembly zu, indem Sie eine Instanz ProvideAssemblyFilterAttribute darauf anwenden.

Das Beispiel stellt den nachfolgenden steuer Toolbox Konfiguration für eine dynamische Assemblys Objekt innerhalb des Vsip.*-Namespace und - Objekte c$benötigens, dass bestimmte ToolboxItem - Designern sichtbar nur mit UserControlund andere, die nie UserControl- Designern sichtbar sind.

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

Registrieren von VSPackages als Bereitstellen einer bestimmten Implementierung von IConfigureToolboxItem , indem Sie eine Instanz von ProvideToolboxItemConfigurationAttribute zur Implementierung von VSPackages Packageanwenden.

Im folgenden Beispiel wird die Visual Studio Umgebung informieren, dass das Paket, das von Vsip.ItemConfiguration.ItemConfiguration-Klasse implementiert wird, die Vsip.ItemConfiguration.ToolboxConfiguration bereitstellt, um dynamisches ToolboxItemzu unterstützen.

<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

Benutzerdefinierte Drag & Drop

Neben zu Toolbox selbst hinzugefügt werden, können ToolboxItem-Objekte und ihre Implementierungen verwendet werden, um die Drag & Drop-Unterstützung im Visual Studio IDE zu erweitern. Dies kann zu Toolbox und in Editoren verfügbar gemacht werden sollen, die beliebige Zwischenablageformate ermöglichen.

VSPackages auf das verwaltete Paketframework muss als Bereitstellen von benutzerdefinierten Toolboxelement-Zwischenablageformaten registrieren, indem er eine Instanz von ProvideToolboxFormatAttribute auf die Klasse angewendet wird, die Packageimplementiert.

Weitere Informationen zum Registrieren Toolbox als Anbieter finden Sie unter Registrieren von Toolbox-Stütz.

Um benutzerdefinierte Zwischenablageformate und Drag & Drop-Unterstützung in Toolbox Steuerelemente unterstützen

Erstellen Sie eine Implementierung des ToolboxItemCreatorCallback Delegaten.

Diese Implementierung sollte ein ToolboxItem-Objekt zurückgeben, das das nichtstandardisierte Zwischenablageformat unterstützt.

Ein Beispiel finden ToolboxItemCreatorCallback Implementierung eines Delegaten, die ToolboxItem und ToolboxItemCreatorCallback Referenzseiten.

Führen Sie diese Implementierung der ToolboxItemCreatorCallback Delegaten, der auf Visual Studio Toolbox für eine nichtstandardisierte Toolbox verfügbar ist, indem Sie AddCreatoraufrufen.

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

In diesem Abschnitt

Gewusst wie: Unterstützen von toolbox-Drag & Drop-Funktionalität
Beschreibt, wie Drag & Drop-Unterstützung in einer Ansicht des Dokuments implementiert.
Gewusst wie: Erstellen Sie benutzerdefinierte Toolboxelemente für die Verwendung von Interop-Assemblys bereit
Beschreibt neue ActiveX-Steuerelemente und -Toolboxzu Visual Studio neue Elemente hinzuzufügen. Diese neuen Artikel können entweder ein Standardwert zwischenablageformat oder ein benutzerdefiniertes Format aufweisen, die von einem VSPackage unterstützt werden.
Registrieren von Toolbox-Stütz
Beschreibt, wie ein VSPackage Toolbox als Anbieter registriert. Befasst sich auch dem Sichern oder der Anwendung weiterer Toolbox.

Siehe auch

Freigeben über

Erweiterte Toolbox-Steuerentwicklung

Toolboxelement-Anbieter VSPackage

So konfigurieren Toolboxelement-Anbieter als VSPackage

Erstellen Toolbox-Steuer

So erstellen Sie Steuerelemente Toolbox

Explizite Einführung von Toolboxelementen

So kapseln und Steuerelemente Toolbox hinzu

Verwenden der Reflektion zum Hinzufügen von Toolbox-Kontrollen

So Reflektion und Attribute in Toolbox Steuerelemente anwenden

Verwenden von ToolService-Funktionalität zum Abrufen von Toolbox-Kontrollen

So rufen Sie diese Liste

Verwenden von eingebetteten Text-Betriebsmittel, um Toolbox-Kontrollen automatisch zu laden

So fügen Sie Text eine Ressource hinzufügen verfügbar machen und der Assembly

Explizit durch Reflektion, um Toolbox-Kontrollen automatisch zu laden

Um explizit Reflektion verwenden, um Toolbox auf Steuerelemente automatisch laden

Weitere Toolbox-Steuer Bereitstellungskonfiguration

Um dynamische Steuerelemente Toolbox Unterstützung für Konfiguration erstellen

Benutzerdefinierte Drag & Drop

Um benutzerdefinierte Zwischenablageformate und Drag & Drop-Unterstützung in Toolbox Steuerelemente unterstützen

In diesem Abschnitt

Siehe auch

Aufgaben

Konzepte

Weitere Ressourcen

Zusätzliche Ressourcen