Criando um projeto genérico para acesso a dados

Fernando Parmezani | 14/08/2013 | ADO.NET | 9 Comentários

Algumas consultas em projetos podem ser feitas de forma mais simples, como a consulta de um item em uma tabela. o famoso “select * from tabela” .

Pesquisando na web, encontrei um modelo muito bacana que faz este serviço, e uma das vantagens é a possibilidade de modificar a conexão para bancos como SQL Server, ORACLE DB e MySQL.

Bom eu vou acrescentar a “dll” como anexo, e colocar aqui o código fonte com comentários.

Este modelo aceita somente uma conexão por vez, mas com um pouquinho de esforço fica fácil definir qual a conexão que precisa e assim usar mais que uma.

Classe ConnectionDB:

<span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">class</span> ConnectionDB
    {
        <span class="rem">/// Field String de Conexão</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> connectionString {get;set;}

        <span class="rem">/// Field Nome do Provedor</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> providerName {get;set;}

        <span class="rem">/// &lt;summary&gt; Connection DB</span>
        <span class="rem">/// </span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">static</span> ConnectionDB()
        {
            <span class="kwrd">try</span>
            {
                <span class="rem">// Recebe do arquivo de configuração Web.Config a string de conexão e o nome do provedor</span>
                connectionString = ConfigurationManager.ConnectionStrings[<span class="str">"ConnectionString"</span>].ConnectionString;
                providerName = ConfigurationManager.ConnectionStrings[<span class="str">"ConnectionString"</span>].ProviderName;
                <span class="rem">//connectionString = connectionString;</span>
                <span class="rem">//providerName = providerName;</span>

            }
            <span class="kwrd">catch</span> (Exception)
            {
                <span class="kwrd">throw</span> <span class="kwrd">new</span> Exception(<span class="str">"Erro ao receber dados da Conexão. Por favor verifique se a string de conexão está declarada corretamente."</span>);
            }
        }

        <span class="rem">//Propriedade que apenas informa a String de Conexão</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> ConnectionString
        {
            get { <span class="kwrd">return</span> connectionString; }
        }

        <span class="rem">/// Propriedade que apenas informa o Nome do Provedor</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> ProviderName
        {
            get { <span class="kwrd">return</span> providerName; }
        }
    }

public static class ConnectionDB

{

/// Field String de Conexão

public static string connectionString {get;set;}

/// Field Nome do Provedor

public static string providerName {get;set;}

/// <summary> Connection DB

///

/// </summary>

static ConnectionDB()

{

try

{

// Recebe do arquivo de configuração Web.Config a string de conexão e o nome do provedor

connectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;

providerName = ConfigurationManager.ConnectionStrings["ConnectionString"].ProviderName;

//connectionString = connectionString;

//providerName = providerName;

}

catch (Exception)

{

throw new Exception("Erro ao receber dados da Conexão. Por favor verifique se a string de conexão está declarada corretamente.");

}

//Propriedade que apenas informa a String de Conexão

public static string ConnectionString

{

get { return connectionString; }

}

/// Propriedade que apenas informa o Nome do Provedor

public static string ProviderName

{

get { return providerName; }

}

Connections.cs

<span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">class</span> Connections
    {
        <span class="kwrd">public</span> <span class="kwrd">static</span> List&lt;Connect&gt; RetornaListaConnectionString()
        {
            ConnectionStringSettingsCollection settings = ConfigurationManager.ConnectionStrings;

            var lista = <span class="kwrd">new</span> List&lt;Connect&gt;();

            <span class="kwrd">if</span>(settings != <span class="kwrd">null</span>)
            {
                <span class="kwrd">foreach</span>(ConnectionStringSettings cs <span class="kwrd">in</span> settings)
                {
                    var connect = <span class="kwrd">new</span> Connect(){ connection = cs.ConnectionString, provider = cs.ProviderName};
                    lista.Add(connect);
                }

            }

            <span class="kwrd">return</span> lista;
        }
    }

    <span class="kwrd">public</span> <span class="kwrd">class</span> Connect
    {
        <span class="kwrd">public</span> <span class="kwrd">string</span> connection { get; set; }
        <span class="kwrd">public</span> <span class="kwrd">string</span> provider { get; set; }
    }

public static class Connections

{

public static List<Connect> RetornaListaConnectionString()

{

ConnectionStringSettingsCollection settings = ConfigurationManager.ConnectionStrings;

var lista = new List<Connect>();

if(settings != null)

{

foreach(ConnectionStringSettings cs in settings)

{

var connect = new Connect(){ connection = cs.ConnectionString, provider = cs.ProviderName};

lista.Add(connect);

}

return lista;

}

public class Connect

{

public string connection { get; set; }

public string provider { get; set; }

}

GenericDataBase.cs

publicclass GenericDataBase

    {

        <span class="rem">/// Método que Cria um objeto DBCommand com os dados</span>
        <span class="rem">/// da classe ConnectionDB utilizando Factory</span>
        <span class="rem">/// DBCommand criado</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> DbCommand CreateCommand(String cmmdText, CommandType cmmdType, List&lt;DbParameter&gt; listParameter)
        {

            <span class="rem">// Cria um novo factories de acordo com o nome do provedor</span>
            var factory = DbProviderFactories.GetFactory(ConnectionDB.ProviderName);

            <span class="rem">// Cria um objeto específico de conexão de acordo com o nome do provedor</span>
            var conn = factory.CreateConnection();

            <span class="rem">// Atribui a String de Conexão</span>
            conn.ConnectionString = ConnectionDB.ConnectionString;

            <span class="rem">// Cria um objeto command específico de acordo com o nome do provedor</span>
            var comm = conn.CreateCommand();

            <span class="rem">// Atribui o comando Text</span>
            comm.CommandText = cmmdText;

            <span class="rem">// Atribui o tipo de comando</span>
            comm.CommandType = cmmdType;

            <span class="rem">// Se existir algum parâmetro ele adiciona</span>
            <span class="rem">// ao comando</span>
            <span class="kwrd">if</span> (listParameter != <span class="kwrd">null</span>)
            {
                <span class="kwrd">foreach</span> (var param <span class="kwrd">in</span> listParameter)
                {
                    <span class="rem">// Adicionando o parâmetro</span>
                    comm.Parameters.Add(param);
                }
            }           

            <span class="rem">// Retorna o comando criado</span>
            <span class="kwrd">return</span> comm;

        }

        <span class="rem">/// &lt;summary&gt; Método responsável por criar um Parâmetro</span>
        <span class="rem">/// </span>
        <span class="rem">/// List param = new List();</span>
        <span class="rem">/// param.Add(criaParameter(nome, tipo, valor));</span>
        <span class="rem">/// </span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="nameParameter"&gt; Nome do Parâmetro&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="typeParameter"&gt; Tipo do Parâmetro&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="valueParameter"&gt; Valor do Parâmetro&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> DbParameter CreateParameter(String nameParameter, DbType typeParameter, Object valueParameter)
        {
            <span class="rem">// Cria um novo factories de acordo com o nome do provedor</span>
            var factory = DbProviderFactories.GetFactory(ConnectionDB.ProviderName);

            <span class="rem">// Cria o Parâmetro e add seu valores</span>
            var param = factory.CreateParameter();

            <span class="kwrd">if</span> (param != <span class="kwrd">null</span>)
            {
                param.ParameterName = nameParameter;
                param.DbType = typeParameter;
                param.Value = valueParameter;
            }

            <span class="rem">// Retorna o Parâmetro criado</span>
            <span class="kwrd">return</span> param;
        }

        <span class="rem">/// &lt;summary&gt; Método responsável por criar um Parâmetro</span>
        <span class="rem">/// </span>
        <span class="rem">/// List param = new List();</span>
        <span class="rem">/// param.Add(criaParameter(nome, tipo, valor));</span>
        <span class="rem">/// </span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="nameParameter"&gt; Nome do Parâmetro&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="typeParameter"&gt; Tipo do Parâmetro&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="valueParameter"&gt; Valor do Parâmetro&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="direction"&gt;Direction &lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> DbParameter CreateParameter(String nameParameter, DbType typeParameter, Object valueParameter, ParameterDirection direction)
        {
            <span class="rem">// Cria um novo factories de acordo com o nome do provedor</span>
            var factory = DbProviderFactories.GetFactory(ConnectionDB.ProviderName);

            <span class="rem">// Cria o Parâmetro e add seu valores</span>
            var param = factory.CreateParameter();

            <span class="kwrd">if</span> (param != <span class="kwrd">null</span>)
            {
                param.ParameterName = nameParameter;
                param.DbType = typeParameter;
                param.Value = valueParameter;
                param.Direction = direction;
            }

            <span class="rem">// Retorna o Parâmetro criado</span>
            <span class="kwrd">return</span> param;
        }

        <span class="rem">/// &lt;summary&gt; Método que cria um comando e executa esse comando.</span>
        <span class="rem">/// </span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="cmmdText"&gt;String SQL ou StoredProcedure&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="cmmdType"&gt;Tipo de Commando (Text ou Stored Procedure)&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="listParameter"&gt;Lista de parâmetros&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="typeCmmd"&gt;Comando a ser executado (ExecuteNonQuery, ExecuteReader, ExecuteScalar, ExecuteDataTable)&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;Object&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> Object ExecuteCommand(String cmmdText, CommandType cmmdType, List&lt;DbParameter&gt; listParameter, TypeCommand typeCmmd)
        {
            <span class="rem">// Cria comando com os dados passado por parâmetro</span>
            var command = CreateCommand(cmmdText, cmmdType, listParameter);
            <span class="rem">// Cria objeto de retorno</span>
            Object objRetorno = <span class="kwrd">null</span>;

            <span class="kwrd">try</span>
            {
                <span class="rem">// Abre a Conexão com o banco de dados</span>
                command.Connection.Open();
                <span class="kwrd">switch</span> (typeCmmd)
                {
                    <span class="kwrd">case</span> TypeCommand.ExecuteNonQuery:
                        <span class="rem">// Retorna o número de linhas afetadas</span>
                        objRetorno = command.ExecuteNonQuery();<span class="kwrd">break</span>;
                    <span class="kwrd">case</span> TypeCommand.ExecuteReader:
                        <span class="rem">// Retorna um DbDataReader</span>
                        objRetorno = command.ExecuteReader(CommandBehavior.CloseConnection);<span class="kwrd">break</span>;
                    <span class="kwrd">case</span> TypeCommand.ExecuteScalar:
                        <span class="rem">// Retorna um objeto</span>
                        objRetorno = command.ExecuteScalar();<span class="kwrd">break</span>;
                    <span class="kwrd">case</span> TypeCommand.ExecuteDataTable:
                        <span class="rem">// Cria uma tabela</span>
                        var table = <span class="kwrd">new</span> DataTable();
                        <span class="rem">// Executa o comando e salva os dados na tabela</span>
                        var reader = command.ExecuteReader();
                        table.Load(reader);
                        <span class="rem">// Fecha o Reader</span>
                        reader.Close();
                        <span class="rem">// Retorna a tabela</span>
                        objRetorno = table;
                        <span class="kwrd">break</span>;
                }
            }
            <span class="kwrd">finally</span>
            {
                <span class="kwrd">if</span> (typeCmmd != TypeCommand.ExecuteReader)
                {
                    <span class="rem">// Sempre fecha a conexão com o BD</span>
                    command.Connection.Close();
                }
            }
            <span class="kwrd">return</span> objRetorno;
        }

    }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

{

/// Método que Cria um objeto DBCommand com os dados

/// da classe ConnectionDB utilizando Factory

/// DBCommand criado

public static DbCommand CreateCommand(String cmmdText, CommandType cmmdType, List<DbParameter> listParameter)

{

// Cria um novo factories de acordo com o nome do provedor

var factory = DbProviderFactories.GetFactory(ConnectionDB.ProviderName);

// Cria um objeto específico de conexão de acordo com o nome do provedor

var conn = factory.CreateConnection();

// Atribui a String de Conexão

conn.ConnectionString = ConnectionDB.ConnectionString;

// Cria um objeto command específico de acordo com o nome do provedor

var comm = conn.CreateCommand();

// Atribui o comando Text

comm.CommandText = cmmdText;

// Atribui o tipo de comando

comm.CommandType = cmmdType;

// Se existir algum parâmetro ele adiciona

// ao comando

if (listParameter != null)

{

foreach (var param in listParameter)

{

// Adicionando o parâmetro

comm.Parameters.Add(param);

}

// Retorna o comando criado

return comm;

}

/// <summary> Método responsável por criar um Parâmetro

///

/// List param = new List();

/// param.Add(criaParameter(nome, tipo, valor));

///

/// </summary>

/// <param name="nameParameter"> Nome do Parâmetro</param>

/// <param name="typeParameter"> Tipo do Parâmetro</param>

/// <param name="valueParameter"> Valor do Parâmetro</param>

/// <returns></returns>

public static DbParameter CreateParameter(String nameParameter, DbType typeParameter, Object valueParameter)

{

// Cria um novo factories de acordo com o nome do provedor

var factory = DbProviderFactories.GetFactory(ConnectionDB.ProviderName);

// Cria o Parâmetro e add seu valores

var param = factory.CreateParameter();

if (param != null)

{

param.ParameterName = nameParameter;

param.DbType = typeParameter;

param.Value = valueParameter;

}

// Retorna o Parâmetro criado

return param;

}

/// <summary> Método responsável por criar um Parâmetro

///

/// List param = new List();

/// param.Add(criaParameter(nome, tipo, valor));

///

/// </summary>

/// <param name="nameParameter"> Nome do Parâmetro</param>

/// <param name="typeParameter"> Tipo do Parâmetro</param>

/// <param name="valueParameter"> Valor do Parâmetro</param>

/// <param name="direction">Direction </param>

/// <returns></returns>

public static DbParameter CreateParameter(String nameParameter, DbType typeParameter, Object valueParameter, ParameterDirection direction)

{

// Cria um novo factories de acordo com o nome do provedor

var factory = DbProviderFactories.GetFactory(ConnectionDB.ProviderName);

// Cria o Parâmetro e add seu valores

var param = factory.CreateParameter();

if (param != null)

{

param.ParameterName = nameParameter;

param.DbType = typeParameter;

param.Value = valueParameter;

param.Direction = direction;

}

// Retorna o Parâmetro criado

return param;

}

/// <summary> Método que cria um comando e executa esse comando.

///

/// </summary>

/// <param name="cmmdText">String SQL ou StoredProcedure</param>

/// <param name="cmmdType">Tipo de Commando (Text ou Stored Procedure)</param>

/// <param name="listParameter">Lista de parâmetros</param>

/// <param name="typeCmmd">Comando a ser executado (ExecuteNonQuery, ExecuteReader, ExecuteScalar, ExecuteDataTable)</param>

/// <returns>Object</returns>

public static Object ExecuteCommand(String cmmdText, CommandType cmmdType, List<DbParameter> listParameter, TypeCommand typeCmmd)

{

// Cria comando com os dados passado por parâmetro

var command = CreateCommand(cmmdText, cmmdType, listParameter);

// Cria objeto de retorno

Object objRetorno = null;

try

{

// Abre a Conexão com o banco de dados

command.Connection.Open();

switch (typeCmmd)

{

case TypeCommand.ExecuteNonQuery:

// Retorna o número de linhas afetadas

objRetorno = command.ExecuteNonQuery();break;

case TypeCommand.ExecuteReader:

// Retorna um DbDataReader

objRetorno = command.ExecuteReader(CommandBehavior.CloseConnection);break;

case TypeCommand.ExecuteScalar:

// Retorna um objeto

objRetorno = command.ExecuteScalar();break;

case TypeCommand.ExecuteDataTable:

// Cria uma tabela

var table = new DataTable();

// Executa o comando e salva os dados na tabela

var reader = command.ExecuteReader();

table.Load(reader);

// Fecha o Reader

reader.Close();

// Retorna a tabela

objRetorno = table;

break;

}

finally

{

if (typeCmmd != TypeCommand.ExecuteReader)

{

// Sempre fecha a conexão com o BD

command.Connection.Close();

}

return objRetorno;

}

TypeCommand.cs

publicenum TypeCommand

    {
        ExecuteNonQuery
        ,ExecuteReader
        ,ExecuteScalar
        ,ExecuteDataTable
    }

{

ExecuteNonQuery

,ExecuteReader

,ExecuteScalar

,ExecuteDataTable

}

Pronto. criando os arquivos acima com um projeto Class Library fica fácil criar utilizar esta biblioteca.

Lembrando que em cada aplicação você deve criar uma ConnectioString no arquivo de configuração como o exemplo abaixo.

Config.cs

&lt;connectionStrings&gt;
    &lt;add name=<span class="str">"ConnectionString"</span> connectionString=<span class="str">"Data Source=.SQLEXPRESS;Initial Catalog=[DATABASENAME];Persist Security Info=True;User ID=sa;Password=XXXX"</span> providerName=<span class="str">"System.Data.SqlClient"</span> /&gt;
  &lt;/connectionStrings&gt;

Para ficar mais claro a criação deste projeto , criei os vídeos explicativos que seguem abaixo.

</connectionStrings>

Para ficar mais claro a criação deste projeto , criei os vídeos explicativos que seguem abaixo.

Parte #1

Parte#2

Sobre o autor

Fernando Parmezani

Analista de Sistemas, é especialista em tecnologia Microsoft de desenvolvimento, especialmente em Net FrameWork, participou e vários projetos de criação e desenvolvimento de aplicações web e desktop para várias empresas do ramo comercial, industrial e prestação de serviços com mais de 8 anos de experiência na área. Atualmente é o Analista Desenvolvedor Sênior.

9 Comentários

Amarildo 10/12/2014 Responder

Excelente video, parabens Fernando, aprendi muito com essas duas video aulas, estou aprendendo, abraço

Fernando Parmezani 14/01/2015 Responder

Obrigado Amarildo,

Veja os outros vídeos da série, ok!

Matheus PL 28/01/2015 Responder

Fernando parabéns muito bom mesmo seus vídeos, só uma duvida tenho uma stored procedure e preciso passar parametros como ficaria a chamada do método ExecuteCommand

Fernando Parmezani 28/01/2015 Responder

Oi Matheus, obrigado

Você deve criar os chamados Parameters.
O Vídeo já tem algum tempo, se a solução não tiver esta opção, me envia um email e te mando o projeto bem mais completo.

email: fernando@parmezani.net

Jardel Oliveira 19/11/2015 Responder

Fernando.
Bom Dia!
Parabéns pelo trabalho.
Estou tentando inserir imagem sem sucesso.
Poderia me esclarecer como faria para inserir imagem no banco utilizando as classes genéricas?

Jardel Oliveira
Lindomar 29/04/2017 Responder

Bom dia Fernando Você poderia nos dar uma dica de como usar uma transaction

Fernando Parmezani 30/04/2017 Responder

Opa,

Vou tentar, qual sua dúvida?

Lindomar 02/05/2017 Responder

Bom dia,
Então nos exemplos ADO.NET – Acesso ao banco de dados com classe genérica você mostrou um método insert.
Minha duvida seria como fazer 2 insert’s em tabelas diferentes
Exemplo: “TABELAS”
Venda
VendaItem

Desde já obrigado

Lindomar 02/05/2017 Responder

PS: Esqueci de mencionar fazer 2 insert’s usando uma Transaction (Transação)

Adicione um comentário

This site uses Akismet to reduce spam. Learn how your comment data is processed.