none
Como fechar e descartar conexão com banco de dados automaticamente ? RRS feed

  • Pergunta

  • Olaa,

    Estou construindo um Provedor de dados para SQL server, a intenção do mesmo é concentrar toda parte de tecnologia, o mesmo será usado pela Camada DAL, segue abaixo o mesmo:

        public class ProvedorSQLServer
        {
           private SqlConnection connection;
    
           public ProvedorSQLServer(string StringDeConexao) {
    
                this.connection= new SqlConnection(StringDeConexao);
    	    this.connection.Open();
            }
    
           public string ObtemDadoEscalar(SqlCommand comandoSql){
    	   
    		....
    		....
    		
           }
    
           public void RealizaInsertDeleteUpdate(SqlCommand comandoSql)
           {
    		....
    		....
           }
    
           public DataTable PreencheDataTable(SqlCommand comandoSql)
           {
    		....
    		....
           }
      }

    Como pode ser observado a Conexão é aberta no construtor, pois minha intenção é que quem estiver utilizando a classe não se preocupe em abrir a conexão, mas da mesma forma que não quero que haja a preocupação em abrir a conexão não quero que haja a preocupação em fechá-la, diante do respectivo cenário segue as dúvidas:

    1) Qual a forma mais correta de realizar o Close() e o Dispose() nessa conexão de forma Automatica, devo utilizar um Destrutor (e dentro do mesmo realizar o Close() e Dispose() da conexão) ? devo implementar a interface Idisposable ? Ou qual outra melhor forma de fechar e descartar a conexão automaticamente assim que a mesma não estiver sendo mais utilizada  ?

    Desde já, Agradeço pela atenção.

    sexta-feira, 16 de novembro de 2012 17:17

Respostas

  • Rodrigo,

    Ao chamar do método Dispose() da classe SqlConnection, ela nada mais do que internamente limpa as propriedades utilizadas pelo objeto e fecha a conexão, veja o comportamento do método:

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            this._userConnectionOptions = null;
            this._poolGroup = null;
            this.Close();
        }
        this.DisposeMe(disposing);
        base.Dispose(disposing);
    }

    Talvez a simples implementação da interface IDisposable seja o suficiente:

    public class ProvedorSQLServer : IDisposable
    {
        private SqlConnection connection;
    
        public ProvedorSQLServer(string StringDeConexao)
        {
            this.connection = new SqlConnection(StringDeConexao);
            this.connection.Open();
        }
    
        public string ObtemDadoEscalar(SqlCommand comandoSql)
        {
            throw new NotImplementedException();
        }
    
        public void RealizaInsertDeleteUpdate(SqlCommand comandoSql)
        {
            throw new NotImplementedException();
        }
    
        public DataTable PreencheDataTable(SqlCommand comandoSql)
        {
            throw new NotImplementedException();
        }
    
        public void Dispose()
        {
            this.connection.Dispose();
        }
    }

    Basta usar a sua classe no contexto do using para invocar o dispose automaticamente no termino do escopo:
    using (ProvedorSQLServer p = new ProvedorSQLServer("Sua string de conexão"))
    {
        //Código e mais código....
    }
    //Ao sair do escopo do "using" a conexão será fechada automaticamente


    Muitos recomendam usar da classe SqlConnection dentro do escopo using, então se usarmos na sua classe custom para SqlConnection vamos obter praticamente o mesmo resultado:
    using (SqlConnection con = new SqlConnection("String de conexão"))
    {
        //Código
    }



    Vitor Mendes | Seu feedback é muito importante para todos!
    Visite o meu site: http://www.vitormendes.com.br/


    • Sugerido como Resposta Murilo Kunze sexta-feira, 16 de novembro de 2012 17:55
    • Editado Vitor Mendes sexta-feira, 16 de novembro de 2012 17:56
    • Não Sugerido como Resposta _dev sexta-feira, 16 de novembro de 2012 22:19
    • Marcado como Resposta _dev sexta-feira, 16 de novembro de 2012 23:52
    sexta-feira, 16 de novembro de 2012 17:47
  • Rodrigo,

    Caso não seja utilizando dentro do contexto "using" e não seja invocado o método Dispose() explicitamente a conexão permanecera aberta.

    Vitor Mendes | Seu feedback é muito importante para todos!
    Visite o meu site: http://www.vitormendes.com.br/

    • Marcado como Resposta _dev sexta-feira, 16 de novembro de 2012 23:52
    sexta-feira, 16 de novembro de 2012 23:23

Todas as Respostas

  • Rodrigo,

    Ao chamar do método Dispose() da classe SqlConnection, ela nada mais do que internamente limpa as propriedades utilizadas pelo objeto e fecha a conexão, veja o comportamento do método:

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            this._userConnectionOptions = null;
            this._poolGroup = null;
            this.Close();
        }
        this.DisposeMe(disposing);
        base.Dispose(disposing);
    }

    Talvez a simples implementação da interface IDisposable seja o suficiente:

    public class ProvedorSQLServer : IDisposable
    {
        private SqlConnection connection;
    
        public ProvedorSQLServer(string StringDeConexao)
        {
            this.connection = new SqlConnection(StringDeConexao);
            this.connection.Open();
        }
    
        public string ObtemDadoEscalar(SqlCommand comandoSql)
        {
            throw new NotImplementedException();
        }
    
        public void RealizaInsertDeleteUpdate(SqlCommand comandoSql)
        {
            throw new NotImplementedException();
        }
    
        public DataTable PreencheDataTable(SqlCommand comandoSql)
        {
            throw new NotImplementedException();
        }
    
        public void Dispose()
        {
            this.connection.Dispose();
        }
    }

    Basta usar a sua classe no contexto do using para invocar o dispose automaticamente no termino do escopo:
    using (ProvedorSQLServer p = new ProvedorSQLServer("Sua string de conexão"))
    {
        //Código e mais código....
    }
    //Ao sair do escopo do "using" a conexão será fechada automaticamente


    Muitos recomendam usar da classe SqlConnection dentro do escopo using, então se usarmos na sua classe custom para SqlConnection vamos obter praticamente o mesmo resultado:
    using (SqlConnection con = new SqlConnection("String de conexão"))
    {
        //Código
    }



    Vitor Mendes | Seu feedback é muito importante para todos!
    Visite o meu site: http://www.vitormendes.com.br/


    • Sugerido como Resposta Murilo Kunze sexta-feira, 16 de novembro de 2012 17:55
    • Editado Vitor Mendes sexta-feira, 16 de novembro de 2012 17:56
    • Não Sugerido como Resposta _dev sexta-feira, 16 de novembro de 2012 22:19
    • Marcado como Resposta _dev sexta-feira, 16 de novembro de 2012 23:52
    sexta-feira, 16 de novembro de 2012 17:47
  • Prezado Vitor Mendes,

    Muito obrigado pela atenção, pelo que pude entender ao usar o Using, o mesmo já invoca automaticamente o método Dispose no termino do escopo. Mas levando-se em consideração o não uso do Using, existe outra possibilidade da conexão ser fechada automaticamente quando a mesma não estiver sendo utilizada ?

    Novamente Obrigado.

    sexta-feira, 16 de novembro de 2012 22:27
  • Rodrigo,

    Caso não seja utilizando dentro do contexto "using" e não seja invocado o método Dispose() explicitamente a conexão permanecera aberta.

    Vitor Mendes | Seu feedback é muito importante para todos!
    Visite o meu site: http://www.vitormendes.com.br/

    • Marcado como Resposta _dev sexta-feira, 16 de novembro de 2012 23:52
    sexta-feira, 16 de novembro de 2012 23:23
  • Prezado Vitor,

    Minha dúvida foi sanada.

    Grato pela atenção,

    sexta-feira, 16 de novembro de 2012 23:52