CRUD no ADO.NET

Nós que trabalhamos na borda da tecnologia, sempre procurando por novidades, avaliando versões betas, ctps, etc, acabamos esquecendo um pouco das coisas simples e básicas. Notei isso recentemente quando algumas pessoas que estão começando a aprender C# me pediram por um exemplo simples de rotinas de inclusão, alteração, exclusão e consulta de registros em uma tabela de um banco de dados SQL Server. Me assustei quando notei que não tinha tal exemplo pronto, para poder enviar.

É em nome da simplicidade, e para que sempre que possível, possa ajudar quem tem interesse em aprender C#, que vou começar a postar aqui alguns exemplos e conceitos básicos. Começando hoje com um exemplo de CRUD, usando os recursos mais simples do ADO.NET.

Para quem não é familiarizado com a sigla, CRUD é o acrônimo de: Create, Read, Update e Delete. Referencia às quatro operações básicas de qualquer banco de dados.

O código deste exemplo que vou mostrar aqui, pode ser executado em um aplicação do tipo Console Application, e precisa do database Northwind da Microsoft. É claro que você deve adaptá-lo para que funcione no seu banco de dados e no tipo de aplicação que deseja: ASP.NET, Windows Forms, WPF, Silverlight, etc.

Comecemos então com o código necessário para abrir a conexão com o banco de dados. Veja na Listagem abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Data;
using System.Data.SqlClient;

namespace Algorama.Exemplos.CRUDSimples.AppConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            string ConnString =
            "Data Source=(local);Initial Catalog=Northwind; Integrated Security=True";
            SqlConnection Conn  = new SqlConnection(ConnString);
            try
            {
                Conn.Open();
                InsertShippers(Conn, "ALGOARAMA", "123456");
                //UpdateShippers(Conn, "ALGORAMA - ALTERADO", "55555555", 4);
                //DeleteShippers(Conn, 4);
                SelectShippers(Conn);
                Console.ReadKey();            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.ReadKey();
            }
            finally
            {
                Conn.Close();
            }
        }
    }
}

Note nas linhas 6 e 7, que precisamos importar os namespaces System.Data e System.Data.SqlClient, para que possamos utilizar os recursos do ADO.NET para SQL Server. Em seguida dentro do método Main (que é executado quando rodamos uma aplicação console), veja que estamos criando um objeto da classe SqlConnection (linha 17), através de uma ConnectionString (linha 16), que possuí as credenciais para acessar o banco de dados no servidor.

Quando vamos abrir uma conexão com um banco de dados, precisamos garantir que o nosso código vá fechá-la corretamente, depois de usada. É por isso que usamos a estrutura try/catch/finally. Com ela, mesmo que ocorra um erro durante o acesso ao banco, estamos garantindo que a linha 33 sempre será executada, fechando a conexão.

Depois que abrimos a conexão com o banco, na linha 20, note que temos a chamada de 4 métodos. Esses são os métodos correspondentes às quatro operações CRUD. Alguns estão comentados, pois para efeito de testes, é interessante que você execute um por vez. Vamos então ao código de cada um destes métodos, a começar pelo Insert.

private static void InsertShippers(
    SqlConnection Conn, 
    string Name, string Phone)
{
      SqlCommand Comm = new SqlCommand();
           
      Comm.CommandText =
      "INSERT INTO Shippers( CompanyName, Phone ) Values(@Name, @Phone)";
      Comm.Parameters.Add(new SqlParameter("@Name", Name));
      Comm.Parameters.Add(new SqlParameter("@Phone", Phone));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Inserido(s)",
            nroReg.ToString());
}

Todos os quatro métodos recebem como parâmetro o objeto de conexão aberto no método Main. Com este objeto, no método Insert podemos criar um objeto da classe SqlCommand (linha 5), e definir um comando no formato texto (linha 7). É claro que você poderia estar usando uma stored procedure aqui.

Veja que nas linhas 9 e 10, estamos alimentando os parâmetros do comando que será executado. Essa prática garante que nossa aplicação esteja segura quanto a possíveis ataques de SQL Injection. Por fim o comando é executado e uma mensagem exibida na console.

Note que para que você utilize essa rotina em uma aplicação Windows Forms ou ASP.NET, poucas adaptações devem ser feitas. A essência da operação de inclusão não muda.

O próximo método que segue na Listagem abaixo, é o método que faz a operação de Select. Veja que também usamos um SqlCommand, porém, neste caso o SqlCommand é executado por um SqlDataAdapter (linha 11), que é usado para preencher um DataSet (linha 13).

private static void SelectShippers(
    SqlConnection Conn)
{
      SqlCommand Comm = new SqlCommand();

      Comm.CommandText = "SELECT * FROM Shippers";
      Comm.CommandType = CommandType.Text;
      Comm.Connection  = Conn;

      DataSet ds = new DataSet();
      SqlDataAdapter da = new SqlDataAdapter();
      da.SelectCommand = Comm;
      da.Fill(ds);

      Console.WriteLine(
          "Total de: {0} registros",
          ds.Tables[0].Rows.Count);

      foreach (DataRow item in ds.Tables[0].Rows)
      {
          Console.WriteLine(
                    "Id: {0} - Name: {1} - Phone: {2}",
                    item["ShipperID"],
                    item["CompanyName"],
                    item["Phone"]);
      }
}

O dataset é uma representação em memória de parte do nosso banco de dados. Com ele podemos recuperar e manipular os dados do database de forma desconectada. Esse é um assunto a parte, que deve ser explorado em mais detalhes em outra ocasião.

Por fim, ainda no método Select, depois de recuperados todos os registros, estamos imprimindo-os na Console através de um foreach (linha 19), que irá percorrer por todas as linhas da tabela do nosso dataset.

Por último, temos agora os métodos de Update e Delete, que seguem nas próximas duas listagens. Eles tem comportamento muito parecido com o Insert, que usa o SqlCommand e parâmetros, dispensando qualquer comentário adicional.

private static void UpdateShippers(
    SqlConnection Conn, 
    string Name, string Phone, int ID)
{
SqlCommand Comm = new SqlCommand();

      Comm.CommandText =
      "UPDATE Shippers SET CompanyName = @Name, Phone = @Phone WHERE ShipperID = @ID";
      Comm.Parameters.Add(new SqlParameter("@Name", Name));
      Comm.Parameters.Add(new SqlParameter("@Phone", Phone));
      Comm.Parameters.Add(new SqlParameter("@ID", ID));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Alterados(s)",
            nroReg.ToString());
}

private static void DeleteShippers(
    SqlConnection Conn, int ID)
{
      SqlCommand Comm = new SqlCommand();

      Comm.CommandText = "DELETE FROM Shippers WHERE ShipperID = @ID";
      Comm.Parameters.Add(new SqlParameter("@ID", ID));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Deletados(s)",
            nroReg.ToString());
}

É importante notar que o código apresentado aqui serve como teste para estas quatro operações. Se você pretende usar este código em uma aplicação Windows ou Web, terá que realizar algumas adaptações. Se você quiser, pode ainda fazer o download desse exemplo aqui.

Espero que este post ajude quem procura por um exemplo básico de ADO.NET.
Grande Abraço e até a próxima!