22 11 2017

O .NET normalmente faz um ótimo trabalho no que diz respeito ao gerenciamento de memória. Porém, um grave erro cometido pela maioria dos desenvolvedores que trabalham com essa plataforma é só se preocupar com a alocação de memória quando ela vira um problema (ou seja, quando a aplicação trava por falta de memória). Dois conceitos extremamente importantes relacionados à alocação e liberação de memória no .NET são o método Dispose e os blocos using. No vídeo de hoje eu explico para você a importância desses conceitos e como utilizá-los. Confira:

Alocação e liberação de memória no .NET

Apesar do Garbage Collector do .NET facilitar muito a nossa vida, nós temos que seguir alguns protocolos, senão ele não funcionará da maneira esperada. Basicamente, ao declararmos variáveis na nossa aplicação e atribuirmos um valor para elas, nós estamos alocando memória.

Quando falamos de variáveis simples (como strings, números, etc), nós não sentiremos praticamente nenhum impacto no consumo de memória, uma vez que a quantidade de memória utilizada por esses tipos de objeto é muito pequena. Porém, quando começamos a trabalhar com objetos mais complexos (por exemplo, ao carregarmos informações do banco de dados em uma DataTable), a alocação de memória pode começar a se transformar em um problema.

A alocação da memória é algo inevitável, afinal, temos que armazenar a informação em memória de um jeito ou de outro. Porém, mais importante do que a alocação é a liberação da memória quando não estamos mais utilizando as informações.

Normalmente nós não temos que nos preocupar com a liberação de memória no .NET, uma vez que o Garbage Collector faz um ótimo trabalho detectando as variáveis que não estão mais sendo utilizadas (ou seja, as que estão fora de escopo) e libera a memória automaticamente. Porém, em alguns casos o Garbage Collector não consegue detectar facilmente se uma variável realmente não está mais sendo utilizada. É aí que entra o método Dispose e os blocos using.

Exemplo clássico: carregamento de grid

Para testarmos a alocação e liberação de memória, criei uma aplicação Windows Forms muito simples, na qual teremos dois botões no formulário, além de um objeto do tipo DataGridView:

Um exemplo muito comum que encontraremos em praticamente qualquer aplicação que trabalhe com banco de dados é o carregamento de um grid com informações vindas do banco. Muito provavelmente você deve utilizar um código parecido com este para fazer esse tipo de carregamento:

// C#
lblCarregando.Visible = true;
Application.DoEvents();

var conn = new System.Data.SQLite.SQLiteConnection("Data Source=db.db;");
conn.Open();
var comm = new System.Data.SQLite.SQLiteCommand(conn);
comm.CommandText = "SELECT * FROM Tabela";
var dataTable = new DataTable();
var reader = comm.ExecuteReader();
dataTable.Load(reader);
dataGridView.DataSource = dataTable;

lblCarregando.Visible = false;

' VB.NET
LblCarregando.Visible = True
Application.DoEvents()

Dim Conn = New System.Data.SQLite.SQLiteConnection("Data Source=db.db;")
Conn.Open()
Dim Comm = New System.Data.SQLite.SQLiteCommand(Conn)
Comm.CommandText = "SELECT * FROM Tabela"
Dim DataTable = New DataTable()
Dim Reader = Comm.ExecuteReader()
DataTable.Load(Reader)
DataGridView.DataSource = dataTable

LblCarregando.Visible = False

O código acima funciona perfeitamente, carregando as informações do banco em uma DataTable e exibindo o seu conteúdo no DataGridView (configurando o DataSource). Porém, nós temos alguns problemas ao utilizarmos o código dessa maneira. O primeiro deles é que a conexão e o DataReader não foram fechados. Além disso, o que acontece se nós executarmos exatamente esse mesmo código múltiplas vezes (para atualizar as informações do grid, por exemplo)?

Ao executarmos esse método várias vezes, a memória da DataTable anterior não será liberada, o que causará um acúmulo na utilização de memória para a aplicação. Quando estamos carregando pouca informação no grid, nós nem sentiremos muito o impacto. Porém, se estivermos carregando uma quantidade considerável de informações (como as 1 milhão de linhas que temos na aplicação de exemplo), a memória do processo só subirá a cada chamada e, uma hora ou outra, a aplicação travará por falta de memória.

Interface IDisposable

No .NET nós temos uma interface chamada “IDisposable” que diz respeito à questão da liberação de recursos. Toda classe que aloca memória com recursos não gerenciados (ou que utiliza recursos que devem ser corretamente fechados) deve implementar essa interface, onde os recursos deverão ser liberados na implementação do método “Dispose“.

Quando desenvolvemos as nossas classes, dificilmente nós teremos que nos preocupar em implementar essa interface nos tipos da nossa aplicação. Porém, inúmeras classes do .NET implementam essa interface, e quando nós utilizamos essas classes, nós temos que chamar o método Dispose por dois motivos.

O primeiro motivo é que só assim a memória alocada para os recursos não gerenciados será liberada. Já o segundo motivo é que, ao chamarmos o método Dispose de um objeto que implementa essa interface, ele ficará mais visível para que o Garbage Collector libere a memória alocada por ele.

Para saber se uma classe implementa a interface IDisposable, navegue pela definição dela (clicando no nome da classe e apertando a tecla F12) e tente encontra-la em algum nível da hierarquia. Se você encontrar, isso significa que você deve chamar o método Dispose dos objetos desse tipo (ou deve declará-los com um bloco using). Esse é o caso da maioria das classes do ADO.NET (por exemplo, DbConnection, DbCommand, DbDataReader, etc).

Melhorando o código com blocos using

A primeira coisa que temos que ajustar no código apresentado anteriormente é chamarmos o método Dispose dos objetos do ADO.NET (Connection, Command, DataReader, etc) quando não precisamos mais deles (ou seja, no final do carregamento). Nós poderíamos simplesmente chamar o método Dispose manualmente na última linha do método, porém, nós podemos fazer isso de uma maneira mais elegante utilizando blocos using.

Quando declaramos uma variável utilizando um bloco using, nós estamos implicitamente declarando que ela só estará sendo utilizada dentro daquele bloco. O .NET chamará automaticamente o método Dispose desses objetos uma vez que o bloco using for finalizado. Veja como é que ficaria uma versão melhorada do acesso a dados do nosso exemplo, utilizando blocos using para declarar as variáveis relacionadas ao ADO.NET:

            // C#
            using (var conn = new System.Data.SQLite.SQLiteConnection("Data Source=db.db;"))
            {
                conn.Open();

                using (var comm = new System.Data.SQLite.SQLiteCommand(conn))
                {
                    comm.CommandText = "SELECT * FROM Tabela";
                    var dataTable = new DataTable();
                    using (var reader = comm.ExecuteReader())
                    {
                        dataTable.Load(reader);
                    }
                    dataGridView.DataSource = dataTable;
                }
            }

        ' VB.NET
        Using Conn = New System.Data.SQLite.SQLiteConnection("Data Source=db.db;")
            Conn.Open()

            Using Comm = New System.Data.SQLite.SQLiteCommand(Conn)
                Comm.CommandText = "SELECT * FROM Tabela"
                Dim DataTable = New DataTable()
                Using Reader = Comm.ExecuteReader()
                    DataTable.Load(Reader)
                End Using
                DataGridView.DataSource = dataTable
            End Using
        End Using

Esse código já é bem melhor do que o anterior, uma vez que nós estamos descartando todos os objetos do ADO.NET que foram utilizados no processo de aquisição dos dados. Por exemplo, nessa segunda versão a conexão e o DataReader serão fechados automaticamente uma vez que os blocos using respectivos forem finalizados.

Entretanto, somente essa alteração no código não bastará para que a memória das DataTables anteriores seja descartada mais rapidamente. Uma segunda melhoria no código seria fazermos um Clear e um Dispose na DataTable que estava servindo de DataSource do grid no ciclo anterior. Fazemos isso através do seguinte código (que você deve adicionar antes de carregar os dados novamente do banco):

            // C#
            var dataSourceAnterior = dataGridView.DataSource as IDisposable;
            var dataTableAnterior = dataGridView.DataSource as DataTable;
            dataGridView.DataSource = null;
            if (dataSourceAnterior != null)
            {
                dataSourceAnterior.Dispose();
            }
            if (dataTableAnterior != null)
            {
                dataTableAnterior.Clear();
            }

        ' VB.NET
        Dim DataSourceAnterior = TryCast(DataGridView.DataSource, IDisposable)
        Dim DataTableAnterior = TryCast(DataGridView.DataSource, DataTable)
        DataGridView.DataSource = Nothing
        If DataSourceAnterior IsNot Nothing Then
            DataSourceAnterior.Dispose()
        End If
        If dataTableAnterior IsNot Nothing Then
            dataTableAnterior.Clear()
        End If

Agora sim. Com essas alterações, mesmo se clicarmos no botão para carregarmos os dados diversas vezes, a memória utilizada pelos dados anteriores será descartada pelo Garbage Collector.

Segundo exemplo: exibição de formulários

Um segundo exemplo clássico é a exibição de formulários. Se você der uma olhada na classe “Form“, você verá que em algum nível da hierarquia ela herda de IDisposable. Ou seja, nós devemos chamar o método Dispose de um formulário ou devemos utilizá-la dentro de um bloco using (apesar que esse método é chamado automaticamente na maioria dos casos quando executamos o método Close).

Veja um exemplo de chamada de formulário sem a utilização de bloco using:

// C#
for (int c = 0; c < 5; c++)
{
	var form = new Form2();
	form.Show();
	form.Close();
}

' VB.NET
For C As Integer = 0 To 4
	Dim Form = New Form2()
	Form.Show()
	Form.Close()
Next

Esse código simplesmente abre e fecha 5 vezes um formulário qualquer (que no nosso projeto de exemplo carrega um grid com 500 mil linhas). Apesar de não fazer nenhum efeito direto (porque estamos chamando o método Close que automaticamente chamará o Dispose), o código fica mais “correto” se declararmos o formulário dentro de um bloco using:

            // C#
            for (int c = 0; c < 5; c++)
            {
                using (var form = new Form2())
                {
                    form.Show();
                    form.Close();
                }
            }

        ' VB.NET
        For C As Integer = 0 To 4
            Using Form = New Form2()
                Form.Show()
                Form.Close()
            End Using
        Next

Além disso, é importante descartarmos recursos não utilizados (por exemplo, a DataTable que serviu de fonte de dados para o grid) no método Dispose do formulário. No C# você encontra esse método dentro do arquivo de designer do formulário:

Já no VB.NET, você encontra esse método expandindo o nome do formulário:

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

Apesar do .NET fazer um ótimo trabalho quanto à alocação e liberação automática de memória, é importante que nós lembremos de chamar o método Dispose em objetos que implementam a interface IDisposable. Dessa forma, além de descartarmos recursos não gerenciados que tiverem sido utilizados pela instância, nós estaremos também implicitamente dizendo ao Garbage Collector que nós não estamos mais utilizando aquele objeto, o que fará com que ele seja descartado da memória mais rapidamente.

Você já conhecia essa interface? Sabia da existência dos blocos using para facilitar a utilização de objetos desse tipo? Fico aguardando os seus comentários logo abaixo!

Até a próxima!

André Lima

Photo by Pixabay used under Creative Commons
https://pixabay.com/en/startup-start-up-notebooks-creative-593327/

Photo by Pixabay used under Creative Commons
https://pixabay.com/en/printed-circuit-board-memory-green-1911693/

Song Rocket Power Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0 License
http://creativecommons.org/licenses/by/3.0/

Exemplo de CRUD no WPF com MVVM Aplicações Android com Xamarin – parte 7 de N – SQLite no Xamarin Android