26 07 2017

Eu sei que WPF é a plataforma de desenvolvimento de aplicações desktop mais nova da Microsoft e que o Windows Forms já está aposentado. Entretanto, algumas pessoas podem discordar disso, mas, eu acho que em diversas situações faz mais sentido utilizar o Windows Forms se você já tiver experiência com ele. Porém, o objetivo desse artigo não é fazer uma comparação entre WPF e Windows Forms (eu já escrevi sobre isso uns tempos atrás). O que eu quero realmente mostrar no artigo de hoje é o sistema de data binding no Windows Forms.

Uma vez que é um fato que muitos desenvolvedores ainda trabalham com Windows Forms, é muito importante aprender a trabalhar com essa plataforma da melhor maneira possível. Eu já vi inúmeros desenvolvedores que ficam copiando manualmente dados de controles para classes de dados, ou desenvolvem lógica para ativar ou desativar controles utilizando eventos. Saiba que existe uma maneira muito mais fácil e limpa de implementar esse tipo de funcionalidade. É justamente com a ajuda do data binding que a sua vida vai ficar muito mais tranquila ao desenvolver qualquer tipo de aplicação, seja ela Windows Forms, WPF, Xamarin, UWP, etc.

Quer aprender como funciona o esquema de data binding no Windows Forms? Então vamos lá!

Data binding entre controles

Uma das coisas que podemos implementar com data binding no Windows Forms é a troca de informações entre controles. Nós podemos ligar qualquer propriedade de um controle com qualquer propriedade de outro controle. Por exemplo, imagine que você tenha que habilitar ou desabilitar um botão dependendo do estado de um CheckBox:

Como é que muita gente resolve esse problema? Implementando essa lógica no evento “CheckStateChanged” do CheckBox! Se você implementaria dessa forma, para tudo! Com uma linha de código nós conseguimos fazer uma ligação entre a propriedade “Enabled” do TextBox e a propriedade “Checked” do CheckBox:

            // C#
            btExemplo.DataBindings.Add("Enabled", checkBoxHabilitado, "Checked");

        ' VB.NET
        BtExemplo.DataBindings.Add("Enabled", CheckBoxHabilitado, "Checked")

Veja só o efeito produzido por essa simples linha de código:

Como você pode perceber, data binding entre propriedades de controles é algo muito tranquilo de ser implementado no Windows Forms. Basta acessarmos a propriedade “DataBindings” do controle destino (no nosso caso, o botão) e então chamamos o método “Add” para adicionarmos uma nova ligação (nós podemos ter várias ligações no mesmo controle, utilizando propriedades diferentes).

Os parâmetros para o método “Add” são: a propriedade que receberá o valor no controle destino (no nosso caso, a propriedade “Enabled” do botão), o controle de origem (no nosso caso, o CheckBox) e a propriedade no controle de origem (no nosso caso, a propriedade “Checked” do CheckBox).

Viu só que fácil? Imagine se nós tivéssemos também alguns TextBoxes na tela. Nós poderíamos fazer outros data bindings com a propriedade “Text“, por exemplo:

            // C#
            btExemplo.DataBindings.Add("Text", tbExemplo, "Text");
            tbExemplo.DataBindings.Add("Text", tbExemplo2, "Text");
            tbExemplo2.DataBindings.Add("Text", tbExemplo, "Text");

        ' VB.NET
        BtExemplo.DataBindings.Add("Text", TbExemplo, "Text")
        TbExemplo.DataBindings.Add("Text", TbExemplo2, "Text")
        TbExemplo2.DataBindings.Add("Text", TbExemplo, "Text")

E com essas poucas linhas de código, nós temos esse efeito:

Data binding no DataGridView

Outro exemplo clássico de data binding no Windows Forms é com o controle DataGridView. Nós podemos alimentar o controle de grid com uma coleção de objetos ou com uma DataTable. Para demonstrar essa funcionalidade, vamos adicionar uma nova classe no nosso projeto, dando o nome de “Produto“:

    // C#
    public class Produto
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public decimal ValorUnitario { get; set; }
    }

' VB.NET
Public Class Produto
    Public Property Id As Integer
    Public Property Nome As String
    Public Property ValorUnitario As Decimal
End Class

Em seguida, vamos adicionar as colunas correspondentes no DataGridView:

Atenção! Não esqueça de configurar a propriedade “DataPropertyName” de cada coluna do grid, de modo que elas apontem para a propriedade correspondente da nossa classe:

Feito isso, vamos adicionar uma lista de Produtos no nível do formulário:

        // C#
        private List<Produto> _produtos = new List<Produto>();

' VB.NET
Private Produtos As New List(Of Produto)

Com a lista instanciada, vamos adicionar alguns produtos dentro dela e, em seguida, alimentamos o grid com essa lista através da propriedade “DataSource“:

            // C#
            _produtos.Add(new Produto() { Id = 1, Nome = "Produto 1", ValorUnitario = 1.23m });
            _produtos.Add(new Produto() { Id = 2, Nome = "Produto 2", ValorUnitario = 4.56m });
            _produtos.Add(new Produto() { Id = 3, Nome = "Produto 3", ValorUnitario = 7.89m });

            dgvProdutos.DataSource = _produtos;

        ' VB.NET
        Produtos.Add(New Produto() With {.Id = 1, .Nome = "Produto 1", .ValorUnitario = 1.23})
        Produtos.Add(New Produto() With {.Id = 2, .Nome = "Produto 2", .ValorUnitario = 4.56})
        Produtos.Add(New Produto() With {.Id = 3, .Nome = "Produto 3", .ValorUnitario = 7.89})

        DgvProdutos.DataSource = Produtos

Ao executarmos a aplicação, aparentemente tudo funcionou corretamente:

Mas, será que tudo está funcionando mesmo? O que será que aconteceria se nós adicionássemos um novo produto na lista em tempo de execução? Vamos testar?

Para checarmos esse cenário, vamos implementar uma lógica para o evento “Click” do nosso botão. Quando o botão for clicado, nós vamos alterar o texto do primeiro produto da lista utilizando o conteúdo digitado no TextBox e, além disso, nós adicionaremos um novo produto utilizando um ID sequencial:

        // C#
        private int _ultimoId = 3;
        private void btExemplo_Click(object sender, EventArgs e)
        {
            _produtos[0].Nome = tbExemplo.Text;
            _produtos.Add(new Produto() { Id = ++_ultimoId, Nome = _ultimoId.ToString(), ValorUnitario = _ultimoId });
        }

    ' VB.NET
    Private UltimoId = 3
    Private Sub BtExemplo_Click(sender As Object, e As EventArgs) Handles BtExemplo.Click
        Produtos(0).Nome = TbExemplo.Text
        UltimoId += 1
        Produtos.Add(New Produto() With {.Id = UltimoId, .Nome = UltimoId.ToString(), .ValorUnitario = UltimoId})
    End Sub

Se testarmos essa implementação, veremos que o novo produto não será exibido no grid e, além disso, temos um comportamento bem estranho quanto à alteração do texto no primeiro produto. O grid só entende que ele foi modificado depois de navegarmos para outra linha:

Por que tivemos esse efeito? E como é que podemos resolve-lo?

A classe BindingList

O primeiro problema na nossa implementação é o fato de termos utilizado a classe “List” para criarmos a nossa coleção de produtos. A classe “List” não foi desenvolvida com o intuito de ser utilizada em data binding. Porém, não se preocupe. Para isso nós temos a classe “BindingList“, que é justamente uma “List” que suporta data binding!

Se trocarmos a declaração da nossa coleção de produtos por uma BindingList, nós teremos um resultado um pouco melhor:

        // C#
        private System.ComponentModel.BindingList<Produto> _produtos = new System.ComponentModel.BindingList<Produto>();

' VB.NET
Private Produtos As New System.ComponentModel.BindingList(Of Produto)

Veja que o texto do primeiro produto foi alterado de imediato. Além disso, o novo produto que inserimos na lista em tempo de execução também foi exibido com sucesso. Porém, nós ainda temos um probleminha a ser resolvido. Se nós continuarmos inserindo novas linhas no grid, chega uma hora em que o grid para de atualizar o nome do primeiro produto:

Isso acontece porque a nossa classe “Produto” não implementa a interface “INofifyPropertyChanged“.

A interface INotifyPropertyChanged

A interface INotifyPropertyChanged é utilizada para que o mecanismo de data binding seja notificado quando o valor de uma propriedade for alterado. Nas classes internas do .NET (nos controles do Windows Forms, por exemplo), isso tudo já está implementado nativamente. Porém, se criarmos novas classes no nosso projeto (como foi o caso da classe “Produto” que criamos nesse exemplo), nós temos que implementar essa interface caso a classe venha a ser utilizada em algum data binding.

Essa não é uma particularidade do Windows Forms. Muito pelo contrário, essa interface é essencial também no famoso data binding do WPF. Se não implementarmos essa interface nas nossas classes, nós teremos esse mesmo problema no WPF.

Uns tempos atrás eu escrevi um artigo falando das interfaces de notificação de alteração no WPF. Hoje eu só vou mostrar como implementá-las nesse exemplo, e não vou entrar em muitos detalhes sobre elas. Caso você queira aprender mais sobre esse assunto, confira o artigo que eu acabei de mencionar.

A implementação da interface INotifyPropertyChanged é muito tranquila. Nós só temos que disparar o evento “NotifyPropertyChanged” em todos os “setters” das nossas propriedades (que agora não poderão ser auto-implementadas):

    // C#
    public class Produto : System.ComponentModel.INotifyPropertyChanged
    {
        private int _id;
        public int Id
        {
            get { return _id; }
            set 
            { 
                _id = value;
                OnPropertyChanged("Id");
            }
        }
        private string _nome;
        public string Nome
        {
            get { return _nome; }
            set 
            { 
                _nome = value;
                OnPropertyChanged("Nome");
            }
        }
        private decimal _valorUnitario;
        public decimal ValorUnitario
        {
            get { return _valorUnitario; }
            set 
            { 
                _valorUnitario = value;
                OnPropertyChanged("ValorUnitario");
            }
        }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
            }
        }
    }

' VB.NET
Public Class Produto
    Implements System.ComponentModel.INotifyPropertyChanged

    Private _id As Integer
    Public Property Id As Integer
        Get
            Return _id
        End Get
        Set(value As Integer)
            _id = value
            OnPropertyChanged("Id")
        End Set
    End Property

    Private _nome As String
    Public Property Nome As String
        Get
            Return _nome
        End Get
        Set(value As String)
            _nome = value
            OnPropertyChanged("Nome")
        End Set
    End Property

    Private _valorUnitario As Decimal
    Public Property ValorUnitario As Decimal
        Get
            Return _valorUnitario
        End Get
        Set(value As Decimal)
            _valorUnitario = value
            OnPropertyChanged("ValorUnitario")
        End Set
    End Property

    Public Event PropertyChanged As System.ComponentModel.PropertyChangedEventHandler Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
    Private Sub OnPropertyChanged(ByVal PropertyName As String)
        RaiseEvent PropertyChanged(Me, New System.ComponentModel.PropertyChangedEventArgs(PropertyName))
    End Sub
End Class

Se testarmos o comportamento do grid mais uma vez depois dessa alteração, nós veremos que agora ele se comportará corretamente:

Como você deve ter notado, a implementação da interface INotifyPropertyChanged pode acabar sendo um pouco “maçante“. Imagine termos que implementar todo esse código em todas as nossas classes de modelo? Vai dar um certo trabalho. É pensando nisso que a Microsoft vem investindo em novas funcionalidades no C# e VB.NET para facilitar a nossa vida. Eu já escrevi uns tempos atrás sobre o atributo CallerMemberName, que facilita um pouco esse processo. Se pesquisarmos na internet, encontraremos maneiras mais fáceis de implementarmos essa interface, como esta que eu encontrei no StackOverflow:

    // C#
    public class Produto : System.ComponentModel.INotifyPropertyChanged
    {
        private int _id;
        public int Id
        {
            get { return _id; }
            set { SetField(ref _id, value); }
        }
        private string _nome;
        public string Nome
        {
            get { return _nome; }
            set { SetField(ref _nome, value); }
        }
        private decimal _valorUnitario;
        public decimal ValorUnitario
        {
            get { return _valorUnitario; }
            set { SetField(ref _valorUnitario, value); }
        }

        protected bool SetField<T>(ref T field, T value, [System.Runtime.CompilerServices.CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(field, value))
                return false;
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
            }
        }
    }

' VB.NET
Public Class Produto
    Implements System.ComponentModel.INotifyPropertyChanged

    Private _id As Integer
    Public Property Id As Integer
        Get
            Return _id
        End Get
        Set(value As Integer)
            SetField(_id, value)
        End Set
    End Property

    Private _nome As String
    Public Property Nome As String
        Get
            Return _nome
        End Get
        Set(value As String)
            SetField(_nome, value)
        End Set
    End Property

    Private _valorUnitario As Decimal
    Public Property ValorUnitario As Decimal
        Get
            Return _valorUnitario
        End Get
        Set(value As Decimal)
            SetField(_valorUnitario, value)
        End Set
    End Property

    Protected Function SetField(Of T)(ByRef field As T, value As T, <System.Runtime.CompilerServices.CallerMemberName> Optional propertyName As String = Nothing) As Boolean
        If EqualityComparer(Of T).[Default].Equals(field, value) Then
            Return False
        End If
        field = value
        OnPropertyChanged(propertyName)
        Return True
    End Function

    Public Event PropertyChanged As System.ComponentModel.PropertyChangedEventHandler Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
    Private Sub OnPropertyChanged(ByVal PropertyName As String)
        RaiseEvent PropertyChanged(Me, New System.ComponentModel.PropertyChangedEventArgs(PropertyName))
    End Sub
End Class

Sincronia entre DataGridView e outros controles

Algo muito mágico que nós recebemos “de brinde” ao utilizarmos data binding no Windows Forms é ligação entre o registro selecionado no grid e outros controles que estejam ligados com a mesma coleção. Para entendermos como isso funciona, vamos adicionar três TextBoxes na nossa janela. Cada TextBox representará uma propriedade da nossa classe “Produto“:

Se adicionarmos um data binding em cada um dos TextBoxes, ligando a propriedade “Text” deles com a propriedade correspondente da coleção de produtos, veja só a “mágica” que acontece automaticamente:

            // C#
            tbId.DataBindings.Add("Text", _produtos, "Id");
            tbNome.DataBindings.Add("Text", _produtos, "Nome");
            tbValorUnitario.DataBindings.Add("Text", _produtos, "ValorUnitario");

        ' VB.NET
        TbId.DataBindings.Add("Text", Produtos, "Id")
        TbNome.DataBindings.Add("Text", Produtos, "Nome")
        TbValorUnitario.DataBindings.Add("Text", Produtos, "ValorUnitario")

Com DataSet e DataTable você não precisa de INotifyPropertyChanged

Como mencionei anteriormente, os controles do Windows Forms já implementam a interface INotifyPropertyChanged nativamente. Isso também acontece com diversas outras classes do .NET Framework, como, por exemplo, DataSet e DataTable. Para verificarmos se isso é realmente verdadeiro, vamos adicionar uma DataTable no nosso formulário:

    // C#
    private DataTable _produtosDT = new DataTable();

' VB.NET
Private ProdutosDT As New DataTable()

Em seguida, vamos substituir a nossa implementação, de forma que os data bindings considerem a DataTable (e não a coleção de produtos):

            // C#
            _produtosDT.Columns.Add("Id", typeof(int));
            _produtosDT.Columns.Add("Nome");
            _produtosDT.Columns.Add("ValorUnitario", typeof(decimal));

            _produtosDT.Rows.Add(1, "Produto 1", 1.23m);
            _produtosDT.Rows.Add(2, "Produto 2", 4.56m);
            _produtosDT.Rows.Add(3, "Produto 3", 7.89m);

            dgvProdutos.DataSource = _produtosDT;

            tbId.DataBindings.Add("Text", _produtosDT, "Id");
            tbNome.DataBindings.Add("Text", _produtosDT, "Nome");
            tbValorUnitario.DataBindings.Add("Text", _produtosDT, "ValorUnitario");

        ' VB.NET
        ProdutosDT.Columns.Add("Id", GetType(Integer))
        ProdutosDT.Columns.Add("Nome")
        ProdutosDT.Columns.Add("ValorUnitario", GetType(Decimal))

        ProdutosDT.Rows.Add(1, "Produto 1", 1.23)
        ProdutosDT.Rows.Add(2, "Produto 2", 4.56)
        ProdutosDT.Rows.Add(3, "Produto 3", 7.89)

        DgvProdutos.DataSource = ProdutosDT

        TbId.DataBindings.Add("Text", ProdutosDT, "Id")
        TbNome.DataBindings.Add("Text", ProdutosDT, "Nome")
        TbValorUnitario.DataBindings.Add("Text", ProdutosDT, "ValorUnitario")

Não esqueça também de alterar o código do clique do botão!

        // C#
        private void btExemplo_Click(object sender, EventArgs e)
        {
            _produtosDT.Rows[0]["Nome"] = tbExemplo.Text;
            _produtosDT.Rows.Add(++_ultimoId, _ultimoId.ToString(), _ultimoId);
        }

    ' VB.NET
    Private Sub BtExemplo_Click(sender As Object, e As EventArgs) Handles BtExemplo.Click
        ProdutosDT.Rows(0)("Nome") = TbExemplo.Text
        UltimoId += 1
        ProdutosDT.Rows.Add(UltimoId, UltimoId.ToString(), UltimoId)
    End Sub

Execute a aplicação e observe que o efeito será exatamente o mesmo que tivemos com a nossa coleção de produtos.

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.

Concluindo

O data binding no Windows Forms é um conceito que eu infelizmente vejo pouquíssimas pessoas utilizando. Eu verdadeiramente espero que os desenvolvedores optem por não utilizar data binding simplesmente por falta de conhecimento. Como você pode perceber, tem muita coisa que pode ser resolvida com pouquíssimas linhas de código utilizando data binding que levariam dezenas e dezenas de linhas sem a sua utilização.

Você já conhecia tudo isso que eu apresentei aqui nesse artigo? Se sim, conte mais sobre as suas experiências nos comentários. E se você não tinha conhecimento sobre o funcionamento do data binding no Windows Forms, agora não tem mais desculpa. Pare de ficar implementando código manual para copiar informações de controles em classes de dados, utilize data binding e o seu código ficará muito mais limpo!

Até a próxima!

André Lima

Image by Pixabay used under Creative Commons
https://pixabay.com/en/chain-metal-chain-link-257490/

Configurando o idioma do Report Viewer Imprimindo direto na impressora com o Report Viewer