Dicas MVC

Prévia do material em texto

Postado em 12 DE AGOSTO DE 2014
Utilizar o HtmlHelper para criar um DropDownList em uma View do ASP.NET MVC pode ser um 
desafio para iniciantes em MVC, veja como facilitar seu trabalho utilizando uma técnica simples.
Existem diversas formas de popular e controlar o estado de um DropDownList gerado pelo 
HtmlHelper, algumas podem dar um certo trabalho e confundir o programador que está iniciando 
com ASP.NET MVC e ainda não dominou todas as técnicas.
Conforme o código a seguir, criamos na pasta Models uma classe chamada Cliente que será 
utilizada para popular um DropDownList, observe que foi criado um método que retorna uma lista 
de clientes pré definidos (apenas para facilitar a demonstração).
1 using System.Collections.Generic;
2
3 namespace DropDownList.Models
4 {
5 public class Cliente
6 {
7 public int ClienteId { get; set; }
8 public string Nome { get; set; }
9
10 public List<Cliente> ListaClientes()
11 {
12 return new List<Cliente>
13 {
14 new Cliente { ClienteId = 1, Nome = "Eduardo Pires"},
15 new Cliente { ClienteId = 2, Nome = "João Silva"},
16 new Cliente { ClienteId = 3, Nome = "Fulano de Tal"}
17 };
18 }
19 }
20 }
A classe de Controller possui dois ActionResults, um para Get e um para Post, no primeiro 
ActionResult é criada uma ViewBag utilizando um nome que facilite o entendimento (no caso o 
ClienteId).
Esta ViewBag recebe uma estrutura DropDownList que é criada através da classe SelectList e os 
parâmetros utilizados são: Source, Value, Name (Origem do dado [Método ListarClientes], valor do 
elemento e nome a ser exibido). Estes parâmetros precisam coincidir com as propriedades da 
estrutura do seu dado (classe Cliente).
1 using System.Web.Mvc;
2 using DropDownList.Models;
3
4 namespace DropDownList.Controllers
5 {
6 public class HomeController : Controller
7 {
8 public ActionResult Index()
9 {
10 // Criando uma ViewBag com uma lista de clientes.
11 // Utilizo o nome da ViewBag com ClienteId apenas
12 // para facilitar o entendimento do código
13 // new SelectList significa retornar uma
14 // estrutura de DropDownList
15 ViewBag.ClienteId = new SelectList
Uma técnica simples para utilizar DropDownList no ASP.NET MVC
sexta-feira, 12 de junho de 2015 20:18
 Página 1 de Dicas MVC 
16 (
17 new Cliente().ListaClientes(),
18 "ClienteId",
19 "Nome"
20 );
21
22 return View();
23 }
24
25 [HttpPost]
26 // No Post o valor selecionado do DropDownList
27 // será recebido no parametro clienteId
28 public ActionResult Index(string clienteId)
29 {
30 // O quarto parametro "clienteId" diz qual é o ID
31 // que deve vir pré-selecionado ao montar o DropDownList
32 ViewBag.ClienteId = new SelectList
33 (
34 new Cliente().ListaClientes(),
35 "ClienteId",
36 "Nome",
37 clienteId
38 );
39
40 return View();
41 }
42 }
43 }
Ao observar o retorno da criação do SelectList no Quick Watch fica mais fácil de entender a 
estrutura retornada
Para o Razor HtmlHelper criar corretamente seu DropDownList basta informar (no formato String) 
o nome da ViewBag que contém a estrutura de dados, foi adicionado um segundo parâmetro para 
criar um elemento em branco na primeira posição, assim evitando que o primeiro item seja 
selecionado por engano.
1 @{
2 ViewBag.Title = "Teste DropDownList";
3 }
4
5 @using (Html.BeginForm("Index", "Home", FormMethod.Post))
6 {
 Página 2 de Dicas MVC 
6 {
7 @Html.AntiForgeryToken()
8 <div>
9 <h4>@ViewBag.Title</h4>
10 </div>
11 <div class="row">
12 <div class="col-md-8">
13 Escolha o cliente:
14 @* Passando o Nome da ViewBag *@
15 @Html.DropDownList("ClienteId", String.Empty)
16
17 <input type="submit" value="Enviar" class="btn btn-
default" />
18 </div>
19 </div>
20 }
O resultado ficará assim
A View possui um Form que fará um post para a segunda ActionResult da Controller que já espera 
receber o valor do item selecionado no DropDownList, o mesmo processo é repetido só que no 
final da criação da estrutura da SelectList é repassado mais um parâmetro que é o valor do item 
que foi selecionado na tela anterior, esse parâmetro garante que o foco da seleção mantenha-se 
no item que foi previamente selecionado.
Com isso vimos que é muito simples utilizar o DropDownList utilizando esta técnica, caso queira 
treinar basta criar um projeto simples ASP.NET MVC e implementar o código disponibilizado aqui.
Caso desconheça o uso de ViewBag leia este meu artigo que explica os conceitos:
ASP.Net MVC – ViewData, ViewBag e TempData
Até a próxima!
Publicado em ASP.NET, ASP.NET MVC, DICAS por EDUARDO PIRES. Marque LINK PERMANENTE.
15 IDEIAS SOBRE “UMA TÉCNICA SIMPLES PARA UTILIZAR DROPDOWNLIST NO ASP.NET MVC”
 Página 3 de Dicas MVC 
Renato Haddad
Março, 2014
O objetivo deste artigo é ilustrar como criar um Repositório de Dados no Entity Framework 6 com classes em Visual C# 5. O uso de repositório é 
antigo, diversas tecnologias usam, e pesquisando na internet encontrei diversos exemplos pobres em funcionalidades, muitas ve zes alguns que torna 
o trabalho do desenvolvedor muito braçal, e ao longo do projeto, compromete a produtividade. Sendo assim, ao longo de anos do EF e algumas 
conversas com o Rowan Miller, Program Manager do EF na MS/EUA, resolvi escrever este artigo para ajuda -los a montar uma arquitetura genérica 
de repositório de dados.
Em alguns momentos críticos de um projeto, uma decisão de qual caminho seguir é fundamental. Isto vale para qualquer tipo de projeto, e em TI 
vale desde uma simples planilha no Excel até projetos complexos de E-Commerce. E, quando adicionamos o uso de banco de dados, projeto em 
equipes (centralizadas ou não), começa a ficar crítico. Isto sem falar em outras variáveis como extensibilidade, camadas de d ados, persistência, outras 
plataformas, etc. Enfim, o projeto que irei criar será uma solução com diversos projetos separados, a fim de focar em cada ca mada.
Os pré-requisitos para este artigo são conhecimento intermediário de C# e o Visual Studio .NET 2013.
Solução Repositório
A primeira coisa a fazer é criar uma solução vazia. Para isto, abra o Visual Studio 2013, selecione a opção File / New / Proj ect ou CTRL + SHIFT + N 
ou na janela inicial, clique em New Project. Conforme a figura 1, selecione Other Project Types / Visual Studio Solutions. Em Name digite 
Repositorio.MSDN e no Location você pode gravar onde desejar.
Figura 1 – Nova solução
Clique no botão OK e note no Solution Explorer que existe apenas a solução vazia. Quando falamos de repositório de dados, a p rimeira coisa que 
pensamos são as entidades, ou seja, a estrutura das classes, o que normalmente serão espelhadas em tabelas no banco de dados. Aqui, você pode 
abstrair diretamente do banco de dados utilizando o recurso do Model First do Entity Framework ou usar o fantástico recurso d e Code First. Mas, se 
neste projeto pretendo ter somente as entidades, não é certo pensar que a string de conexão com o banco de dados estará neste projeto. E, é 
verdade, neste projeto de DLL (Class Library) não teremos nada referente ao local onde as entidadesestão armazenadas. Para i sto, criarei um projeto 
de DAL (Data Access Layer), o qual usará as entidades que criaremos aqui.
Sendo assim, no Solution Explorer, clique com o botão direito e selecione Add / New Project. Conforme a figura 2, selecione a linguagem Visual C# e 
o template Class Library. Em Name digite Repositorio.Entidades e o Location deixe como está.
Figura 2 – Projeto de entidades
Clique no botão OK e deixe que o Visual Studio crie o projeto. Como é um projeto de Class Library, o VS já cria uma classe ch amada Class1, portanto, 
exclua-a. Em seguida, crie uma classe (Add/Class) chamada Cliente, conforme a estrutura a seguir. Basicamente é uma classe pública c ontendo as 
propriedades do objeto Cliente. Nem preciso dizer que você pode adicionar ou remover propriedades conforme a necessidade.
C#
namespace Repositorio.Entidades
{
 public class Cliente
 {
 public int ClienteID { get; set; }
 public string Nome { get; set; }
 public string CNPJ { get; set; }
 public string Endereco { get; set; }
 public string Telefone { get; set; }
 public bool Ativo { get; set; }
 }
}
Pergunta: Qual propriedade é a chave primária? No Entity Framework 6 se uma propriedade contém o nome da classe seguido de ID , esta será a 
chave primária. No caso da classe Cliente, a propriedade ClienteID será a chave. E, se eu quiser colocar outro nome, por exem plo ChaveCliente ou 
apenas ID? Aí você terá que usar o Data Annotations e informar o atributo [Key] para a respectiva propriedade.
Pronto, salve a classe e compile o projeto F6. Se houver algum erro nesta classe, corrija porque é necessário que o projeto e steja compilado 100% 
com sucesso.
O próximo passo é criar um novo projeto chamado Repositorio.DAL, o qual será o responsável por manipular a classe cliente cri ada. Sendo assim, no 
Solution Explorer, Add / New Project, escolha o template de Class Library. Em Name digite Repositorio.DAL e clique no botão O K, conforme a figura 
3.
Figura 3 – Projeto de DAL
Da mesma forma que o projeto anterior, exclua a Class1.cs criada automaticamente. O primeiro passo é adicionar as referências necessárias. Vamos 
utilizar o fantástico recurso do Nuget para esta tarefa, portanto, selecione o menu Tools / Library Package Manager / Package Manager Console. 
Conforme a figura 4, será aberta a janela do Nuget, então na combobox Default project, selecione Repositorio.DAL, afinal temo s dois projetos. Em 
seguida digite:
Install-Package EntityFramework
Figura 4 – Instalação do EF via Nuget
Desta forma o EF será instalado apenas neste projeto. Note ainda que a versão instalada é a 6.0.2, fato que é a mais recente no mercado no 
momento em que estou escrevendo este artigo. Não se assuste se for instalada uma versão superior do EF quando você for simula r estes códigos.
Em seguida, no projeto Repositorio.DAL, clique com o botão direito em References no Solution Explorer, selecione Add Referenc e. Na janela aberta, 
selecione Assemblies, localize o namespace System.Data.Entity, conforme a figura 5. Ao final, clique no botão OK.
Figura 5 – Adicionar referências do namespace
Repita o mesmo passo, mas referencie o projeto Repositorio.Entidades, conforme a figura 6, afinal o DAL irá gerenciar as enti dades.
Figura 6 – Adicionar referências do projeto de entidades
Contexto
Excelente, já temos todas as referências necessárias. Pressione F6 para compilar com sucesso. Em seguida, por uma questão de estrutura e 
organização, crie as pastas Contexto, Repositorios e Base, sendo que a Base é dentro de Repositorios. Na pasta Contexto, crie uma nova classe 
Repositório de Dados no Entity Framework 6
sábado, 13 de junho de 2015 00:44
 Página 4 de Dicas MVC 
organização, crie as pastas Contexto, Repositorios e Base, sendo que a Base é dentro de Repositorios. Na pasta Contexto, crie uma nova classe 
chamada BancoContexto.cs. Adicione os seguintes namespaces:
C#
using System.Data.Entity;
using Repositorio.Entidades;
Esta será a classe de contexto, portanto, para que ela gerencie toda a parte de banco de dados (criar, excluir e gerenciar o DB) é preciso herda-la de 
DbContext. Sendo assim, na assinatura da classe, adicione o : DbContext.
Em seguida, precisamos informar qual será a string de conexão, afinal o banco ainda não existe, e mesmo que existisse, em alg um lugar deverá estar 
o caminho completo da conexão, certo? Sendo assim, no construtor desta classe, adicione o : base(“chave”), sendo que a chave é exatamente o 
caminho da conexão que está descrito no arquivo App.Config ou Web.Config (se for ASP.NET). Mas atenção: no projeto Repositori o.DAL você NÃO 
deverá incluir esta chave no App.Config. Eu disse que a chave deverá constar apenas no projeto que irá solicitar o DAL.
Por default, chamei a chave de ConnDB e mantenha este nome para que possamos definir o padrão. Muitos chamam de strConn ou st ringConexao 
ou ConexaoBanco, enfim, o importante é que você defina o seu padrão e passe para todos os projetos que a utilizarão.
Dica: o ConnDB não pode ser dinâmico? Sim, isto não é nenhum problema pois se você analisar o construtor do DbContext irá not ar que há várias 
sobrecargas, as quais você pode construir o código para ser uma chave dinâmica.
Veja como está a classe até o momento:
C#
using System.Data.Entity;
using Repositorio.Entidades;
namespace Repositorio.DAL.Contexto
{
 public class BancoContexto : DbContext
 {
 public BancoContexto() : base("ConnDB") { }
}
}
Pressione F6 para compilar e certifique-se que está 100% com sucesso.
Interface da Classe
O que é uma interface de uma classe? Entendemos que interface é um contrato de como uma classe deve ser implementada, contend o todas as 
ações definidas, não as implementações de códigos de comportamentos. Um exemplo bem clássico é o famoso contrato de aluguel, o qual são 
definidos na interface (contrato padrão), os nomes do inquilino e proprietário, data de pagamento, multas, imóvel, etc. E, qu ando se redige o 
contrato do aluguel é que teremos os dados preenchidos em si.
No nosso caso, vamos criar na pasta Base uma interface chamada IRepositorio.cs, contendo todos os métodos que deverão ser imp lementados pela 
classe que usar esta interface como referência. Logo de cara, não se assuste com a assinatura da classe. Existe o TEntity dec larado, assim como quem 
é, ou seja, neste caso TEntity é uma class. Veja o código a seguir.
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Repositorio.DAL.Repositorios.Base
{
 interface IRepositorio<TEntity> where TEntity : class
 {
 IQueryable<TEntity> GetAll();
 IQueryable<TEntity> Get(Func<TEntity, bool> predicate);
 TEntity Find(params object[] key);
 void Atualizar(TEntity obj);
 void SalvarTodos();
 void Adicionar(TEntity obj);
 void Excluir(Func<TEntity, bool> predicate);
 }
}
Veja uma descrição detalhada dos métodos da interface para um melhor entendimento.
IQueryable<TEntity> 
GetAll();
Retorna todos os dados como IQueryable, ou seja, você pode retornar a lista e aplicar expressões Lambda para 
filtrar e classificar dados, por exemplo.
IQueryable<TEntity> 
Get(Func<TEntity, 
bool> predicate);
Retona todos os dados que atenderem a um critério passado em tempo de execução através de uma expressão 
Lambda. Neste caso, o Func é um delegate que será criado dinâmicamente, aplica-se o predicate para verificar se o 
dado atende ao critério. Aqui eu sei que dará um nó na cabeça, mas é preciso um conhecimento de C# avançado, 
então, pesquise sobre Delegates, Func e predicate.
TEntity Find(params 
object[] key);
Irá aplicar um filtro pela chave primária da classe em si. Quem é a chave primária?Não importa porque o Find recebe 
um array de object e efetua a pesquisa. Com isto, se você tiver uma chave composta, o Find se encarrega de tudo, 
basta você passar os dados e pronto.
void Atualizar(TEntity 
obj);
Recebe o objeto TEntity para efetuar o Update no banco.
void SalvarTodos(); Chama o método SaveChanges para efetivar todas as alterações no contexto.
void Adicionar(TEntity 
obj);
Recebe o objeto TEntity para efetuar o Insert no banco.
void 
Excluir(Func<TEntity, 
bool> predicate);
Este método irá excluir registros, sendo que a condição é dinâmica através de uma expressão Lambda e aplica-se o 
predicate para a condição passada.
 Página 5 de Dicas MVC 
Agora que já temos a interface criada, vamos criar e implementar a classe. Portanto, na pasta Base, adicione uma classe chama da Repositorio. 
Adicione os seguintes namespaces:
C#
using System.Data.Entity;
using Repositorio.DAL.Contexto;
Veja a classe completa com todas as implementações. Note que a classe é abstract para que ela não possa ser herdada. Na assin atura TEntity 
também é uma classe (where TEntity : class). Note que esta classe herda outras duas interfaces, sendo IDisposable (para que p ossa suportar o 
Dispose) e IRepositorio<TEntity>. Quando você digitar estas heranças, o Visual Studio coloca uma notação em azul dizendo que não estão 
implementadas. Então, basta selecionar as classes (IDisposable e IRepositorio) e dar um CTRL + . (ponto) duas vezes. Toda a e strutura das interfaces 
serão criadas nesta classe.
A seguir, para cada método você deverá digitar os códigos de acordo com a funcionalidade. Uma coisa interessante que você dev e estar 
questionando: como é que a classe sabe quando serão feitos os selects, updates, deletes e inserts? Pois é meu amigo, não é má gica não, são códigos 
dinâmicos que o Entity Framework implementa com o DbContext e DbSet. Cabe a nós informar a entidade e os critérios, o restant e é com o 
compilador que irá executar.
Certa ocasião, um aluno me perguntou: Mas Renato, e as instruções T-SQL ou PL-SQL, onde as escrevo? Eu disse: você não escreverá nenhuma linha 
disso nunca mais, pois quem é o responsável em montar toda a instrução é o compilador, tudo agora é dinâmico. Nem preciso diz er que o olhar de 
interrogação ficou estampado no rosto da pessoa. E, você leitor, aprofunde-se nestes códigos para entender e tirar mais proveito ainda.
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;
using Repositorio.DAL.Contexto;
namespace Repositorio.DAL.Repositorios.Base
{
 public abstract class Repositorio<TEntity> : IDisposable,
 IRepositorio<TEntity> where TEntity : class
 {
 BancoContexto ctx = new BancoContexto();
 public IQueryable<TEntity> GetAll()
 {
 return ctx.Set<TEntity>();
 }
public IQueryable<TEntity> Get(Func<TEntity, bool> predicate)
 {
 return GetAll().Where(predicate).AsQueryable();
 }
public TEntity Find(params object[] key)
 {
 return ctx.Set<TEntity>().Find(key);
 }
public void Atualizar(TEntity obj)
 {
 ctx.Entry(obj).State = EntityState.Modified;
 }
public void SalvarTodos()
 {
 ctx.SaveChanges();
 }
public void Adicionar(TEntity obj)
 {
 ctx.Set<TEntity>().Add(obj);
 }
public void Excluir(Func<TEntity, bool> predicate)
 {
 ctx.Set<TEntity>()
 .Where(predicate).ToList()
 .ForEach(del => ctx.Set<TEntity>().Remove(del));
 }
public void Dispose()
 {
 ctx.Dispose();
 }
 }
}
Aqui requer uma explicação mais detalhada dos métodos, afinal, a interface diz o método e a classe é que diz como o 
código será implementado.
O primeiro é a declaração do BancoContexto, já que tudo depende dele, nada mais justo que referenciá -lo.
C#
BancoContexto ctx = new BancoContexto();
Já o método GetAll, simplesmente recebe a entidade em si, Cliente por exemplo, e retorna um IQueryable (lista) completa, um “ Select *”.
C#
public IQueryable<TEntity> GetAll()
{
 return ctx.Set<TEntity>();
}
O método Get é o melhor de todos porque além de ser 100% dinâmico, você usa expressões Lambda o tempo todo. Sempre digo que t odo 
 Página 6 de Dicas MVC 
O método Get é o melhor de todos porque além de ser 100% dinâmico, você usa expressões Lambda o tempo todo. Sempre digo que t odo 
desenvolvedor DEVE saber Lambda, pois sem isto não é possível viver de forma produtiva. Este método Get retorna também uma li sta IQueryable, 
no entanto, o parâmetro de entrada é uma Func da entidade, Cliente por exemplo, o qual será passado o critério a ser aplicado no predicate. Nos 
bastidores, você deverá passar uma expressão Lambda, por exemplo “c => c.Nome.Contains("microsoft")”. Já na implementação, é chamado o 
método GetAll, explicado anteriomente, e aplica-se o filtro Where com a Lambda recebida na entrada.
C#
public IQueryable<TEntity> Get(Func<TEntity, bool> predicate)
{
 return GetAll().Where(predicate).AsQueryable();
}
Pergunta: Quantas vezes a classe vai ao banco de dados? Duas correto, pois primeiro executa o GetAll, vai no banco e retorna todos os dados, e em 
seguida vai no banco novamente para aplicar o Where, certo? Errado! A expressão Lambda é montada em sua árvore de expressões, e no momento 
em que irá ser usada ou retornada a quem chamou é que vai ao banco de dados. Neste caso o GetAll será um subterfújio para apl icar o predicate 
com o critério, ou seja, irá apenas uma vez ao banco de dados. O legal aqui é rodar este método com o Profile do SQL ativado para se ver a 
instrução T-SQL montada para isto.
O Find busca automaticamente pela chave primária, sendo que a entrada do parâmetro é um array de object, ou seja, pode ser ap enas um campo ou 
um conjunto que compõe a chave composta.
C#
public TEntity Find(params object[] key)
{
 return ctx.Set<TEntity>().Find(key);
}
O Atualizar recebe a entidade Cliente, por exemplo, e atribui o Modified para o EntityState, informando ao contexto que tal e ntidade foi modificada. 
Atenção: aqui não é feito nenhum Update no banco, pois quem é o responsável por isto é o SaveChanges do método Salvar.
C#
public void Atualizar(TEntity obj)
{
 ctx.Entry(obj).State = EntityState.Modified;
}
O SalvarTodos chama o SaveChanges do contexto e efetiva todas as operações de Update, Insert ou Delete no banco de dados. O c ontexto do Entity 
Framework é uma forma de manipular dados na memória apenas, nada no banco de dados, portanto, você pode ter muitas entidades no contexto 
(até o limite da memória da máquina), sendo que cada entidade pode ter operações distintas de Update, Delete ou Insert. Deixe os dados na 
memória e quando precisar, chame o SaveChanges para efetivar fisicamente no banco.
Pergunta 1: Posso colocar 300 entidades no mesmo contexto no EF 6? Sim e deve, pois já fiz testes de performance em relação à quantidade de 
entidades no mesmo contexto, e não há nenhum problema de lentidão. Em projetos médios é comum ter muitas entidades no mesmo c ontexto, e 
isto até facilita o gerenciamento, pois basta um SaveChanges e pronto.
Pergunta 2: Mas não é aconselhável dividir as entidades em diversos contextos? No EF 6 não é preciso, pois o gerencimento do contexto em apenas 
um facilita muito. Já em versões anteriores era um problema sério. No EF 4 e 5 tive projetos em diversos contextos, o que cau sou um problema sério 
de união de contextos, transações em diferentes contextos e atualizações de entidades. Dica: migre urgente para o EF 6, no mí nimo.
C#
public void SalvarTodos()
{
 ctx.SaveChanges();
}
O Adicionar recebe a entidadeCliente, por exemplo, e adiciona o registro através do método Add. Nos bastidores a instrução I nsert será criada 
devidamente correta com todos os parâmetros declarados para proteger qualquer tentativa de injeção de SQL.
Pergunta 1: Posso incluir diversos objetos de uma vez? Sim e deve. Como tudo estará no contexto, ou seja na memória, vá inclu indo quantos 
registros quiser em todas as entidades, e ao final chame o SalvarTodos apenas uma vez.
Pergunta 2: Se eu tiver uma lista de clientes a serem incluídos, preciso adicionar e salvar cada um? Quando se tem uma lista, você deve aplicar uma 
Action para disparar o ForEach a partir da lista, sendo que a Action será o delegate que irá chamar o Adicionar, passando cad a um dos elementos da 
lista. Ao final de tudo é que chama-se o SalvarTodos apenas uma vez. Preste atenção mais adiante no projeto de Console, pois iremos incluir alguns 
clientes desta forma. E, prepare o balde para babar com o código. Prometo que os teus loopings nunca mais serão iguais, viva o C# 5!
C#
public void Adicionar(TEntity obj)
{
 ctx.Set<TEntity>().Add(obj);
}
O Excluir na minha opinião é a melhor funcionalidade de conceitos aplicados até agora. O parâmetro de entrada é uma expressão Lambda que será 
usada no predicate. Pense da seguinte forma: desejo excluir os clientes da cidade=florianópolis ou ativo=false ou contém o no me=jose, enfim, quem 
monta a expressão é a situação, pois ela tem que ser dinâmica para se adequar ao momento. E, ao mesmo tempo, a implementação deverá atender 
a TODAS as situações. Sendo assim, o contexto ctx seleciona a entidade TEntity (cliente, por exemplo), aplica o filtro Where com a condição definida 
no predicate (expressão Lambda do parâmetro). Em seguida, é preciso aplicar o ToList para converter para uma lista. E, aí sim vem a glória do 
ForEach para varrer toda a lista e remover todos os itens que atenderem ao critério. Como que isto acontece nos bastidores? É simples (como se 
fosse), o compilador irá disparar um delegate para criar um método em tempo de execução, o qual irá excluir o item da lista. Ou seja, tudo ocorre 
em tempo de execução, dinamicamente com delegate.
Pergunta 1: Mas não posso usar o foreach normal ou o for? Sim, pode, mas o código ficará maior, com mais linhas, porém de fác il manutenção! Isto 
até que você se acostume com a sintaxe do ForEach da lista.
Pergunta 2: Posso ter dois métodos Excluir, um para excluir pela chave primária e outro genérico com parâmetros? Pode, porém não há nenhuma 
necessidade, pois este que criei já faz estas duas funções.
C#
public void Excluir(Func<TEntity, bool> predicate)
{
 ctx.Set<TEntity>()
 .Where(predicate).ToList()
 .ForEach(del => ctx.Set<TEntity>().Remove(del));
 Página 7 de Dicas MVC 
 .ForEach(del => ctx.Set<TEntity>().Remove(del));
}
O Dispose é usado para destruir o objeto instanciado na memória, isto é bem comum no .NET.
public void Dispose()
{
 ctx.Dispose();
}
Classe Repositório de Cliente
Nos passos anteriores criamos a interface e a classe repositório. Agora é preciso criar a classe de repositório de cada entid ade. Como temos a classe 
Cliente, adicione uma nova classe chamada ClienteRepositorio na pasta Repositorio. Veja o código a seguir com as duas referên cias e a herança de 
Repositório<TEntity>.
C#
using Repositorio.DAL.Repositorios.Base;
using Repositorio.Entidades;
namespace Repositorio.DAL.Repositorios
{
 public class ClienteRepositorio : Repositorio<Cliente>
 {
 }
}
Para efeito de acompanhamento, veja na figura 7 a estrutura do Solution Explorer até o momento com os dois projetos, pastas e classes.
Figura 7 – Estrutura do projeto
Compile F6 o projeto e certifique-se que está 100% com sucesso.
Projeto de Console Application
Agora que já temos toda a parte de entidade e repositório definida, podemos iniciar os projetos que irão consumir estes outro s dois. Vamos iniciar 
com um projeto para inserir clientes, utilizando um recurso que citei sobre lista com ForEach. No Solution Explorer, adicione um novo projeto do tipo 
Console Application chamado Repositorio.Console, conforme a figura 8.
Figura 8 – Projeto de Console
O primeiro passo a fazer é adicionar as referências. Abra o Package Console Manager, na combobox de Default project, selecion e 
Repositorio.Console e na linha de comando, digite a seguinte linha para instalar o Entity Framework 6.
PM> Install-Package EntityFramework
Pronto, agora resta adicionar as referências aos outros dois projetos, conforme a figura 9.
Figura 9 – Referências dos dois projetos
Aqui vai uma dica muito importante. Este projeto de Console é o que irá consumir o repositório, portanto, neste projeto é pre ciso informar a string 
de conexão com o banco de dados. Para isto, abra o arquivo App.config, localize a tag <entityFramework> e antes desta, adicio ne as seguintes 
linhas:
C#
<connectionStrings>
 <add name="ConnDB" connectionString="Data Source=localhost;Initial Catalog=BancoRepositorio;Integrated 
Security=True" providerName="System.Data.SqlClient" />
 </connectionStrings>
Note que a chave chama-se ConnDB, e por favor não digite diferente porque o DbContext lá no projeto de repositório procura por este nome. Já em 
connectionString você deve fornecer o caminho completo de onde pretende criar o banco de dados no SQL Server. Sendo assim, ca so tenha usuário 
e senha, forneça-os. Salve e feche este arquivo.
Em seguida, abra o arquivo Program.cs, adicione os seguintes namespaces. Sendo assim, já temos acesso ao repositório e a enti dade Cliente.
C#
using Repositorio.DAL.Repositorios;
using Repositorio.Entidades;
O único método estático Main já existe, portanto, adicione uma chamada para um método Adicionar, assim como o código do mesmo .
C#
namespace Repositorio.Console
{
 class Program
 {
 static void Main(string[] args)
 {
 Adicionar();
}
private static void Adicionar()
 {
 using (var repClientes = new ClienteRepositorio())
 {
 new List<Cliente>
 {
 new Cliente { Nome="Microsoft", Ativo=true, CNPJ="9394.4343/0001-55", 
 Endereco="1, Microsoft One", Telefone="11574739494"},
 new Cliente { Nome="Google", Ativo=true, CNPJ="1234.9494/0001-33", 
 Endereco="12, Santa Clara, CA", Telefone="1185858483"},
 new Cliente { Nome="Oracle", Ativo=true, CNPJ="9876.4433/0002-44", 
 Endereco="54, Santa Monica", Telefone="4884848592"}
 }.ForEach(repClientes.Adicionar);
repClientes.SalvarTodos();
System.Console.WriteLine("Clientes adicionadas com sucesso.");
System.Console.WriteLine("======= clientes cadastrados ===========");
 foreach (var c in repClientes.GetAll())
 {
 System.Console.WriteLine("{0} - {1}", c.ClienteID, c.Nome);
 }
 Página 8 de Dicas MVC 
 }
System.Console.ReadKey();
 }
 }
 }
}
Vamos a explicação detalhada do método Adicionar. Como o repositório suporta o Dispose (nós implementamos), podemos usar o us ing, assim 
quando for encontrado o fechamento das chaves do using, o objeto já é liberado e destruído da memória. O using faz um referên cia ao 
ClienteRepositorio, o qual foi atribuído à variável repClientes. Em seguida é montada uma lista com Generics (List<T>) onde m onto três objetos do 
tipo cliente. Em seguida, como é uma lista, há o ForEach disponível que irá disparar uma Action para um delegate dinâmico. Es te delegate vai 
chamar o método Adicionar do repositório repClientes. O melhor de tudo é que isto será criado em tempo de execução.
Pergunta:Posso criar um foreach comum? Sim, você pode criar um foreach comum, varrer toda a lista de elementos de clientes, e para cada iteração, 
você chama o Adicionar do repositório. Mas, convenhamos, melhore o seu código e muito com o Action que dispara o delegate.
Ao final, todos os clientes estarão apenas na memória, nada de banco de dados. Então, cabe chamar o método SalvarTodos para e fetivar a inclusão 
no banco fisicamente. Uma vez incluídos, para ter certeza disto, criei um código para chamar o método GetAll e listar os IDs e nomes dos clientes.
Pressione F6 para compilar e certifique-se que tudo esteja 100% com sucesso. O próximo passo é executar este projeto de Console. No entanto, na 
lista de projetos o de Console não está em negrito, significando que quando você pressionar F5, o projeto em negrito é que se rá executado. Então, 
clique com o botão direito no projeto de Console e selecione Set as StartUp Project. Agora sim, pressione F5 e aguardo a exec ução onde o banco de 
dados será criado na hora. Veja na figura 10 que os clientes foram cadastrados com sucesso, pois estão listados.
Figura 10 – Clientes cadastrados
Não execute novamente senão os mesmos clientes serão adicionados. Comente a linha da chamada do método Adicionar no Main para evitar de 
cadastrar tudo novamente. Este foi o primeiro teste somente para cadastrar alguns dados.
Agora, veja um teste de como criar uma expressão Lambda e passa-la como critério para o método de Excluir dados. No Main, crie uma chamada 
para o método ExcluirVariosClientes, assim como o respectivo código.
C#
static void Main(string[] args)
{
 //Adicionar();
ExcluirVariosClientes();
}
private static void ExcluirVariosClientes()
{
 using (var repClientes = new ClienteRepositorio())
 {
 new List<Cliente>
 {
 new Cliente { Nome="Renato Haddad", Telefone="48575757"},
 new Cliente { Nome="Renato Marcantonio", Telefone="55929292"},
 new Cliente { Nome="Renato Jose", Telefone="77565644"}
 }.ForEach(repClientes.Adicionar);
repClientes.SalvarTodos();
 System.Console.WriteLine("Clientes Renato's adicionados");
// lista todos os clientes
 foreach (var c in repClientes.GetAll())
 {
 System.Console.WriteLine(c.ClienteID + " - " + c.Nome);
 }
// excluir vários clientes Renato
 try
 {
 repClientes.Excluir(c => c.Nome.StartsWith("Renato"));
 repClientes.SalvarTodos();
 System.Console.WriteLine("clientes excluidos com sucesso");
 }
 catch (Exception)
 {
 System.Console.WriteLine("erro ao excluir um cliente");
 }
 System.Console.ReadKey();
 }
}
Neste código basicamente adiciono três clientes que iniciam com o texto Renato, salvo no banco e listo todos para comprovar q ue foram 
cadastrados. E, o melhor vem agora na chamada do método repClientes.Excluir. Só para relembrar como está o método, veja o cód igo a seguir. A 
entrada é uma Func que espera uma expressão Lambda a ser passada ao método de extensão Where do predicate que irá disparar o delegate do 
ForEach para executar a exclusão dos itens que atendem ao critério.
C#
public void Excluir(Func<TEntity, bool> predicate)
{
 ctx.Set<TEntity>()
 .Where(predicate).ToList()
 .ForEach(del => ctx.Set<TEntity>().Remove(del));
}
E qual critério? Neste caso são todos os clientes cuja propriedade Nome inicia (StartsWith) com “Renato”. Ou seja, serão excl uídos os três clientes 
que inclui de teste anteriormente. Cabe dizer que o critério é dinâmico e você pode usar todo o que for suportado pelo C#.
C#
c => c.Nome.StartsWith("Renato")
E, para finalizar, como o Excluir foi chamado, é preciso invocar o SalvarTodos para efetivar a exclusão dos dados no banco. P ronto, pressione F5 
novamente para salvar, compilar e executar o projeto. Caso queira abrir o banco de dados, use o Server Explorer, conforme a f igura 11.
 Página 9 de Dicas MVC 
novamente para salvar, compilar e executar o projeto. Caso queira abrir o banco de dados, use o Server Explorer, conforme a f igura 11.
Figura 11 – Clientes no banco
Projeto ASP.NET MVC 5
Para ilustrar o consumo do repositório em um projeto MVC 5, crie um novo projeto do tipo Web / ASP.NET Web application, chama do 
Repositorio.MVC, conforme a figura 12.
Figura 12 – Novo projeto Web
Clique em OK e selecione o template MVC, conforme a figura 13. Veja que não coloquei nenhuma autenticação, pois não é preciso , iremos apenas 
consumir o repositório.
Figura 13 – Projeto MVC 5
Clique no botão OK e aguarde a criação do projeto completo. Logo de cara, deixe este novo projeto como default para execução, então, no Solution 
Explorer clique com o botão direito e selecione Set as Startup Project.
Agora, já instale o Entity Framework 6 via Nuget e adicione as referências aos projetos Repositorio.Entidades e Repositorio.D AL. Pressione F6 para 
compilar e certifique-se que está 100% com sucesso.
O próximo passo é referenciar a string de conexão que será usada no projeto de Repositório.DAL. Para isto, abra o arquivo Web .Config, localize a tag 
</configSections > e após esta tag, adicione o bloco a seguir. Atenção, não erre no nome da chave ConnDB, pois esta é a chave que o DAL irá 
procurar para localizar o banco de dados. Mais uma vez, nem preciso dizer que caso o seu SQL Server tenha autenticação, adici one o UserId e a 
Password, assim como o nome do servidor onde o banco está.
C#
<connectionStrings>
 <add name="ConnDB" connectionString="Data Source=localhost;Initial Catalog=BancoRepositorio;Integrated 
Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>
Controller de Clientes
Um projeto MVC 5 é tão fácil de se criar todas as Views de CRUD, que há templates (scaffolds) prontos. E, a primeira coisa a fazer é criar o Controller 
de Clientes. Compile o projeto novamente F6. Na pasta Controllers, clique com o botão direito, selecione Add / Controller. Se rá aberta a janela de 
Scaffold (templates) conforme a figura 14, então selecione MVC 5 Controller with views, using Entity Framework.
Figura 14 – Adicionar um controller usando o Entity Framework
Clique no botão Add e preencha os dados conforme a figura 15, sendo: Controller (Controller name) = ClientesController; Model class = Cliente; 
Data context class = BancoContexto.
Figura 15 – Informações para o Controller
Clique no botão Add e aguarde o Visual Studio criar ClientesController e todas as Views (UI) para fazer o CRUD de dados.
Ajustes no Controller
Na pasta Controller tem o arquivo ClientesController.cs criado automaticamente usando o scaffold do MVC 5. No entanto, como t emos o repositório 
é preciso fazer alguns ajustes. Sendo assim, no código a seguir, o que for default do MVC 5 eu coloquei como comentário, e o código que você 
deverá digitar está em seguida dos comentários. Basicamente é preciso retirar todas as referências do contexto e apontar para o ClienteRepositorio.
C#
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Net;
using System.Web;
using System.Web.Mvc;
using Repositorio.Entidades;
using Repositorio.DAL.Contexto;
using Repositorio.DAL.Repositorios;
namespace Repositorio.MVC.Controllers
{
 public class ClientesController : Controller
 {
 // Troca o contexto
 //private BancoContexto db = new BancoContexto();
 private readonly ClienteRepositorio repCli = new ClienteRepositorio();
// GET: /Clientes/
 public ActionResult Index()
 {
 //return View(db.Cliente.ToList());
 return View(repCli.GetAll().ToList());
 }
// GET: /Clientes/Details/5
 public ActionResult Details(int? id)
 {if (id == null)
 {
 return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
 }
 //Cliente cliente = db.Cliente.Find(id);
 Cliente cliente = repCli.Find(id);
if (cliente == null)
 {
 return HttpNotFound();
 }
 return View(cliente);
 }
// GET: /Clientes/Create
 public ActionResult Create()
 {
 Página 10 de Dicas MVC 
 {
 return View();
 }
// POST: /Clientes/Create
 // To protect from overposting attacks, please enable the specific properties you want to bind to, for 
 // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
 [HttpPost]
 [ValidateAntiForgeryToken]
 public ActionResult Create([Bind(Include="ClienteID,Nome,CNPJ,Endereco,Telefone,Ativo")] Cliente cliente)
 {
 if (ModelState.IsValid)
 {
 //db.Cliente.Add(cliente);
 repCli.Adicionar(cliente);
 
 //db.SaveChanges();
 repCli.SalvarTodos();
 return RedirectToAction("Index");
 }
return View(cliente);
 }
// GET: /Clientes/Edit/5
 public ActionResult Edit(int? id)
 {
 if (id == null)
 {
 return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
 }
 //Cliente cliente = db.Cliente.Find(id);
 Cliente cliente = repCli.Find(id);
 if (cliente == null)
 {
 return HttpNotFound();
 }
 return View(cliente);
 }
// POST: /Clientes/Edit/5
 // To protect from overposting attacks, please enable the specific properties you want to bind to, for 
 // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
 [HttpPost]
 [ValidateAntiForgeryToken]
 public ActionResult Edit([Bind(Include="ClienteID,Nome,CNPJ,Endereco,Telefone,Ativo")] Cliente cliente)
 {
 if (ModelState.IsValid)
 {
 //db.Entry(cliente).State = EntityState.Modified;
 repCli.Atualizar(cliente);
//db.SaveChanges();
 repCli.SalvarTodos();
 return RedirectToAction("Index");
 }
 return View(cliente);
 }
// GET: /Clientes/Delete/5
 public ActionResult Delete(int? id)
 {
 if (id == null)
 {
 return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
 }
 //Cliente cliente = db.Cliente.Find(id);
 Cliente cliente = repCli.Find(id);
 if (cliente == null)
 {
 return HttpNotFound();
 }
 return View(cliente);
 }
// POST: /Clientes/Delete/5
 [HttpPost, ActionName("Delete")]
 [ValidateAntiForgeryToken]
 public ActionResult DeleteConfirmed(int id)
 {
 //Cliente cliente = db.Cliente.Find(id);
 Cliente cliente = repCli.Find(id);
//db.Cliente.Remove(cliente);
 repCli.Excluir(c => c == cliente);
//db.SaveChanges();
 repCli.SalvarTodos();
 return RedirectToAction("Index");
 }
protected override void Dispose(bool disposing)
 Página 11 de Dicas MVC 
protected override void Dispose(bool disposing)
 {
 //if (disposing)
 //{
 // db.Dispose();
 //}
 repCli.Dispose();
 base.Dispose(disposing);
 }
 }
}
Pressione F6 para compilar o projeto, e caso tenha algum erro, corrija-o.
Views (UI interface de usuário)
Uma vez criado o Controller são criadas todas as Views do Cliente automaticamente, como você pode ver na pasta Views/Clientes na figura 16.
Figura 16 – Views do Cliente
Por se tratar de um projeto MVC 5, vamos fazer um ajuste para aparecer a opção Cliente no menu da View principal. Localize o arquivo 
_Layout.cshtml na pasta Views/Shared. Na lista de opções do menu adicione a chamada para Clientes.
C#
<div class="navbar-collapse collapse">
 <ul class="nav navbar-nav">
 <li>@Html.ActionLink("Home", "Index", "Home")</li>
 <li>@Html.ActionLink("Clientes", "Index", "Clientes")</li>
 <li>@Html.ActionLink("About", "About", "Home")</li>
 <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
 </ul>
</div>
Pronto, o projeto já está finalizado utilizando todos os recursos de repositório de dados, em camadas e independentes para vo cê testar cada camada 
individualmente. Para manutenção de qualquer código é muito mais fácil, produtivo e o melhor de tudo é que para um cenário de times médios e 
grandes, isto se aplica perfeitamente. Pressione F5 para salvar, compilar e executar a aplicação MVC 5. Conforme a figura 17, clique no menu Clientes 
para visualizar todos os clientes cadastrados.
Figura 17 – Clientes cadastrados
Caso queira cadastrar um novo cliente, clique em Create New, ou então, em qualquer outra opção disponível para alterar, detal hes ou excluir. Veja a 
tela de cadastro na figura 18.
Figura 18 – Novo cliente
Eu sugiro você utilizar o breakpoint no Controller para identificar todo o caminho das camadas percorridas pelo código, afina l o Debug é fantástico 
pra isto.
Neste artigo criei apenas um projeto de Console e MVC 5, mas fique à vontade para criar qualquer outro tipo de projeto. E, ca so necessite aplicar o 
repositório como serviço que retorne um JSON ou XML, crie um projeto de Web Api que referencia o repositório e pronto.
Conclusão
O uso de repositórios de dados tem sido usado em projetos de várias tecnologias, e em .NET demonstrei uma maneira que compart ilho com todos 
os leitores, alguns códigos para que você possa implementar nos vossos projetos. Sei que é preciso estudar um pouco mais sobr e códigos 
dinâmicos, actions, predicates, expressões lambda e o entity framework 6, mas isto é o que nos move para os desafios de criar projetos produtivos. 
Particularmente, sempre irei incentivar o estudo de novidades porque tenho certeza que há sempre o que se aprender e melhorar . Caso você tenha 
algum comentário ou queira compartilhar códigos com os desenvolvedores, faça isto com prazer e saiba que quanto mais você com partilhar, mais 
você receberá em troca, afinal é um processo natural de evolução.
Agradeço a oportunidade de poder compartilhar o conhecimento com todos. Qualquer dúvida e preparação de times de desenvolvime nto, por favor 
me contate.
Sobre o Autor
Renato Haddad (rehaddad@msn.com – www.renatohaddad.com ) é MVP, MCT, MCPD e MCTS, palestrante em eventos da Microsoft em diversos 
países, ministra treinamentos focados em produtividade com o VS.NET 2012/2013, ASP.NET 4/5, ASP.NET MVC, Entity Framework, Re porting 
Services, Windows Phone e Windows 8. Visite o bloghttp://weblogs.asp.net/renatohaddad.
| Home | Artigos Técnicos | Comunidade
De <http://localhost:40228/readme/repositorio.html> 
 Página 12 de Dicas MVC