Desenvolvimento avançado de controle de caixa de ferramentas

Artigo
05/18/2015

Dica

A maneira recomendada para adicionar controles personalizados à caixa de ferramentas é usar os modelos de controle de caixa de ferramentas que vêm com o SDK de 10 Visual Studio.Este tópico é mantido para compatibilidade com versões anteriores, adicionando controles existentes na caixa de ferramentas e para desenvolvimento avançado de controle de caixa de ferramentas.

Para obter mais informações sobre a criação de controles da toolbox, usando os modelos, consulte Como: criar um controle de caixa de ferramentas que usa o Windows Forms e Como: criar um controle de caixa de ferramentas que utiliza WPF.

Um VSPackage com base na estrutura de pacote gerenciado pode estender Visual Studio funcionalidade de caixa de ferramentas, adicionando controles, objetos derivados ToolboxItem objetos. Cada ToolboxItem é implementada por um objeto derivado de Component.

VSPackage de provedor de Item de caixa de ferramentas

Um VSPackage com base na estrutura de pacote gerenciado deve ser registrado como um provedor de controle de caixa de ferramentas através de .NET Framework atributos e manipular os eventos relacionados à caixa de ferramentas.

Para configurar um VSPackage como um provedor de Item da caixa de ferramentas

Criar uma instância da ProvideToolboxItemsAttribute aplicados à implementação de classe Package. Por exemplo:

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 {

Dica

O construtor para ProvideToolboxItemsAttribute leva a um número de versão como um argumento inteiro.O Visual Studio ambiente usa esse número de versão para determinar se um VSPackage fornecendo ToolboxItem objetos devem ser recarregados ou se as informações armazenadas em cache podem ser usadas por caixa de ferramentas.Para garantir o recarregamento de um VSPackage ao fornecer um ToolboxItem que está em desenvolvimento, esse número de versão incrementados após qualquer modificação.

Se o ToolboxItem objetos fornecem formatos não padronizados de área de transferência da caixa de ferramentas, uma instância de ProvideToolboxFormatAttribute deve ser aplicado a implementação de classe a Package objeto para cada formato de área de transferência suportado pelo ToolboxItem os objetos que o VSPackage fornece.

Para obter mais informações sobre formatos de área de transferência da caixa de ferramentas com suporte, consulte A caixa de ferramentas (Visual Studio SDK).

Dica

Se VSPackage indica que ele fornece qualquer ToolboxItem objetos com formatos de área de transferência não-padrão, o Visual Studio ambiente assume que somente os formatos indicados pelo ProvideToolboxFormatAttribute instâncias aplicadas a um VSPackage Package a implementação de classe são compatíveis com o VSPackage.Se precisar de um VSPackage suportar os formatos de área de transferência padrão, bem como em um formato diferente do padrão, ele deve aplicar uma instância de ProvideToolboxFormatAttribute para cada formato padrão, bem como o formato não-padrão.
Se o VSPackage fornece a configuração dinâmica de ToolboxItem, ele deve:
1. Aplicar uma instância de ProvideToolboxItemConfigurationAttribute construídos usando o Type que o pacote utiliza para implementar a IConfigureToolboxItem interface.
2. Em um public classe independente do VSPackage Package, o VSPackage deve implementar a IConfigureToolboxItem interface.
  
  Uma instância da ProvideAssemblyFilterAttribute deve ser aplicado para a implementação da classe IConfigureToolboxItem, usando uma seqüência de caracteres contendo um critério de seleção (filtro) como o argumento para o ProvideToolboxItemConfigurationAttribute construtor da instância.

Para obter informações sobre como notificar o Visual Studio controla o ambiente em que um VSPackage oferece a barra de ferramentas, consulte Registrar os recursos de suporte da caixa de ferramentas.

Para obter um exemplo que ilustra como um pode implementar IConfigureToolboxItem de suporte, consulte Passo a passo: Personalizando a configuração de ToolboxItem dinamicamente.

Os VSPackages fornecendo um ToolboxItem deve lidar com ToolboxInitialized e ToolboxUpgraded eventos.

Implementar manipuladores para o ToolboxInitialized e ToolboxUpgraded eventos:

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

Inscrever-se a ToolboxInitialized e ToolboxUpgraded eventos.

Isso geralmente é feito o Package na implementação Initialize método:

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

Para obter um exemplo de como implementar manipuladores para ToolboxInitialized e ToolboxUpgraded eventos, consulte Passo a passo: Itens de caixa de ferramentas Autoloading.

Criação do controle de caixa de ferramentas

A implementação subjacente de um controle de caixa de ferramentas deve ser derivada de Component e encapsulado no padrão ou uma implementação derivada da ToolboxItem objeto.

A maneira mais fácil para fornecer uma Component-derivada de implementação de controles da Toolbox está estendendo um objeto derivado de Control, em particular, o UserControl classe.

Para criar controles de caixa de ferramentas

Use Solution Explorerdo Add New Item comando para criar um objeto de caixa de ferramentas que implementa 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) {

        }
    }

Para obter mais informações sobre autoria de controles Windows Forms e controles de caixa de ferramentas, consulte Desenvolvendo controles dos Windows Forms personalizados com o .NET Framework ou Passo a passo: Itens de caixa de ferramentas Autoloading.

(Opcional) Um aplicativo pode optar por usar um objeto personalizado derivado de ToolboxItem objeto para fornecer o seu controle de caixa de ferramentas para o caixa de ferramentas.

Dica

Qualquer classe derivada da ToolboxItem objeto deve ter uma instância da SerializableAttribute aplicados a ele.

Uma implementação personalizada derivada de ToolboxItem pode estender um aplicativo, oferecendo maior controle sobre como o ToolboxItem dados são serializados, aprimorada de manipulação de metadados de designer, suporte para formatos de área de transferência não-padrão e funcionalidade que permite a interação do usuário final.

No exemplo, os usuários são solicitados por uma caixa de diálogo para selecionar recursos:

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

Dica

Também é possível para uma classe derivada da ToolboxItem o objeto para fornecer sua própria implementação independente do controle base.Essa classe é responsável por Criando e fornecendo todos os componentes subjacentes.

Inclusão explícita de itens da caixa de ferramentas

A ser adicionado à caixa de ferramentas, um controle deve estar contido em uma instância de ToolboxItem ou de um objeto derivado de ToolboxItem e, em seguida, ser adicionado ao caixa de ferramentas usando o IToolboxService interface.

Para encapsular e adicionar controles de caixa de ferramentas

Encapsular o Component implementação em uma instância de um ToolboxItem objeto ou um ToolboxItem-derivado objeto chamando desse objeto Initialize método com a implementação do componente Type:
```
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);
}
```
Acima é um exemplo de um objeto userControl derivado de UserControl (uma instância da ToolboxControl1 objeto mostrado acima) que está sendo usado para construir um novo ToolboxItem.

Dica

A implementação padrão da ToolboxItem levando construtor um Type argumento (#ctor(Type) chamadas de construtor o ToolboxItem do objeto Initialize método.

Usar o serviço da caixa de ferramentas (IToolboxService) para adicionar o ToolboxItem objeto construído a partir da implementação de controle subjacente.

No exemplo abaixo, o acesso ao serviço da caixa de ferramentas é obtido, algumas das propriedades da ToolboxItem instância customItem estiverem definidas e, em seguida customItem é adicionado ao caixa de ferramentas:

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

Usando a reflexão para adicionar controles de caixa de ferramentas

Aplicando atributos para a classe de implementação de um controle de caixa de ferramentas permite que o Visual Studio ambiente ou um SDK do Visual Studio com base no aplicativo para usar a reflexão para detectar automaticamente e adicionar corretamente os controles para o caixa de ferramentas.

Para aplicar a reflexão e atributos para controles da Toolbox

Identificar todos os objetos usados para implementar controles de caixa de ferramentas com instâncias do ToolboxItemAttribute.

O tipo de instância de ToolboxItemAttribute a um objeto será determina se e como um ToolboxItem é construído a partir dele.
1. A aplicação de uma instância de ToolboxItemAttribute construído com uma BOOLEAN valor de false a um objeto torna esse objeto não está disponível na caixa de ferramentas através de reflexão.
  
  Isso pode ser útil para isolar um objeto, como um UserControl da caixa de ferramentas durante o desenvolvimento.
2. A aplicação de uma instância de ToolboxItemAttribute construído com uma BOOLEAN valor de true a um objeto disponibiliza esse objeto à caixa de ferramentas através de reflexão e requer que o objeto ser adicionado à caixa de ferramentas usando um padrão ToolboxItem objeto.
3. Aplicando uma instância de ToolboxItemAttribute construído com o Type de um objeto personalizado derivado de ToolboxItem disponibiliza o objeto para o caixa de ferramentas através de reflexão e requer que o objeto ser adicionado à caixa de ferramentas com esse objeto personalizado derivado de ToolboxItem.
Especificar (para o Visual Studio mecanismo de reflexo do ambiente) o bitmap será usada para exibir o controle de caixa de ferramentas no caixa de ferramentas , adicionando uma instância de ToolboxBitmapAttribute para a caixa de ferramentas de controle de implementação.

Se necessário, aplicar instâncias de ToolboxItemFilterAttribute para ToolboxItem objetos para usar a reflexão para estaticamente marcá-los para uso com objetos que possuem um atributo correspondente.

No exemplo abaixo, a implementação de um controle de caixa de ferramentas tem uma instância de ProvideAssemblyFilterAttribute aplicado a ele, que disponibiliza em que o controle a caixa de ferramentas somente quando o documento de trabalho atual é um UserControl designers

<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

Existem três técnicas básicas para usar a reflexão para autoloading ToolboxItem.

Usando a funcionalidade de ToolService para recuperar os controles da Toolbox

O ToolboxService fornece a VSPackages estática GetToolboxItems métodos que usam a reflexão para fazer a varredura de módulos (assemblies) para todos os tipos que oferecem suporte a itens de caixa de ferramentas e itens para esses tipos de retorno. A ser retornada, um item da caixa de ferramentas deve:

Ser pública.
Implementar a IComponent classe.
Não ser abstrato.
Ter um ToolboxItemAttribute em seu tipo.
Não tem um ToolboxItemAttribute definido como false em seu tipo
Não conter parâmetros genéricos.

Para obter essa lista.

Criar uma instância de Assembly fazendo referência ao assembly que deve ser examinado para ToolboxItem objetos.

Dica

Para obter uma instância de Assembly para o conjunto atual, use o método estático GetExecutingAssembly.
Chame GetToolboxItems, retornando um ICollection objeto que contém uma lista dos objetos apropriados.

Dica

Se um objeto retornado ICollection tem uma instância válida de ToolboxBitmapAttribute atribuído a sua implementação, o GetToolboxItems método definirá o ToolboxItem do objeto Bitmap propriedade.

Use GetService para obter acesso a IToolboxServicee usar sua AddToolboxItem método para adicionar itens de retornado ICollection o objeto à caixa de ferramentas.

O código a seguir consulta o aplicativo em execução e obtém uma lista de todos os seus ToolboxItem objetos e os carrega. Para obter um exemplo que ilustra isso no código em execução, consulte o Initialization método na Passo a passo: Personalizando a configuração de ToolboxItem dinamicamente.

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

Uso de recursos incorporados de texto para controles da Toolbox Autoload

Um recurso de texto em um assembly que contém uma lista formatada corretamente dos controles de caixa de ferramentas pode ser usado por ParseToolboxResource para carregar automaticamente um controle de caixa de ferramentas se formatado corretamente.

Um recurso de texto que contém uma lista de objetos para carregar deve estar disponível em um assembly acessível para o VSPackage.

Para adicionar e disponibilizar um recurso de texto para o assembly.

Em Solution Explorer, botão direito do mouse um projeto.
Aponte para Add, em seguida, clique em Novo Item.
No Add New Item caixa de diálogo, selecione Arquivo de texto e forneça um nome.
Em Solution Explorer, o botão direito do mouse no arquivo de texto criado recentemente e definir o Build Action propriedade para Embedded Resource.

Entradas para o caixa de ferramentas o controle a ser carregado deve conter o nome da classe implementação, o nome do assembly que o contém.

Para obter informações sobre o formato da caixa de ferramentas controlam entradas para o recurso incorporado de texto, consulte o ParseToolboxResource página de referência.
Configure um caminho de pesquisa para os arquivos que contém os assemblies que hospeda os objetos de controle de caixa de ferramentas.

ParseToolboxResource, pesquisa somente pastas especificadas na entrada do registro HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\<version>\AssemblyFolders, onde <version> é o número de versão do lançamento da Visual Studio (por exemplo, 8.0).

Dica

O caminho de raiz do HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\<Version> pode ser substituída por uma raiz alternativa quando o shell de Visual Studio é inicializado, ou o uso do DefaultRegistryRootAttribute.Para obter mais informações, consulte: Opções de linha de comando (Visual Studio SDK).

Para obter detalhes sobre o formato correto das entradas do registro AssemblyFolder, consulte a ParseToolboxResource página de referência.
Obter uma instância do Synchronized o acesso ao recurso incorporado de texto e, se o suporte de localização é necessária para nomes de categoria, uma instância de ResourceManagere usá-las para chamar o ParseToolboxResource método.
```
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);
}
}
```
No exemplo acima, uma lista contido em um recurso de texto incorporado no assembly que contém a classe TbxItemProvider é passado para ParseToolboxResource juntamente com o TbxCategories recursos de string.

O método irá procurar todos os arquivos que contém módulos (assemblies) em diretórios especificados da entrada do registro de AssemblyFolders para os controles de caixa de ferramentas listadas no recurso e carregá-los.

Dica

Se um controle de caixa de ferramentas por ParseToolboxResource tem uma instância válida de ToolboxBitmapAttribute atribuído a sua implementação, ParseToolboxResource definirá o bitmap usado para exibir o controle de caixa de ferramentas.

Explicitamente usando a reflexão para controles da Toolbox Autoload

Se for necessário explicitamente os assemblies de consulta para obter informações sobre o caixa de ferramentas controles que eles contêm, em vez de delegar a tarefa a GetToolboxItems, isso pode ser feito.

Usar explicitamente a reflexão para controles da Toolbox autoload

Criar uma instância de Assembly, referir-se a cada assembly que deve ser examinado para ToolboxItem objetos.

Dica

Para obter uma instância de Assembly para o conjunto atual, use o método estático GetExecutingAssembly.
Para cada assembly a ser digitalizada, use o Assembly do objeto GetTypes método para obter uma lista de cada Type no assembly.
Verifique se o tipo não é abstrato e oferece suporte a IComponent interface (todas as implementações de controles de caixa de ferramentas usados para instanciar um ToolboxItem objeto deve implementar essa interface).
Obter os atributos de Type e usar essas informações para determinar se o VSPackage deseja carregar o objeto.

Dica

Embora principal é possível criar um ToolboxItem de objeto de um IComponent interface implementação sem uma instância da ToolboxItemAttribute não definido como false aplicados a ele, não recomendamos fazê-lo.
Use GetConstructor para obter os construtores para o ToolboxItem objetos que necessitam de controles da Toolbox.
Construir o ToolboxItem objetos e adicioná-los para o caixa de ferramentas.

Para ver um exemplo que ilustra o uso explícito de reflexão para obter e controles da Toolbox autoload, consulte o CreateItemList descrito em Passo a passo: Itens de caixa de ferramentas Autoloading.

Configuração de controle de caixa de ferramentas adicionais

Um VSPackage pode exercer controle adicional sobre quando e como um controle de caixa de ferramentas é exibido pela caixa de ferramentas, por meio da implementação de IConfigureToolboxIteme o uso de ProvideAssemblyFilterAttribute, e ProvideToolboxItemConfigurationAttribute.

Aplicando ToolboxItemFilterAttribute instâncias de uma classe fornece controle estático somente sobre quando e como um caixa de ferramentas o controle está disponível.

Para criar o suporte de configuração dinâmica para controles da Toolbox

Construir uma classe de implementação do IConfigureToolboxItem interface como parte de um VSPackage.

Dica

O IConfigureToolboxItem interface não deve ser implementada da mesma classe que fornece a implementação do VSPackage de Package.

Associar a implementação de IConfigureToolboxItem com os objetos em conjuntos específicos, aplicando uma instância da ProvideAssemblyFilterAttribute a ele.

O exemplo a seguir fornece uma configuração dinâmica para assemblies de objeto de controle de caixa de ferramentas dentro do Vsip.* namespace e exigindo que certos ToolboxItem objetos fiquem visíveis somente com UserControl-com designers e outros nunca visível com UserControl-com base em designers.

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

Registrar um VSPackage como fornecendo uma implementação específica da IConfigureToolboxItem , aplicando uma instância de ProvideToolboxItemConfigurationAttribute a implementação do VSPackage de Package.

O exemplo a seguir informa ao Visual Studio ambiente em que o pacote é implementado pelo Vsip.ItemConfiguration.ItemConfiguration fornece a classe Vsip.ItemConfiguration.ToolboxConfiguration para oferecer suporte a dynamic ToolboxItem.

<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

Suporte personalizado de arrastar-e-soltar

Para além de que está sendo adicionado ao caixa de ferramentas propriamente dito, ToolboxItem objetos e suas implementações podem ser usadas para estender o suporte de arrastar-e-soltar na Visual Studio IDE. Isso pode permitir que arbitrário formatos de área de transferência ser exposto para o caixa de ferramentas e nos editores.

VSPackages com base na estrutura de pacote gerenciado deve se registrar como fornecendo personalizado caixa de ferramentas item formatos da área de transferência, aplicando uma instância de ProvideToolboxFormatAttribute para a implementação da classe Package.

Para obter mais informações sobre como registrar como um caixa de ferramentas provedor, consulte Registrar os recursos de suporte da caixa de ferramentas.

Para fornecer suporte de arrastar-e-soltar e formatos personalizados de área de transferência com controles da Toolbox

Criar uma implementação da ToolboxItemCreatorCallback delegar.

Essa implementação deve retornar um ToolboxItem objeto que ofereça suporte ao formato de área de transferência não-padrão.

Para um exemplo de implementação de um ToolboxItemCreatorCallback delegar, consulte o ToolboxItem e ToolboxItemCreatorCallback páginas de referência.

Fazer essa implementação da ToolboxItemCreatorCallback representante disponível para o Visual Studiocaixa de ferramentas para uma caixa de ferramentas não-padrão chamando 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) {
           /*
            */
        }
    }
}

Nesta seção

Como: funcionalidade de arrastar-e-soltar de caixa de ferramentas de suporte
Descreve como implementar o suporte de arrastar-e-soltar em um modo de exibição do documento.
Como: fornecer os itens de caixa de ferramentas personalizada usando a Assemblies de interoperabilidade
Descreve como adicionar novos controles de ActiveX e novos itens para o Visual Studiocaixa de ferramentas. Esses novos itens podem têm um formato padrão da área de transferência ou um formato personalizado que suporte o VSPackage.
Registrar os recursos de suporte da caixa de ferramentas
Descreve como registrar um VSPackage como um provedor de caixa de ferramentas. Também fala sobre como oferecer suporte ou usar outros recursos de caixa de ferramentas.

Consulte também

Compartilhar via

Desenvolvimento avançado de controle de caixa de ferramentas

VSPackage de provedor de Item de caixa de ferramentas

Para configurar um VSPackage como um provedor de Item da caixa de ferramentas

Criação do controle de caixa de ferramentas

Para criar controles de caixa de ferramentas

Inclusão explícita de itens da caixa de ferramentas

Para encapsular e adicionar controles de caixa de ferramentas

Usando a reflexão para adicionar controles de caixa de ferramentas

Para aplicar a reflexão e atributos para controles da Toolbox

Usando a funcionalidade de ToolService para recuperar os controles da Toolbox

Para obter essa lista.

Uso de recursos incorporados de texto para controles da Toolbox Autoload

Para adicionar e disponibilizar um recurso de texto para o assembly.

Explicitamente usando a reflexão para controles da Toolbox Autoload

Usar explicitamente a reflexão para controles da Toolbox autoload

Configuração de controle de caixa de ferramentas adicionais

Para criar o suporte de configuração dinâmica para controles da Toolbox

Suporte personalizado de arrastar-e-soltar

Para fornecer suporte de arrastar-e-soltar e formatos personalizados de área de transferência com controles da Toolbox

Nesta seção

Consulte também

Tarefas

Conceitos

Outros recursos

Recursos adicionais