C# -  Dapper básico (revisitado) via Console

 Neste artigo vamos rever os conceitos básicos sobre o Dapper um micro ORM que pode ser usado em aplicações menos complexas.

Se você não gosta de ORMs ou se o seu projeto não justifica a utilização de um ORM como o Entity Framework, o Dapper pode vir a calhar para você.

Por que então não dar uma chance ao Dapper conhecendo os seus recursos ?

Eu já falei sobre o Dapper nos seguintes artigos:

Hoje vou mostrar como é fácil usar o Dapper em um projeto Console.

recursos usados:

Criando o projeto no VS 2019 Community

Vamos criar um projeto usando a linguagem C# do tipo Console para .NET Core : Console App(.NET Core)

Podemos chamar o projeto de CShp_Dapper1.

No projeto criado vamos incluir um arquivo de JSON chamado appsettings.json que para facilitar o nosso trabalho será colocado na pasta /bin/debug/netcoreapp2.2 do projeto.

Definindo a fonte de dados

Vamos usar como fonte de dados um banco de dados SQL Server Cadastro.mdf e a tabela Clientes que tem a seguinte estrutura e dados:

A seguir temos o script SQL para gerar a tabela:

CREATE TABLE [dbo].[Clientes] (
[ClienteId] INT IDENTITY (1, 1) NOT NULL,
[Nome] NVARCHAR (80) NOT NULL,
[Idade] INT NULL,
[Email] NVARCHAR (150) NULL,
[Pais] NVARCHAR (20) NULL,
CONSTRAINT [PK_Clientes] PRIMARY KEY CLUSTERED ([ClienteId] ASC)
);

A string de conexão deste banco de dados já pode ser incluida no arquivo appsettings.json conforme mostrado a seguir:

{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=MACORATTI;Initial Catalog=Cadastro;Integrated Security=True"
  }
}

Vamos criar uma pasta Models no projeto e nesta classe definir a classe Cliente com o código abaixo:

    public class Cliente
    {
        public int ClienteI { get; set; }
        public string Nome { get; set; }
        public int  Idade { get; set; }
        public string Email { get; set; }
        public string Pais { get; set; }
    }

Essa classe será o nosso DTO.

Instalando o Dapper e os pacotes do Configuration

No menu Tools acione o gerenciador de pacotes Nuget para a Solution e instale o pacote Dapper no projeto:

Instale também os seguines pacotes :

  1. Microsoft Extensions.Configuration
  2. Microsoft Extensions.Configuration.Json

Agora que já temos tudo pronto vamos realizar as operações CRUD usando o Dapper.

Definindo o código no arquivo Program

Abra o arquivo Program e defina os namespaces que iremos usar:

using CShp_Dapper1.Models;
using Dapper;
using Microsoft.Extensions.Configuration;
using System;
using System.Data.SqlClient;
using System.IO;

A seguir vamos definir uma instância de IConfiguration:

 public static IConfigurationRoot Configuration { get; set; }

No método Main() inclua o código a seguir que lê a string de conexão e monta o menu:

        static void Main(string[] args)
        {

            var builder = new ConfigurationBuilder()
                    .SetBasePath(Directory.GetCurrentDirectory())
                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

            Configuration = builder.Build();

            string _con = Configuration["ConnectionStrings:DefaultConnection"];

            Console.WriteLine("\tc - Consultar");
            Console.WriteLine("\ti - Incluir");
            Console.WriteLine("\ta - Atualizar");
            Console.WriteLine("\td - Deletar");
            Console.Write("Sua opção (c,i,d,a) ? ");
            switch (Console.ReadLine())
            {
                case "c":
                    Consultar(_con);
                    break;
                case "i":
                    Incluir(_con);
                    break;
                case "a":
                    Atualizar(_con);
                    break;
                case "d":
                    Deletar(_con);
                    break;
            }
            Console.ReadKey();
        }

A seguir vamos definir cada um dos métodos para realizar as operações de consulta, inclusão, atualização e exclusão dos dados.

1- Consultar Dados

       static async void Consultar(string conexao)
        {
            using (var db = new SqlConnection(conexao))
            {
                await db.OpenAsync();
                var query = "Select Top 10 ClienteId,Nome,Idade,Pais From Clientes";
                var clientes = await db.QueryAsync<Cliente>(query);
                foreach (var cliente in clientes)
                {
                    Console.WriteLine(new string('*', 20));
                    Console.WriteLine("\nID: " + cliente.ClienteId.ToString());
                    Console.WriteLine("Nome : " + cliente.Nome);
                    Console.WriteLine("Idade: " + cliente.Idade.ToString());
                    Console.WriteLine("Pais : " + cliente.Pais + "\n");
                    Console.WriteLine(new string('*', 20));
                }
                Console.ReadLine();
            }
        }

2- Incluir Dados

  static async void Incluir(string conexao)
   {
            using (var db = new SqlConnection(conexao))
            {
                Cliente model = new Cliente();
                model.Nome = "teste";
                model.Email = "email@teste.com";
                model.Idade = 99;
                model.Pais = "Terra";
                try
                {
                    await db.OpenAsync();
                    var query = @"Insert Into Clientes(Nome,Idade,Email,Pais) Values(@nome,@idade,@email,@pais)";
                    await db.ExecuteAsync(query, model);
                    Console.WriteLine($"Cliente {model.Nome} incluido com sucesso");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
    }

3- Atualizar Dados

  static async void Atualizar(string conexao)
   {
       using (var db = new SqlConnection(conexao))
       {
           Cliente model = new Cliente();
           model.Nome = "teste alterado";
           model.Email = "email@teste.com";
           model.Idade = 88;
           model.Pais = "Terra";
           model.ClienteId = 2;

           try
           {
               await db.OpenAsync();
               var query = @"Update Clientes Set Nome=@Nome, Idade=@Idade,Email=@Email,Pais=@Pais Where ClienteId=@ClienteId";

               await db.ExecuteAsync(query, model);

               Console.WriteLine($"Cliente {model.Nome} incluido com sucesso");
           }
           catch (Exception ex)
           {
                Console.WriteLine(ex.Message);
           }
       }
   }

  

4- Excluir Dados

       static async void Deletar(string conexao)
        {
            int id = 2;
            using (var db = new SqlConnection(conexao))
            {
                try
                {
                    await db.OpenAsync();
                    var query = @"Delete from Clientes Where ClienteId=" + id;
                    await db.ExecuteAsync(query,new { ClienteId = id });

                    Console.WriteLine($"Cliente excluido com sucesso");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
  

Executando o projeto e realizando a consulta teremos o resultado a seguir:

Temos assim uma implementação básica do Dapper que pode ser uma opção muito versátil para projetos de pequeno porte para acessar dados com um bom desempenho.

Pegue o projeto completo aqui: CShp_Dapper1.zip

"E Jesus clamou, e disse: Quem crê em mim, crê, não em mim, mas naquele que me enviou.
E quem me vê a mim, vê aquele que me enviou.
Eu sou a luz que vim ao mundo, para que todo aquele que crê em mim não permaneça nas trevas."
João 12:44-46

Referências:

José Carlos Macoratti