É muito comum quando se desenvolve um software, se deparar com a necessidade de algum componente específico que não existe nas ToolBoxs padrões do Visual Studio, mesmo sabendo que na Internet existe uma gama muito grande de componentes prontos, dentre esses alguns frees outros pagos. Porém, vem sempre a dúvida: e se utilizar esse componente e amanhã precisar migrar a aplicação para uma nova versão do Visual Studio, será que terá suporte? Sabemos que a Microsoft não se responsabiliza por componentes de terceiros e o desenvolvedor pode acabar ficando com um grande problema.
Com base nesse cenário, este artigo vai ensinar como criar um componente para que o desenvolvedor não tenha problemas de suporte, pois poderá alterá-los a qualquer momento para melhor atendê-lo.
Vamos utilizar o Visual Studio 2010 para implementação do componente, que é um validador de campos, ou seja, serve para validar os campos de um formulário. Porém, neste artigo validaremos apenas os componentes do tipo Textbox e Combobox.
O primeiro passo é abrir o visual Studio para criar um novo projeto. Acesse o menu File -> New -> Project, conforme Figura 1.
Na janela seguinte, digite “empty” na caixa de pesquisa e selecione BlankSolution. Altere a propriedade Name para SMFirstComponent ou para nome que preferir, conforme mostra a Figura 2.
Se olharmos no Solution Explorer veremos que foi criada uma solução vazia, então agora clique com o botão direito do mouse e escolha Add... e em seguida New Project.
Crie um projeto do Tipo Class Library e altere a propriedade Name para MyFirstComponent, conforme demonstrado nas Figuras 3 e 4.
Após criar o projeto Class Liberar, acesse o Solution Explorer e exclua o arquivo Class1, pois não iremos utilizá-lo. Ainda no Solution Explorer clique sobre o Projeto MyFirstComponet com o botão direito do Mouse e selecione Add New Item. Na nova janela selecione a opção Component Class e na Propriedade Name coloque ValidaObrigatorio, conforme ilustrado nas Figuras 5 e 6.
Note que temos um “container” do tipo do objeto. Aperte F7 para visualizarmos o código do componente. Aqui, iniciamos nossa implementação.
Adicione nas usings as namespaces System.ComponentModel, System.Collection e System.Windows.Forms, pois todas elas serão necessárias para as implementações do nosso componente. Lembrando que para última namespace será necessário acessar o Solution Explorer e com o botão direito clicar sobre o projeto e selecionar Add Reference; na tela seguinte é só localizar a System.Windows.Forms e cliclar em OK. Veja como ficou nas Figuras 7 e 8.
Nosso componente deverá herdar a classe ErrorProvider e também implementará a interface IExtenderProvider, conforme exibido na Listagem 1.
using System.ComponentModel;
namespace MyFirstComponente
{
public partial class ValidaObrigatorio : ErrorProvider,
IExtenderProvider
{
protected Hashtable _obrigatorio;
protected Hashtable _fraseerro;
protected Hashtable _indicecombo;
Como mostra na listagem acima, será necessário criar três propriedades: uma chamada _obrigatorio, outra _fraseerro, e por último uma chamada _indicecombo. Elas deverão ser do tipo Hashtable.
Precisamos instanciar nossas propriedades nos construtores da nossa classe para evitar erros durante a execução. Veja na Listagem 2.
public ValidaObrigatorio()
{
_obrigatorio = new Hashtable();
_fraseerro = new Hashtable();
_indicecombo = new Hashtable();
InitializeComponent();
}
public ValidaObrigatorio(IContainer container)
{
_obrigatorio = new Hashtable();
_fraseerro = new Hashtable();
_indicecombo = new Hashtable();
container.Add(this);
InitializeComponent();
}
Prosseguindo com nossa implementação, vamos criar três classes privadas chamadas ReturnObrigatorio, ReturnFrase e ReturnIndice, que serão responsáveis por armazenar o valores das propriedades, ou seja, são essas propriedades que definirão se o componente é um campo obrigatório e qual a mensagem será exibida para o usuário, e no caso do componente ComboBox a última propriedade será o índice que ele deve aceitar como vazio. Veja a criação na Listagem 3.
private partial class ReturnObrigatorio
{
public bool Obrigatorio;
public ReturnObrigatorio()
{
Obrigatorio = false;
}
}
private partial class ReturnFrase
{
public string FraseErro;
public ReturnFrase()
{
FraseErro = "";
}
}
private partial class ReturnIndice
{
public int IndiceCombo;
public ReturnIndice()
{
IndiceCombo = -1;
}
}
Após a implementação das nossas propriedades, vamos criar os métodos ObrigatorioExiste, FraseErroExiste e IndiceComboExiste. Veja a Listagem 4.
private ReturnObrigatorio ObrigatorioExiste(object key)
{
ReturnObrigatorio p = (ReturnObrigatorio)_obrigatorio[key];
if (p == null)
{
p = new ReturnObrigatorio();
_obrigatorio[key] = p;
}
return p;
}
private ReturnFrase FraseErroExiste(object key)
{
ReturnFrase e = (ReturnFrase)_fraseerro[key];
if (e == null)
{
e = new ReturnFrase();
_fraseerro[key] = e;
}
return e;
}
private ReturnIndice IndiceComboExiste(object key)
{
ReturnIndice e = (ReturnIndice)_indicecombo[key];
if (e == null)
{
e = new ReturnIndice();
_indicecombo[key] = e;
} return e;
}
Os métodos acima servem para garantir que as propriedades existem nos componentes. Se elas não existirem, os métodos criarão elas.
Agora precisamos criar três métodos get e três métodos set para que nossas propriedades possam ser alteradas nos componentes em que elas estarão presentes. Observe a Listagem 5.
public void SetObrigatorio(Control lControl, bool bValue)
{
ObrigatorioExiste(lControl).Obrigatorio = bValue;
}
public bool GetObrigatorio(Control lControl)
{
return ObrigatorioExiste(lControl).Obrigatorio;
}
public void SetFraseErro(Control lControl, string sValue)
{
FraseErroExiste(lControl).FraseErro = sValue;
}
public string GetFraseErro(Control lControl)
{
return FraseErroExiste(lControl).FraseErro;
}
public void SetIndiceCombo(Control lControl, int iValue)
{
IndiceComboExiste(lControl).IndiceCombo = iValue;
}
public int GetIndiceCombo(Control lControl)
{
return IndiceComboExiste(lControl).IndiceCombo;
}
Como estamos criando um componente para realizar a validação, agora precisamos criar um dos métodos mais importantes do nosso componente, que é o método Validar. É ele que será responsável por realizar a validação dos componentes contidos na tela. Na Listagem 6 você poderá ver o código.
public bool Validar()
{
bool bVer = true;
foreach (Control lControl in this.ContainerControl.Controls)
{
if (ObrigatorioExiste(lControl).Obrigatorio)
{
if (lControl is TextBox)
{
if (lControl.Text == "")
{
this.SetError(lControl,
FraseErroExiste(lControl).FraseErro);
bVer = false;
}
}
else if (lControl is ComboBox)
{
ComboBox ctl = (ComboBox)lControl;
if (ctl.SelectedIndex == -1)
{
this.SetError(lControl,
FraseErroExiste(lControl).FraseErro);
bVer = false;
}
}
}
}
return bVer;
}
No método acima, caso deseje, poderá criar as regras para os demais componentes, aqui estamos criando apenas para o Textbox e Combobox.
Agora vamos implementar o último método responsável por atribuir nossas propriedades aos componentes. Veja a Listagem 7.
bool IExtenderProvider.CanExtend(object lControl)
{
if ((lControl is TextBox) || (lControl is ComboBox))
{
return true;
}
else
{
return false;
}
}
Este método verifica o tipo do controle e, se for um textbox ou um combobox, ele retorna verdadeiro para que as propriedades sejam criadas.
É necessário adicionar os ProvideProperty nossa classe, sem isso nossas propriedades não são incluídas nos componentes. Observe a Listagem 8.
[ProvideProperty("FraseErro", typeof(Control))]
[ProvideProperty("Obrigatorio", typeof(Control))]
[ProvideProperty("IndiceCombo", typeof(Control))]
public partial class ValidaObrigatorio : ErrorProvider,
IExtenderProvider
Agora nosso componente está completo, bastando acessar o menu Build e clicar em Build Solution.
Instalando o Componente
Para que possamos utilizar nosso componente, precisamos instalá-lo, então para isso, abra o Visual Studio e crie um novo projeto Windows Form, conforme Figura 9.
Acesse a ToolBox e clique com o botão direito do mouse sobre ela e selecione a opção Choose Itens, conforme a Figura 10.
Na janela que irá se abrir, clique no botão Browse... e localize a pasta Debug que esta dentro da pasta Bin do seu projeto e selecione a dll. Marque o checkBox do componente e clique em OK.
Agora volte para seu Form e Inclua: um Componente TextBox, um ComboBox, um ValidaObrigatorio e um Button. Altere as propriedades Obrigatório para true e, a na propriedade frase erro escreva o retorno desejado, para o combo a propriedade indiceCombo deve ser alterada se você desejar que o índice a ser validado seja diferente de -1.
Agora de um duplo clique no Botão e no método criado insira o código da Listagem 9.
private void button1_Click(object sender, EventArgs e)
{
if (validaObrigatorio1.Validar())
{
//Codigo caso todos os campos Obrigatórios
//estejam preenchidos Corretamente
}
}
Agora é só rodar a aplicação, deixar os campos em branco e clicar no botão que você terá o resultado na Figura 13.
Ficamos por aqui com esse artigo espero que tenham gostado e até a próxima.
