Em 17/05/2017.
Trocar informações entre formulários é uma necessidade que, sem dúvida, todo programador precisará implementar nas suas aplicações uma hora ou outra. Esse é um aprendizado bem básico, mas que muita gente que está começando fica com dúvida e acaba implementando da pior maneira possível. Pensando nisso, eu resolvi gravar um vídeo bem curto e direto ao ponto, mostrando como enviar parâmetros de um formulário para o outro.
No vídeo eu utilizo um projeto Windows Forms, mas você pode utilizar o mesmo conceito no WPF, caso você não esteja trabalhando com a arquitetura MVVM. Confira o vídeo:
O projeto de exemplo
Nesse vídeo eu utilizei um projeto bem simples, uma vez que o único objetivo era mostrar como podemos fazer a troca de informações entre formulários. No formulário principal (Form1), temos dois TextBoxes e um botão:
A ideia é que, ao clicarmos no botão “Abrir Form2“, nós abriremos o segundo formulário da aplicação. Esse segundo formulário deverá receber o conteúdo que estiver digitado no TextBox “Parâmetro” do primeiro formulário.
No segundo formulário nós temos um TextBox e um botão:
Ao clicarmos no botão “Fechar” do segundo formulário, o conteúdo que estiver digitado no TextBox “Parâmetro” deve ser retornado para o primeiro formulário, mais especificamente no TextBox “Retorno“.
Parâmetros via construtor
A primeira possibilidade que podemos utilizar para enviarmos informações do primeiro formulário para o segundo formulário é através do construtor. Por padrão, os formulários só possuem um construtor padrão que não recebe nenhum parâmetro. Porém, nós podemos criar um segundo construtor no Form2. Esse construtor herdará do construtor principal, porém ele receberá uma string como parâmetro e utilizará o seu valor para preencher o TextBox:
1
2
3
4
5
| // C#public Form2(string parametro) : this(){ textBoxParametro.Text = parametro;} |
1
2
3
4
5
6
7
8
9
| ' VB.NETPublic Sub New() InitializeComponent()End SubPublic Sub New(Parametro As String) Me.New() TextBoxParametro.Text = ParametroEnd Sub |
Nota: no C#, não esqueça de herdar do construtor padrão, adicionando a chamada a “this()” na sua assinatura. Já no VB.NET, não esqueça de implementar manualmente o construtor padrão, que fará a chamada ao método “InitializeComponent”, que efetivamente adicionará os controles no formulário.
Com o construtor criado, nós podemos passar o valor do TextBox do primeiro formulário para o segundo formulário:
1
2
3
4
5
6
7
8
| // C#private void buttonAbrirForm2_Click(object sender, EventArgs e){ using (var form2 = new Form2(textBoxParametro.Text)) { form2.ShowDialog(); }} |
1
2
3
4
5
6
| ' VB.NETPrivate Sub ButtonAbrirForm2_Click(sender As Object, e As EventArgs) Handles ButtonAbrirForm2.Click Using Form2 As New Form2(TextBoxParametro.Text) Form2.ShowDialog() End UsingEnd Sub |
Parâmetros via propriedade
Como pudemos ver acima, nós podemos passar informações do primeiro formulário para o segundo formulário através de parâmetros no construtor. Porém, para passarmos valores de volta do segundo formulário para o formulário principal, não dá para utilizarmos o construtor. Nesse caso, nós temos que criar uma propriedade no Form2 que dará acesso ao texto do TextBox:
1
2
3
4
5
| // C#public string Parametro{ get { return textBoxParametro.Text; }} |
1
2
3
4
5
6
| ' VB.NETPublic ReadOnly Property Parametro As String Get Return TextBoxParametro.Text End GetEnd Property |
Feito isso, nós conseguimos acessar o valor de retorno no primeiro formulário:
1
2
3
4
5
6
7
8
9
| // C#private void buttonAbrirForm2_Click(object sender, EventArgs e){ using (var form2 = new Form2(textBoxParametro.Text)) { form2.ShowDialog(); textBoxRetorno.Text = form2.Parametro; }} |
1
2
3
4
5
6
7
| ' VB.NETPrivate Sub ButtonAbrirForm2_Click(sender As Object, e As EventArgs) Handles ButtonAbrirForm2.Click Using Form2 As New Form2(TextBoxParametro.Text) Form2.ShowDialog() TextBoxRetorno.Text = Form2.Parametro End UsingEnd Sub |
E com isso nós temos a troca completa de informações, tanto o envio de informações do Form1 para o Form2 quanto o retorno das informações do Form2 para o Form1.
Uma melhoria extra que podemos fazer nesse exemplo é adicionarmos um “setter” à nossa propriedade. Do jeito que o código está até agora, nós só conseguimos ler o valor da propriedade (ela é readonly). Se implementarmos um “setter” nessa propriedade, nós podemos trabalhar exclusivamente com ela na troca de informações, eliminando a necessidade de criarmos o construtor customizado:
1
2
3
4
5
6
| // C#public string Parametro{ get { return textBoxParametro.Text; } set { textBoxParametro.Text = value; }} |
1
2
3
4
5
6
7
8
9
| ' VB.NETPublic Property Parametro As String Get Return TextBoxParametro.Text End Get Set(value As String) TextBoxParametro.Text = value End SetEnd Property |
Em seguida, na criação do Form2, nós podemos utilizar a propriedade tanto para enviar o parâmetro como para receber o retorno:
1
2
3
4
5
6
7
8
9
10
| // C#private void buttonAbrirForm2_Click(object sender, EventArgs e){ using (var form2 = new Form2()) { form2.Parametro = textBoxParametro.Text; form2.ShowDialog(); textBoxRetorno.Text = form2.Parametro; }} |
1
2
3
4
5
6
7
8
| ' VB.NETPrivate Sub ButtonAbrirForm2_Click(sender As Object, e As EventArgs) Handles ButtonAbrirForm2.Click Using Form2 As New Form2() Form2.Parametro = TextBoxParametro.Text Form2.ShowDialog() TextBoxRetorno.Text = Form2.Parametro End UsingEnd Sub |
Não faça isso!
Infelizmente, a pior implementação da trocar informações entre formulários ainda é muito utilizada por aí, que é a alteração do modificador de visibilidade dos controles para “público“. Essa modalidade é muito utilizada porque ela é extremamente fácil de ser implementada. Basta alterar uma propriedade do controle e pronto, teremos acesso irrestrito a todas as suas propriedades:
No vídeo eu mostro um exemplo concreto dos problemas que essa alternativa pode trazer para os nossos projetos. Ao alterarmos o modificador de visibilidade para “público“, nós teremos acesso irrestrito ao controle todo, e não somente à propriedade “Text“. Dessa maneira, nós podemos esconder ou remover o controle do segundo formulário, ou até mesmo alterar completamente o seu comportamento. Obviamente, essa não é uma boa prática, portanto, evite utilizá-la.
Concluindo
No vídeo de hoje você conferiu duas maneiras que podemos utilizar nos nossos projetos Windows Forms e WPF para trocarmos informações entre formulários. A primeira delas é através de parâmetros no construtor. Já a segunda alternativa é utilizarmos propriedades.
Através de parâmetros no construtor nós conseguimos enviar informações em um único sentido (do formulário chamador para o formulário receptor). Por outro lado, ao utilizarmos propriedades, nós conseguimos trocar informações nos dois sentidos.
E você, acredito que já precisou trocar informações entre formulários, não é mesmo? Qual dessas duas alternativas você utilizou? Ou você acabou implementando de alguma outra maneira? Conte-nos mais detalhes na caixa de comentários logo abaixo!
Baixe o projeto de exemplo
Para baixar o projeto de exemplo desse artigo, assine a minha newsletter. Ao fazer isso, além de ter acesso ao projeto, você receberá um e-mail toda semana sobre o artigo publicado e ficará sabendo também em primeira mão sobre o artigo da próxima semana, além de receber dicas “bônus” que eu só compartilho por e-mail. Inscreva-se utilizando o formulário no final do artigo.
Até a próxima!
André Lima
Nenhum comentário:
Postar um comentário