Arquivos do Blog
Padrões de Projeto em C#. Parte I: Singleton
E ai pessoal, hoje vou começar uma série de artigos ensinando a implementar diversos padrões de projeto, ou design patterns no C#.
Hoje vou falar do Singleton.
Singleton, é um termo inglês que expressa quando resta apenas uma carta nas mãos em um jogo de baralho. É exatamente isso que é o papel do Singleton em um projeto de software, permitir apenas uma instância de um objeto naquele escopo de execução do software.
Onde devo usar?
É interessante implementar o Singleton quando precisamos garantir que existirá apenas uma instância de um objeto, geralmente usado em objetos de banco de dados para evitar abrir conexões em excesso ou para objetos responsáveis pelo log da aplicação.
Para mais detalhes sobre o Singleton, consulte a página da Wikipédia sobre Singleton clicando aqui
Vamos criar nossa classe Singleton, em meu exemplo vou simular uma classe de conexão com o banco de dados chamada ConexaoSingleton:
public sealed class ConexaoSingleton
{
private static readonly ConexaoSingleton = new ConexaoSingleton();
private ConexaoSingleton(){}
public static ConexaoSingleton Instance
{
get
{
return instance;
}
}
}
O construtor da classe é protegido e o objeto só pode ser instanciado por ele mesmo.
Em toda a aplicação, sempre que fizer ConexaoSingleton.Instance, a classe irá retornar a mesma instância da classe ConexaoSingleton
Como Trabalhar com Repositório Genérico no Entity Framework
Olá a todos, hoje vou escrever um post falando como podemos implementar um Repositório Genérico usando o Entity Framework.
Primeiramente para quem ainda não sabe, irei explicar resumidamente o que é um repositório.
O Repositório ou Repository, é um objeto geralmente associado a um objeto de negócio como um objeto cliente, por exemplo, responsável por acessar a base de dados, como no exemplo abaixo:
Objeto de negócio:
public class Cliente
{
public int Id {get; set; }
public int Nome {get; set; }
}
Repositório:
public class RepositorioCliente
{
public void Adiciona(Cliente cliente)
{
}
public void Edita(Cliente cliente)
{
}
public Cliente ObtemPorId(int Id)
{
}
public void Deleta(Cliente cliente)
{
}
}
Para usar faríamos assim:
repositorioCliente repositorio = new RepositorioCliente(); repositório.Adiciona(Cliente);
Seguindo o exemplo acima, em um sistema mais complexo teríamos que criar um RepositorioFornecedor, um RepositorioFatura etc.. criando os respectivos métodos de acesso a dados para cada repositório.
Vamos então implementar um repositório genérico, isto é, um repositório padrão
que terá os métodos de criar, editar, deletar e obter onde precisamos apenas
informar qual objeto de negócio desejamos trabalhar no repositório genérico.
Vamos lá, primeiro vamos criar uma interface IRepositorio:
public interface IRepositorio<T> where T : class
{
void Adicionar(T item);
void Remover(T item);
void Editar(T item);
T ObtemPorId(object id);
IQueryable Tudo();
}
Note que a interface possui um parâmetro genérico T, iremos tipar o repositório para o objeto de negócio que desejamos usar.
Vamos agora criar o repositório genérico:
public class Repositorio<T> : IDisposable, IRepositorio where T : class
{
protected readonly DbContext contexto;
public Repositorio(DbContext contexto)
{
this.contexto = contexto;
}
public virtual void Adicionar(T item)
{
contexto.Set<T>().Add(item);
contexto.SaveChanges();
}
public virtual void Remover(T item)
{
contexto.Set<T>().Remove(item);
contexto.SaveChanges();
}
public virtual void Editar(T item)
{
contexto.Entry(item).State = EntityState.Modified;
contexto.SaveChanges();
}
public virtual T ObtemPorId(object id)
{
return contexto.Set<T>().Find(id);
}
public virtual IQueryable Tudo()
{
return contexto.Set<T>();
}
public void Dispose()
{
contexto.Dispose();
}
}
Simples, agora para usar fazemos o seguinte:
using (IRepositorio repositorio = new Repositorio<Cliente>())
{
repositorio.Adiciona(objetoCliente);
}
Ou para uma consulta com LINQ:
using (IRepositorio repositorio = new Repositorio<Cliente>())
{
var lista = from p in repositório.Tudo()
select p;
}
Com este exemplo podemos ver o potencial que o Entity Framework nos oferece para acesso a dados.
Observação:
É importante o método Tudo() ser do tipo IQueryable, dessa forma o IQueryable armazena as operações que estamos fazendo nele com o LINQ e executa a consulta no banco de dados apenas quando vamos acessar os dados.
