ADO .NET - Criando um Acesso de dados Genérico (revisitado)

 Neste artigo vamos recordar como podemos criar um acesso a dados genérico usando os objetos da ADO .NET.

Eu apresentei os conceitos básicos da ADO .NET neste artigo , e, estou voltando a esse assunto depois de algum tempo para recordar a sua aplicação no VS 2017 Communtiy.

A biblioteca ADO.NET fornece diferentes tipos de provedores de dados para trabalhar com diferentes fontes de dados. Três provedores de dados comuns são OLE DB, SQL e ODBC.

A principal razão de usar diferentes provedores de dados é manter o desempenho e não perder a funcionalidade do provedor de dados nativos. Por exemplo, quando você acessa um banco de dados do Access usando o provedor de dados OLE DB, ele usa provedor OLE DB nativo para acessar o banco de dados, mas quando você usa o provedor de dados ODBC para acessar um banco de dados do Access, ele usa a camada ODBC na camada nativa.

Em resumo, todas as classes do provedor de dados, como conexão, comando, adaptador de dados e leitor de dados, são herdadas das interfaces. E focando nas interfaces o objetivo deste artigo é mostrar como você pode escrever uma classe genérica, que pode acessar os dados usando os provedores de dados OLE DB, SQL e ODBC com base na seleção do usuário no tempo de execução.

O modelo de interface

Cada provedor de dados implementa algumas interfaces. Essas interfaces são definidas no namespace System.Data. Por exemplo, as classes SqlConnection, OleDbConnection e OdbcConnection são derivadas da interface IDbConnection.

Semelhante às classes de conexão, outros componentes do ADO.NET, como DataAdapter, DataReader, Command, também implementam suas interfaces relativas.

Vamos usar essas interfaces para escrever classes genéricas de acesso a dados. O objetivo não é implementar todas as funcionalidades mas dar uma boa ideia de como isso funciona e como você pode estender as funcionalidades. Veja as referências para saber mais sobre esse assunto.

Ao trabalho...

recursos:

Criando o projeto Windows Forms

Vamos criar um projeto Windows Desktop usando o template Windows Forms App(.NET Framework) com o nome WF_GenericAccess.

No formulário padrão inclua a partir da ToolBox os controles:

Disponha os controles conforme o leiaute exibido na figura abaixo:

Pronto nossa interface já esta pronta.

Criando a classe para acesso genérico

Inclua uma classe (poderia ser outro projeto do tipo Class Library) chamada: AcessoGenerico com o código abaixo:

using System.Data;
using System.Data.Common;
using System.Data.Odbc;
using System.Data.OleDb;
using System.Data.SqlClient;
namespace WF_GenericAccess
{
    public class AcessoGenerico
    {
        private static IDbConnection iconexao = null;
        private static IDbDataAdapter iadapter = null;
        private static DbDataAdapter dbAdapter = null;
        private static IDataReader ireader = null;
        public AcessoGenerico()
        { }
        // GetConnection retorna IDbConnection   
        public static IDbConnection GetConnection(int connType, string connString)
        {
            switch (connType)
            {
                case 1: // OleDb Data Provider  
                    iconexao = new OleDbConnection(connString);
                    break;
                case 2: // Sql Data Provider  
                    iconexao = new SqlConnection(connString);
                    break;
                case 3: // ODBC Data Provider  
                    iconexao = new OdbcConnection(connString);
                    break;
                // case 3: //inclua o seu dataprovider customizado aqui
                default:
                    break;
            }
            return iconexao;
        }
        // GetDataAdapter retorna IDbDataAdapter  
        public static IDbDataAdapter GetDataAdapter(int connType, string connString, string sql)
        {
            switch (connType)
            {
                case 1: // OleDb Data Provider  
                    iadapter = new OleDbDataAdapter(sql, connString);
                    break;
                case 2: // Sql Data Provider  
                    iadapter = new SqlDataAdapter(sql, connString);
                    break;
                case 3: // ODBC Data Provider  
                    iadapter = new OdbcDataAdapter(sql, connString);
                    break;
                // case 3: //inclua o seu dataprovider customizado aqui
                default:
                    break;
            }
            return iadapter;
        }
    }
}

Nossa classe de acesso genérico na verdade apenas retorna a conexão e um adapter genérico conforme o provedor selecionado. Aqui você deve implementar os métodos para realizar o CRUD.

A seguir temos o código do evento Click do botão de comando após o usuário selecionar o provedor de dados desejado:

using System;
using System.Data;
using System.Windows.Forms;
namespace WF_GenericAccess
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private string connString, sql;
        IDbConnection conn = null;
        IDbDataAdapter adapter = null;
        private void btnConectar_Click(object sender, EventArgs e)
        {
           //define a consulta SQL para acessar a tabela Employees
            sql = "SELECT * FROM Employees";
            if (rdbOleDb.Checked)
            {
                connString = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=c:\\dados\\Access\\Northwind.mdb";
                conn = AcessoGenerico.GetConnection(1, connString);
                adapter = AcessoGenerico.GetDataAdapter(1, connString, sql);
            }
            else if (rdbSql.Checked)
            {
                connString = "Data Source=MACORATTI;Initial Catalog=Northwind;Integrated Security=True";
                conn = AcessoGenerico.GetConnection(2, connString);
                adapter = AcessoGenerico.GetDataAdapter(2, connString, sql);
            }
            else if (rdbOdbc.Checked)
            {
                // defina sua conexão aqui
                // connString = "sua_conexão";
                conn = AcessoGenerico.GetConnection(3, connString);
                adapter = AcessoGenerico.GetDataAdapter(3, connString, sql);
            }
            try
            {
                conn.Open();
                // preenche o DataSet  
                DataSet ds = new DataSet();
                adapter.Fill(ds);
                dgvDados.DataSource = ds.Tables[0].DefaultView;
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message);
            }
            finally
            {
                conn.Close();
            }
        }
    }
}

Estamos acessando aqui efetivamento o banco de dados Northwind no formato do Microsoft Access na pasta c:dados\Access e no formato do SQL Server.

A consulta SQL definida vai retornar todos os registros da tabela Employees e exibir no DataGridView.

Uma abordagem mais robusta seria utilizar o padrão Factory para criar a camada de acesso a dados genérica.

Pegue o código do projeto aqui:  WF_GenericAccess.zip

"Disse-lhe, pois, Pilatos: Logo tu és rei? Jesus respondeu: Tu dizes que eu sou rei. Eu para isso nasci, e para isso vim ao mundo, a fim de dar testemunho da verdade. Todo aquele que é da verdade ouve a minha voz."
João 18:37

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 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

Referências:

José Carlos Macoratti