Passo a passo: Criando um controle de caixa de ferramentas do Windows Forms

Artigo
05/18/2015

O modelo de controle de caixa de ferramentas do Windows Forms que está incluído na SDL do Visual Studio 2010 permite que você crie um controle que é automaticamente adicionado para o Toolbox quando a extensão está instalada. Esta explicação passo a passo mostra como usar o modelo para criar um controle de contador que você pode distribuir para outros usuários.

Pré-requisitos

Para concluir este passo a passo, você deve instalar o SDL do Visual Studio 2010.

Dica

Para obter mais informações sobre o SDK de Visual Studio, consulte Ampliando a visão geral de Visual Studio.Para descobrir como fazer o download do SDK do Visual Studio, consulte Visual Studio extensibilidade Developer Center no site do MSDN.

Localizando o modelo de controle de caixa de ferramentas do Windows Forms em Visual Studio

O modelo de controle de caixa de ferramentas do Windows Forms está disponível na Novo projeto caixa de diálogo, em Installed Templates, nos seguintes locais:

Visual Basic, extensibilidade. O idioma do projeto é Visual Basic.
Visual C#, extensibilidade. O idioma do projeto é C#.

Criando um projeto de controle de caixa de ferramentas do Windows Forms

O modelo de controle de caixa de ferramentas do Windows Forms cria um controle de usuário indefinido e fornece toda a funcionalidade necessária para adicionar o controle para o caixa de ferramentas.

Para criar o projeto

No menu File, clique em New, e em seguida, clique em Project
No Novo projeto caixa de diálogo, em Modelos instalados, expanda o nó de sua linguagem de programação preferida e selecione extensibilidade. Na lista de tipos de projeto, selecione Caixa de ferramentas de controle do Windows Forms.
No nome , digite o nome que você deseja usar para o projeto. (Este passo a passo usa o nome contador.) Clique em OK.

Isso cria uma solução que contém um controle de usuário, um atributo para colocar o controle no caixa de ferramentas, e um VSIX de manifesto de implantação. O nome caixa define o nome da solução e o nome do namespace, mas ele não define o nome do controle como ele aparece no caixa de ferramentas. Você irá definir que posteriormente na explicação.

Criar uma Interface do usuário para o controle

O contador controle requer dois controles filho: um Label para exibir a contagem atual e um Button para redefinir a contagem para 0. Não há outros controles filho são necessários porque os chamadores incrementará o contador programaticamente.

Para criar a interface do usuário

Em Solution Explorer, clique duas vezes em ToolboxControl.cs para abri-lo no designer.
Do caixa de ferramentas, arraste um rótulo controle para a superfície de design.
Redimensionar o controle de usuário para 150 x 50 pixels e redimensionar o botão para 50 x 20 pixels.
No Propriedades janela, defina os seguintes valores para os controles na superfície de design.

Controle

Propriedade

Valor

Label1

Texto

""

Button1

Nome

btnReset

Button1

Texto

Reset

Controle	Propriedade	Valor
Label1	Texto	""
Button1	Nome	btnReset
Button1	Texto	Reset

Codificar o controle de usuário

O contador controle irá expor um método para incrementar o contador, um evento a ser gerado sempre que o contador é incrementado, um Redefinir botão e três propriedades para armazenar o texto de exibição, a contagem atual e mostrar ou ocultar o Redefinir botão. O ProvideTolboxControl atributo determina onde na caixa de ferramentas a contador controle será exibido.

Para codificar o controle de usuário

Clique duas vezes no formulário para abrir o seu manipulador de eventos de carga na janela de código.
Acima do manipulador de eventos, crie um número inteiro para armazenar o valor do contador e uma seqüência de caracteres para armazenar o texto de exibição, como mostrado no exemplo a seguir.
```
int currentValue;
string displayText;
```
Crie as seguintes declarações de propriedade pública.
```
public int Value {
    get { return currentValue; } 
    }

public string Message {
    get { return displayText; }
    set { displayText = value; }
}

public bool ShowReset {
    get { return btnReset.Visible; }
    set { btnReset.Visible = value; }
}
```
Os chamadores podem acessar essas propriedades para obter e definir o texto de exibição do contador e para mostrar ou ocultar o Redefinir botão. Os chamadores podem obter o valor atual do somente leitura Value propriedade, mas eles não podem definir o valor diretamente.
Coloque o seguinte código na Load evento para o controle.
```
private void ToolboxControl_Load(object sender, EventArgs e)
{
    currentValue = 0;
    label1.Text = Message + Value;
}
```
Definindo o texto do rótulo na Load evento permite que as propriedades de destino carregar antes que os valores serão aplicados. O texto do rótulo no construtor, resultaria um rótulo vazio.

Crie o seguinte método público para incrementar o contador.

public void Increment()
{
    currentValue++;
    label1.Text = displayText + Value;
    Incremented(this, EventArgs.Empty);
}

Adicionar uma declaração para o Incremented evento.
```
public event EventHandler Incremented;
```
Os chamadores podem adicionar manipuladores para esse evento para responder às alterações no valor do contador.
Retornar ao modo de design e clique duas vezes o Redefinir botão para gerar o btnReset_Click o manipulador de eventos e preencha-o conforme mostrado no exemplo a seguir.
```
private void btnReset_Click(object sender, EventArgs e)
{
    currentValue = 0;
    label1.Text = displayText + Value;
}
```
Definição da classe, clique com o botão direito no nome de classe, clique em Refactor, clique em Renomeare, em seguida, altere o nome da classe para contador. Este é o nome que será exibido na caixa de ferramentas.

Imediatamente acima da definição de classe, no ProvideToolboxControl a declaração de atributo, altere o valor do primeiro parâmetro de "Counter" para "General". Isso define o nome do grupo de itens que irá hospedar o controle no caixa de ferramentas.

A exemplo a seguir mostra a ProvideToolboxControl atributo e a definição de classe ajustado.

[ProvideToolboxControl("General", false)]
public partial class Counter : UserControl

O exemplo a seguir mostra o código para o controle de usuário concluída.

using System;
using System.Windows.Forms;

namespace Counter
{
    [ProvideToolboxControl("General", false)]
    public partial class Counter : UserControl
    {
        public Counter()
        {
            InitializeComponent();
        }

        private void btnReset_Click(object sender, EventArgs e)
        {
            currentValue = 0;
            label1.Text = displayText + Value;
        }

        int currentValue;
        string displayText;

        public int Value {
            get { return currentValue; } 
            }

        public string Message {
            get { return displayText; }
            set { displayText = value; }
        }

        public bool ShowReset {
            get { return btnReset.Visible; }
            set { btnReset.Visible = value; }
        }

        private void ToolboxControl_Load(object sender, EventArgs e)
        {
            currentValue = 0;
            label1.Text = Message + Value;
        }

        public void Increment()
        {
            currentValue++;
            label1.Text = displayText + Value;
            Incremented(this, EventArgs.Empty);
        }

        public event EventHandler Incremented;
    }
}

Testando o controle

Para testar um caixa de ferramentas controle, primeiro testá-lo no ambiente de desenvolvimento e teste-o em um aplicativo compilado.

Para testar o controle

Pressione F5.

Isso cria o projeto e abre uma segunda instância do Visual Studio que tem o controle instalado.
Na nova instância de Visual Studio, crie um projeto Windows Forms.
Em Solution Explorer, clique duas vezes em Form1. cs para abri-lo no designer.
No caixa de ferramentas, o contador controle deve ser exibido na Geral seção.
Arraste um contador controle ao formulário e, em seguida, selecioná-lo. O Value, Message, e ShowReset propriedades serão exibidas na Propriedades janela, juntamente com as propriedades que são herdadas do UserControl.
Definir o Message propriedade para contagem:.
Arraste um Button o controle para o formulário e defina as propriedades de nome e o texto do botão de teste.
Clique duas vezes no botão para abrir Form1. cs no modo de exibição de código e criar um manipulador de cliques.
No manipulador click, ligue para counter1.Increment().
Na função do construtor, após a chamada para InitializeComponent, tipo Counter1.+ = De Incremented e pressione TAB duas vezes.

Visual Studio gera um manipulador de nível de formulário para o Counter1.Incremented evento.
Realce o Throw a instrução no manipulador de eventos, o tipo de mbox em, e pressione a tecla TAB duas vezes para gerar uma caixa de mensagem do trecho de código mbox em.
Na linha seguinte, adicione o seguinte if/else bloco para definir a visibilidade da Redefinir botão.
```
if (counter1.Value < 5) counter1.ShowReset = false;
else counter1.ShowReset = true;
```
Pressione F5.

O formulário é aberto. O contador controle exibe o texto a seguir.

Contagem: 0
Clique em teste.

O contador será incrementado e Visual Studio exibe uma caixa de mensagem.
Feche a caixa de mensagem.

O Redefinir botão desaparecerá.
Clique em teste até que o contador alcança 5e, em seguida, feche a caixa de mensagem.

O Redefinir re-appears de botão.
Clique em Redefinir.

O contador é redefinido como 0.

Próximas etapas

Quando você constrói uma caixa de ferramentas Visual Studio de controle, cria um arquivo chamado ProjectName.vsix na pasta \bin\debug\ do seu projeto. Você pode implantar o controle carregando o arquivo de .vsix a uma rede ou um site da Web. Quando um usuário abre o arquivo .vsix, o controle é instalado e adicionado ao Visual Studio caixa de ferramentas no computador do usuário. Como alternativa, você pode carregar o arquivo .vsix para o Galeria de Visual Studio site da empresa para que os usuários podem encontrar navegando no Extension Manager.

Consulte também

Compartilhar via