ADO .NET - Operações CRUD (revisitado) - I


Vamos rever os conceitos para realizar as operações CRUD usando a ADO .NET.

Atualmente, o Entity Framework é a tecnologia de acesso e consulta a dados recomendada e promovida no ecossistema .NET. O Entity Framework permite que os desenvolvedores sem muito conhecimento sobre SQL possam consultar, criar consultas complexas e gerar classes com a ajuda de uma interface amigável.

No entanto, para alguns cenários complexos, o Entity Framework nem sempre oferece um desempenho desejado, e, se você quiser obter um melhor desempenho, a ADO.NET ainda pode ser a escolha certa.

Acontece que a ADO.NET vem com um "custo" : ela não possui nenhuma interface de usuário para ajudá-lo a projetar o material, e , tudo precisa ser feito manualmente.

É claro que existem ferramentas de terceiros que podem gerar as consultas SQL para você ou criar classes com base na sua estrutura de banco de dados, mas comparando com o Entity Framework, ela não oferece todos esses recursos que aumentam a produtividade.

Mas pense nisso como um trunfo, pois você tem a possibilidade de projetar tudo do zero. Então antes de tomar essa decisão avalie bem o seu projeto e veja se a relação custo/benefício pende para o lado da ADO .NET.

Se este for o seu caso então esse artigo é para você, pois nele eu vou mostrar como realizar as operações CRUD (Create, Receive, Update e Delete) usando a ADO .NET, e, como criar classes para mapear seus dados e como usar esses recursos para exibir dados em uma interface web.(aqui você pode adaptar para usar a sua interface).

Vou focar apenas na criação do projeto Class Library e da camada de acesso a dados (DAL) em um projeto que pode ser de qualquer tipo.

A título de exemplo vamos usar um banco de dados SQL Server EstudoDB com duas tabelas Artigos e Categorias cuja estrutura é vista a seguir:

Existe um relacionamento um-para-muitos entre Artigos e Categorias :

Para demonstrar as operações CRUD, eu vou criar um aplicativo ASP.NET WebForms, embora o ADO.NET também possa ser integrado ao MVC, WPF ou WebForms. O ADO.NET não depende de uma tecnologia específica voltada para o usuário e por isso você pode adaptar a interface conforme sua necessidade.

Antes de começarmos a codificar, vamos rever alguns dos objetos ADO.NET mais importantes responsáveis ​​pelas operações CRUD :

Criando o projeto no VS 2017 Community

Crie um novo projeto do tipo Web -> ASP .NET Web Application (.NET Framework) com o nome WebDemo;

A seguir marque as opções Empty e Web Forms sem autenticação.

A seguir no menu File clique em Add ->New Project;

Selecione Windows Desktop -> Class Library (.NET Framework) com o nome WebDemo.DAL;

De forma que teremos uma solução contendo dois projetos :

Criando as classes do modelo de domínio

No projeto WebDemo.DAL inclua uma pasta chamada Entities e inclua nessa pasta duas classes:

Abaixo temos o código das classes :

public class Artigo
    {
        public int ArtigoId { get; set; }
        public int CategoriaId { get; set; }
        public string Titulo { get; set; }
        public string Assunto { get; set; }
        public DateTime DataPublicacao { get; set; }
    }

 

    public class Categoria
    {
        public int CategoriaId { get; set; }
        public string CategoriaNome { get; set; }
    }

 

Artigo.cs Categoria.cs

Criando as classes para a camada de acesso a dados

No projeto WebDemo.DAL crie mais três classes que iremos usar para gerenciar os dados dos artigos e categorias

Ao final desta etapa teremos a seguinte estrutura exibida na janela Solution Explorer:

Vejamos a seguir a implementação das classes da camada de acesso a dados:

1- DataBaseHelper

A classe DataBaseHelper possui um campo estático que retorna a string de conexão com o banco de dados SQL Server:

 public class DataBaseHelper
 {
        public static string ConnectionString = @"Data Source=Macoratti;Initial Catalog=EstudoDB;Integrated Security=True";
 }

Aqui você deve informar a string de conexão usada no seu ambiente.

2- GerenciaArtigos

Nesta classe vamos definir 4 métodos :

  1. SalvarArtigo(Artigo artigo)
  2. DeletaArtigo(int artigoId)
  3. GetArtigos()
  4. GetArtigoPorId(int artigoId)

a.  Método SalvarArtigo(Artigo artigo)

Permite incluir e atualizar os dados de um artigo:

        public int SalvarArtigo(Artigo artigo)
        {
            //Cria a consulta SQL para inserir um artigo
            string consultaInclusao = String.Format("Insert into Artigos (Titulo, Assunto , DataPublicacao, CategoriaId)
            Values('{0}', '{1}', '{2}', {3} );"
           + "Select @@Identity", artigo.Titulo, artigo.Assunto, artigo.DataPublicacao.ToString("yyyy-MM-dd"),
 artigo.CategoriaId);
            //Cria a consulta SQL para atualizar um artigo
            string consultaAtualizacao = String.Format("Update Artigos SET Titulo='{0}', Assunto = '{1}', 
             DataPublicacao ='{2}', CategoriaId = {3} Where ArtigoId = {4};",
             artigo.Titulo, artigo.Assunto, artigo.DataPublicacao.ToString("yyyy-MM-dd"), artigo.CategoriaId,
 artigo.ArtigoId);
            //Cria e abre uma conexão com o SQL Server 
            SqlConnection connection = new SqlConnection(DataBaseHelper.ConnectionString);
            connection.Open();
            //Cria um objeto Command
            SqlCommand comando = null;
            if (artigo.ArtigoId != 0)
                comando = new SqlCommand(consultaAtualizacao, connection);
            else
                comando = new SqlCommand(consultaInclusao, connection);
            int artigoIdSalvo = 0;
            try
            {
                //Executa o comando no SQL Server e retorna um novo artigo criado
                var commandResult = comando.ExecuteScalar();
                if (commandResult != null)
                {
                    artigoIdSalvo = Convert.ToInt32(commandResult);
                }
                else
                {
                    //A consulta de atualização não retornará a chave primária
                    //mas se não houver uma exceção então podemos obté-la dos dados fornecidos
                    artigoIdSalvo = artigo.ArtigoId;
                }
            }
            catch (Exception ex)
            {
                //ocorreu um erro
                throw ex;
            }
            //Fecha e libera os objetos
            comando.Dispose();
            connection.Close();
            connection.Dispose();
            return artigoIdSalvo;
        }

Neste código destaca-se a execução do comando que envia a consulta SQL e recebe o Id do novo item criado (por isso usamos @@Identity)

b.  Método DeletaArtigo(int artigoId)

Permite excluir um artigo pelo seu id:

        public bool DeletaArtigo(int artigoId)
        {
            bool resultado = false;
            //Cria uma consulta SQL para deletar um artigo
            string consultaSQL = String.Format("delete from Artigos where ArtigoId = {0}", artigoId);
            //Cria e abre uma conexão com o  SQL Server 
            SqlConnection connection = new SqlConnection(DataBaseHelper.ConnectionString);
            connection.Open();
            //Cria um objeto Command
            SqlCommand comando = new SqlCommand(consultaSQL, connection);
            // Executa o command
            int linhasDeletadas = comando.ExecuteNonQuery();
            if (linhasDeletadas != 0)
                resultado = true;
            // Fecha e libera os objetos
            comando.Dispose();
            connection.Close();
            connection.Dispose();
            return resultado;
        }

cMétodo GetArtigos()

Retorna todos os artigos como uma lista de objetos Artigo:

        public List<Artigo> GetArtigos()
        {
            List<Artigo> resultado = new List<Artigo>();
            //Cria uma consulta para retornar todos os artigos
            string consultaSQL = String.Format("select * from Artigos");
            //Cria e abre uma conexão com o SQL Server
            SqlConnection connection = new SqlConnection(DataBaseHelper.ConnectionString);
            connection.Open();
            SqlCommand comando = new SqlCommand(consultaSQL, connection);
            //Cria um DataReader para armazenar a tabela retornada na memória
            SqlDataReader dataReader = comando.ExecuteReader();
            Artigo artigo = null;
            //carrega no objeto resultado a linha retornada do bd
            if (dataReader.HasRows)
            {
                while (dataReader.Read())
                {
                    artigo = new Artigo();
                    artigo.ArtigoId = Convert.ToInt32(dataReader["ArtigoID"]);
                    artigo.Assunto = dataReader["Assunto"].ToString();
                    artigo.CategoriaId = Convert.ToInt32(dataReader["CategoriaId"]);
                    artigo.DataPublicacao = Convert.ToDateTime(dataReader["DataPublicacao"]);
                    artigo.Titulo = dataReader["Titulo"].ToString();
                    resultado.Add(artigo);
                }
            }
            return resultado;
        }

d.  GetArtigoPorId(int artigoId)

Retorna um artigo pelo seu id:

        public Artigo GetArtigoPorId(int artigoId)
        {
            Artigo resultado = new Artigo();
            //Cria a consulta SQL para retornar o artigo pelo id
            string consultaSQL = String.Format("select * from Artigos where ArtigoId={0}", artigoId);
            //Cria e abre uma conexão com o SQL Server 
            SqlConnection connection = new SqlConnection(DataBaseHelper.ConnectionString);
            connection.Open();
            SqlCommand comando = new SqlCommand(consultaSQL, connection);
            SqlDataReader dataReader = comando.ExecuteReader();
            //Carrega no objeto reusultado a linha retornada do DB
            if (dataReader.HasRows)
            {
                while (dataReader.Read())
                {
                    resultado.ArtigoId = Convert.ToInt32(dataReader["ArtigoId"]);
                    resultado.Assunto = dataReader["Assunto"].ToString();
                    resultado.CategoriaId = Convert.ToInt32(dataReader["CategoriaId"]);
                    resultado.DataPublicacao = Convert.ToDateTime(dataReader["DataPublicacao"]);
                    resultado.Titulo = dataReader["Titulo"].ToString();
                }
            }
            return resultado;
        }

A implementação desses quatro métodos permite gerenciar as informações dos artigos.

Na segunda parte do artigo teremos a implementação dos métodos para gerenciar categorias.

Ó Senhor, Senhor nosso, quão admirável é o teu nome em toda a terra, pois puseste a tua glória sobre os céus!
Salmos 8:1

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:


José Carlos Macoratti