ADO .NET - Acesso Assíncrono aos dados

ADO .NET - Acesso Assíncrono aos dados no .NET Core - I

Vamos rever os conceitos para realizar o acesso assíncrono aos dados usando a ADO .NET no ambiente .NET Core.

O acesso a um banco de dados é uma tarefa custosa pode afetar a sua aplicação e a interação com o usuário.

As classes da ADO.NET permite realizar a programação assíncrono baseada em tarefas, e oferece métodos assíncronos (além dos métodos síncronos). A partir do Microsoft .Net Framework 4.5 temos o suporte para realizar operações de bancos de dados assíncronos e isso também esta suportado no .NET Core.

Podemos assim usar os métodos assíncronos para maximizar a escalabilidade e a taxa de transferência dos dados tornando nossa aplicação mais rápida.

Para ilustrar abaixo temos um trecho de código que mostra como implementar uma operação assíncrona usando ADO .NET:

 using (SqlConnection connection = new SqlConnection(connectionString)
 {
            await connection.OpenAsync();
             //código...
            await reader.ReadAsync();
            //mais código...    
}

Observe a utilização dos métodos OpenAsycn e ReadAsync bem como o uso da palavra await.

Junto com a palavra await sempre usamos async para realizar uma tarefa ou Task. Vamos recordar como eles atuam:

1 - async

O modificador async indica que o método, a expressão lambda ou o método anônimo funcionarão de forma assíncrona;
Um método com o modificador async também é chamado de método assíncrono;
Um método assíncrono fornece uma maneira conveniente de realizar trabalhos potencialmente longos sem bloquear o encadeamento do chamador;
O chamador de um método assíncrono pode retomar seu trabalho sem esperar que o método assíncrono seja concluído;
Normalmente, um método modificado pela palavra-chave async contém pelo menos uma expressão ou instrução await;

2- await

Normalmente a palavra-chave await é usada para liberar uma thread;
O operador await é aplicado a uma tarefa em um método assíncrono para suspender a execução do método até que a tarefa aguardada seja concluída;
O método assíncrono no qual await é usado deve ser modificado pela palavra-chave async. Esse método, definido usando o modificador assíncrono e geralmente contendo uma ou mais expressões de espera, é chamado de método assíncrono;
A tarefa à qual o operador await é aplicado normalmente é o valor de retorno de uma chamada para um método que implementa;

3- Task

Os principais tipos são System.Threading.Tasks.Task;
Representa uma operação assíncrona que pode ser aguardada e cancelada;
System.Threading.Tasks.Task, que é uma tarefa que pode retornar um valor;

Vejamos a seguir um exemplo prático onde vamos acessar um banco de dados Cadastro.mdf do SQL Server e a tabela Livros cuja estrutura e dados vemos abaixo:

Criando o projeto .NET Core

Vamos criar um projeto .NET Core do tipo Console App(.NET Core) com o nome NetCore_AdoNetAsync.

A seguir precisamos referenciar os seguintes namespaces via Nuget:

System.Data.Common
System.Data.SqlClient

Para isso acesse o menu Tools -> Nuget Package Manager -> Manage Nuget Packages for Solution;

A seguir clique na guia Browse, digite o namespace desejado, selecione , e clique no botão Install;

Ao final o arquivo de projeto NetCore_AdoNetAsync.csproj deverá estar assim:

<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
     <LangVersion>7.2</LangVersion>
</PropertyGroup>

<ItemGroup>
<PackageReference Include="System.Data.Common" Version="4.3.0" />
<PackageReference Include="System.Data.SqlClient" Version="4.6.0" />
</ItemGroup>

</Project>

No arquivo Program.cs inclua os seguintes namespaces:

using System;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Data;
using static System.Console;

A seguir defina o seguinte método Main():

 public static async Task Main()
 {
       await LerDadosAsync();
       ReadLine();
 }

Para poder usar este método Main() você precisa estar usando no mínimo C# 7.1.

Agora defina o método LerDadosAsycn();

       public static async Task LerDadosAsync()
        {
            var connection = new SqlConnection(GetStringConexao());
            string sql = "SELECT LivroId, Titulo, Autor, DataLancamento FROM Livros";

            var command = new SqlCommand(sql, connection);

            await connection.OpenAsync();

            using (SqlDataReader reader = await command.ExecuteReaderAsync(CommandBehavior.CloseConnection))
            {
                while (await reader.ReadAsync())
                {
                    int id = reader.GetInt32(0);
                    string tituloLivro = reader.GetString(1);
                    string autorLivro = reader[2].ToString();
                    DateTime? lancamentoLivro = reader.IsDBNull(3) ? (DateTime?)null : reader.GetDateTime(3);

                    WriteLine($"{id,5}. {tituloLivro,-40} {autorLivro,-15} " + $"{lancamentoLivro:d}");
                }
            }
        }

       static string GetStringConexao()
       {
            return "Data Source=Macoratti;Initial Catalog=Cadastro;Integrated Security=True";
       }

Neste código estamos usando chamadas do método Async.

A conexão é aberta com SqlConnection.OpenAsync, o leitor é retornado do método SqlCommand.ExecuteReaderAsync; sendo que os registros são recuperados usando SqlDataReader.ReadAsync.

Nesta abordagem a thread de chamada não está bloqueada, mas pode fazer outra operação antes de obter o resultado.

O resultado é exibido abaixo:

Na segunda parte do artigo veremos como podemos criar métodos para obter e executar comandos assincronos.

Pegue o projeto aqui: NetCore_AdoNetAsync.zip

"Palavra fiel é esta: que, se morrermos com ele, também com ele viveremos;
Se sofrermos, também com ele reinaremos; se o negarmos, também ele nos negará;
Se formos infiéis, ele permanece fiel; não pode negar-se a si mesmo."
2 Timóteo 2:11-13