Desenvolvendo
uma aplicação CRUD com Desing Patterns – (parte 4).
Aplicando o Padrão Singleton...
"A
desconfiança é a mãe da segurança." [Scudéry, Madeleine]
Olá
pessoal.
Este é o quarto artigo da série e continuaremos a criação de nosso framework implementando uma classe para manter a conexão com o banco de dados utilizando o padrão de projeto Singleton.
Se analisarmos o código proposto no primeiro artigo da
série(//www.devmedia.com.br/articles/viewcomp.asp?comp=14689), é possível
verificar que nossa string de conexão com o banco de dados foi declarada como
um campo da classe, sendo assim, visível para todos os métodos da mesma. O
problema é que geralmente teremos varias classes onde iremos utilizar o acessa
a dados. Será então que teremos de declarar nossa string de conexão em todas as
classes de nosso sistema?
Para resolver este problema, pode-se então criar uma
classe que retornará a conexão com o banco de dados, centralizando o código de
conexão com o banco e disponibilizando uma forma mais simples para que as
classes do sistema tenham acesso à conexão com o banco de dados. No nosso caso
esta classe irá utilizar o padrão Singleton.
O modelo Singleton faz parte dos padrões de projeto
criacionais e se ocupa pela instanciação de objetos.
O padrão Singleton faz com que uma classe só possa ter
uma instância e tenha um ponto único de acesso a ela. Para garantir que uma
classe só poderá ter uma instância, seu construtor padrão é restringido com o
modificador private, o que determina que apenas a própria classe possa se
instanciar e, em seguida, á disponibilizado um único método estático que
retorna a única instância da classe.
Nota-se que o recurso do banco de dados não aceita
conexões infinitas e que a conexão com o banco de dados deve ser fechada após
sua utilização.
Este modelo é interessante, pois desta forma, se a
conexão não for fechada por alguma classe, o próximo acesso retornará erro uma
vez que tentará abrir uma conexão já aberta.
O código fonte está bem documentado explicando os
passos da construção da classe.
Dando continuidade ao framework que iniciamos no
artigo 3(link do artigo 3), vamos adicionar uma nova pasta ao projeto por nome Connection
e nesta pasta iremos acrescentar uma classe por nome ConnectionDB. Sua solução
deve ficar como na figura 1.
O próximo passo será alterar o
namespace de nossa classe por GenericFrameWork.
Para implementação desta classe,
iremos fazer as seguintes referencias: System.Web e System.Configuration. O
código fonte completo segue na listagem 1.
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data.SqlClient; using System.Configuration; using System.Web.Configuration; namespace GenericFrameWork { /// <summary> /// Classe responsável
por retornar a instância única da string de conexão. /// <remarks> /// Utilizo o padrão criacional de
projeto Singleton. /// </remarks> /// </summary> public class ConnectionDB { /// <summary> /// O objeto intance é a
instância única da própria classe ConnectionDB; /// Seus modificadores
são: /// *private = indica que o objeto só poderá
ser acessado dentro da classe de origem, /// *static = define o atributo instance como
um objeto da classe, e não da instância, /// *readonly = determina que seu valor só
poderá ser alterado na sua declaração ou dentro de um método construtor. /// </summary> private
static readonly
ConnectionDB instance = new ConnectionDB(); /// <summary> /// Restringimos o
construtor padrão com o modificador private, o que determinda /// que apenas a própria
classe possa se instanciar, ou seja, não pode ser /// instanciado
diretamente. /// </summary> private
ConnectionDB() { } /// <summary> /// Método estático que
retorna a única instância da classe. /// Somente atravéz deste
método as outras classes do sistema poderão utilizar /// a instância de
ConnectionDB. /// </summary> /// <returns>Instância
única da classe</returns> public static
ConnectionDB GetInstance() { return
instance; } /// <summary> /// Método responsável
por retornar uma conexão com o banco de dados. /// </summary> /// <returns>objeto de
conexão com o banco de dados.</returns> public SqlConnection
GetConnection() { // Crio
um objeto do tipo ConnectionStringSettings para receber a string de conexão
criada no webConfig ConnectionStringSettings
getString = WebConfigurationManager.ConnectionStrings["ConnectionString"] as ConnectionStringSettings; // Descriptografa a string de conexão que está no WebConfig
para que a mesma possa ser usada. string stringConexao = Criptografia.decriptografar(getString.ConnectionString); // Retorna a string de conexão. return new
SqlConnection(stringConexao); } #region Propriedades /// <summary> /// String de Conexão com
o banco de Dados. /// </summary> public
string ConnectionString { get { // Chamo o método GetConnection para conhecer a
string de conexão com o banco de dados. string stringConexao =
GetConnection().ConnectionString; // Retorna a string de conexão com o banco de dados. return stringConexao; } } /// <summary> /// Nome do Provedor. /// </summary> public
string ProviderName { get { string
providerName = ConfigurationManager.ConnectionStrings["ConnectionString"].ProviderName; // Retorna a string de conexão. return providerName; } } #endregion } } |
Listagem
1.
É
interessante notar que já estamos utilizando a classe de criptografia que
construímos no artigo 3(//www.devmedia.com.br/articles/viewcomp.asp?comp=15378&fb=1).
Agora já centralizamos toda a parte
de conexão com o banco.
Lembre-se que para utilizar esta classe será necessário
declarar a string de conexão no Web.config, e a mesma deve estar criptografada
por nossa classe. Iremos fazer isto mais a frente, logo após a conclusão de
nosso framework.
No
próximo artigo iremos criar nossa classe de acesso a dados genérica.
Um
abraço e qualquer dúvida podem mandar por email.
http://twitter.com/vitormeriat
Até a próxima!!!
“A sorte favorece as mentes bem trabalhadas...”