Apostila MVC

Resolvo
Tecnologia & Solues

Treinamento de MVC

Samuel Vaz
eu@resolvo.com.br
(11) 986 000 149
www.resolvo.com.br

Samuel Vaz eu@resolvo.com.br

Resolvo Tecnologia & Solues

INDICE
1. Banco de dados ................................................................................................................................... 5
1.1 Sistemas gerenciadores de banco de dados ................................................................... 6
1.2 SQL Server ..................................................................................................................................... 6
1.3 Bases de dados (Databases) .................................................................................................. 6
1.3.1 Criando uma base de dados no SQL Server ................................................................ 7
1.4 Tabelas ........................................................................................................................................... 8
1.4.1 Criando tabelas no SQL Server ......................................................................................... 8
1.5 Operaes Bsicas .................................................................................................................. 10
1.6 Chaves Primria e Estrangeira .......................................................................................... 12
1.7 Consultas Avanadas ............................................................................................................. 13
1.8 Exerccios ................................................................................................................................... 13
2. ADO.NET ............................................................................................................................................. 21
2.1 Driver ........................................................................................................................................... 21
2.2 ODBC ............................................................................................................................................ 21
2.3 ODBC Manager ......................................................................................................................... 22
2.4 Criando uma conexo ............................................................................................................ 22
2.5 Inserindo registros ................................................................................................................. 23
2.6 SQL Injection ............................................................................................................................. 24
2.7 Fbrica de conexes (Factory) .......................................................................................... 25
3. Entity Framework .......................................................................................................................... 26
3.1 Mltiplas sintaxes da linguagem SQL ............................................................................. 26
3.2 Orientao a Objetos VS Modelo Entidade Relacionamento ................................ 27
3.3 Ferramentas ORM ................................................................................................................... 27
3.4 Configurao ............................................................................................................................. 27
3.5 Mapeamento ............................................................................................................................. 29
3.6 Exerccios ................................................................................................................................... 37
3.7 Manipulando entidades ....................................................................................................... 43
3.7.1 Persistindo ............................................................................................................................. 43
3.7.2 Buscando ................................................................................................................................ 43
3.7.3 Removendo ............................................................................................................................ 43
3.7.4 Atualizando ............................................................................................................................ 44
3.7.5 Listando ................................................................................................................................... 44
3.8 Exerccios ................................................................................................................................... 44
3.9 Repository .................................................................................................................................. 45
4. Viso Geral do ASP .NET MVC ................................................................................................... 46
4.1 Necessidades de uma aplicao web .............................................................................. 46
4.2 Viso Geral do ASP .NET MVC ........................................................................................... 46
4.3 Aplicao de exemplo ........................................................................................................... 47
4.3.1 Testando a aplicao ......................................................................................................... 49
4.3.2 Trocando a porta do servidor ........................................................................................ 49
4.4 Pgina de Saudao ................................................................................................................ 50
4.5 Exerccios ................................................................................................................................... 51
4.6 Alterando a pgina inicial ................................................................................................... 51
4.7 Integrando o Banco de Dados ............................................................................................ 52


4.8 Exerccios ................................................................................................................................... 52
4.9 Listando entidades ................................................................................................................. 53
4.10 Exerccios ................................................................................................................................. 56
4.11 Inserindo entidades ............................................................................................................ 56
4.12 Exerccios ................................................................................................................................. 58
4.13 Alterando entidades ............................................................................................................ 60
4.13.1 Link de alterao .............................................................................................................. 60
4.14 Exerccios ................................................................................................................................. 60
4.15 Removendo entidades ....................................................................................................... 61
4.16 Exerccios ................................................................................................................................. 62
5. Tratamento de Erros ................................................................................................................... 62
5.1 Try-Catch .................................................................................................................................... 62
5.1.1 Exerccios .............................................................................................................................. 63
5.1.2 Custom Errors ...................................................................................................................... 63
5.1.3 Exerccios ................................................................................................................................ 64
5.1.4 Erros do HTTP ...................................................................................................................... 64
5.1.5 Exerccios ................................................................................................................................ 65
6. Camada de Apresentao (View) ........................................................................................ 65
6.1 Inline Code ................................................................................................................................. 65
6.2 Utilizando Inline Code .......................................................................................................... 66
6.3 ViewData, ViewBag e Model ............................................................................................... 68
6.4 HTML Helpers .......................................................................................................................... 68
6.4.1 ActionLink Helper ............................................................................................................... 69
6.4.2 Helpers de Formulrios .................................................................................................... 70
6.4.3 DropDownList Helper ....................................................................................................... 73
6.4.4 Editor Helper ........................................................................................................................ 73
6.5 Exerccios ................................................................................................................................... 75
6.6 Master Pages / Layout ......................................................................................................... 76
6.6.1 Contedo comum ................................................................................................................ 76
6.6.2 Lacunas .................................................................................................................................... 78
6.7 Exerccios ................................................................................................................................... 79
6.8 Importao Automtica ....................................................................................................... 80
6.9 Exerccios ................................................................................................................................... 80
6.10 Dividindo o contedo ......................................................................................................... 80
6.11 Exerccios ................................................................................................................................. 81
7. Controles (Controller) ................................................................................................................. 81
7.1 Actions ......................................................................................................................................... 82
7.2 ActionResult .............................................................................................................................. 82
7.3 Parmetros ................................................................................................................................ 83
7.3.1 Vrios parmetros .............................................................................................................. 83
7.3.2 Por objeto ............................................................................................................................... 84
7.4 Exerccios ................................................................................................................................... 84
7.5 TempData ................................................................................................................................... 84
7.6 Exerccios ................................................................................................................................... 85
8. Rotas ................................................................................................................................................... 86
8.1 Adicionando uma rota .......................................................................................................... 87


8.2 Definindo parmetros ........................................................................................................... 87
8.3 Exerccios ................................................................................................................................... 88
9. Validao .......................................................................................................................................... 88
9.1 Controller ................................................................................................................................... 88
9.2 View .............................................................................................................................................. 89
9.3 Exerccios ................................................................................................................................... 90
9.4 Anotaes ................................................................................................................................... 90
9.4.1 Required .................................................................................................................................. 91
9.4.2 Alterando a mensagem ..................................................................................................... 91
9.4.3 Outros validadores ............................................................................................................. 91
9.5 Validao no lado do Cliente .............................................................................................. 92
9.6 Exerccios ................................................................................................................................... 92
10. Sesso ................................................................................................................................................ 92
10.1 Sesso ........................................................................................................................................ 93
10.1.1 Identificando o Usurio ................................................................................................. 93
10.2 Utilizando Session no ASP.NET ...................................................................................... 94
11. Filtros ................................................................................................................................................... 95
11.1 Filtro de Autenticao ........................................................................................................ 96
11.2 Exerccios ................................................................................................................................. 97
11.3 Action Filters .......................................................................................................................... 98
11.4 Exerccios ................................................................................................................................. 99
12. Projeto ............................................................................................................................................... 100
12.1 Modelo .................................................................................................................................... 100
12.2 Exerccios ............................................................................................................................... 100
12.3 Persistncia Repositrios ........................................................................................... 100
12.4 Apresentao Template ............................................................................................... 100
12.5 Cadastrando e Listando Editoras ................................................................................ 101
12.6 Exerccios ............................................................................................................................... 101
12.7 Removendo Editoras ........................................................................................................ 101
12.8 Exerccios ............................................................................................................................... 101
12.9 Cadastrando, Listando e Removendo Livros .......................................................... 102
12.10 Exerccios ............................................................................................................................ 102
12.11 Removendo Livros .......................................................................................................... 102
12.12 Exerccios ............................................................................................................................ 102
12.13 Membership e Autorizao ......................................................................................... 103
12.14 Exerccios ............................................................................................................................ 103
12.21.1 Adicionando um Usurio Administrador com ASP .NET Configuration .. 103
12.15 Exerccios ............................................................................................................................ 103
12.15.1 Autorizao Role-based ............................................................................................ 103
12.16 Exerccios ............................................................................................................................ 103
12.17 Controle de Erro .............................................................................................................. 104
12.18 Exerccios ........................................................................................................................... 104


1. Banco de dados
O nosso objetivo desenvolver aplicaes que necessitam

armazenar informaes relacionadas ao seu objetivo/domnio em
algum lugar. Por exemplo, uma aplicao de gerenciamento de uma
livraria que armazena os dados dos livros que comercializa.
Uma forma de suprir essa necessidade seria armazenar essas
informaes em arquivos. Contudo, alguns fatores importantes nos
levam a descartar tal opo.
A seguir, apresenta-se as principais preocupaes que devem ser
consideradas ao trabalhar com dados:
Segurana: As informaes potencialmente confidenciais devem ser
controladas de forma que apenas usurios e sistemas autorizados
tenham acesso a elas.
Integridade: Eventuais falhas de software ou hardware no devem
corromper os dados.
Acesso: As funes de consulta e manipulao dos dados devem
ser implementadas.
Concorrncia: Usualmente, diversos sistemas e usurios acessaro
as informaes de forma concorrente. Apesar disso, os dados no
podem ser perdidos ou corrompidos.
Considerando todos esses aspectos, conclumos que seria

necessria a utilizao de um sistema complexo para manusear as
informaes das nossas aplicaes. Felizmente, tal tipo de sistema
j existe e conhecido como Sistema Gerenciador de Banco de
Dados (SGBD).


1.1 Sistemas gerenciadores de banco de dados

No mercado, existem diversas opes de banco de dados. Alguns
dos mais populares so:
Oracle
SQL Server
SQL Server Express
PostgreSQL
1.2 SQL Server
Neste treinamento, utilizaremos o SQL Server, que mantido pela

Microsoft. Existem diversas verses do SQL Server, sendo uma, o
Microsoft SQL Server 2012 Express um sistema gratuito de
gerenciamento de dados avanado e confivel que fornece um
repositrio de dados avanado para sites leves e aplicativos de rea
de trabalho.
Pode ser obtido a partir do site:
http://www.microsoft.com/pt-br/download/details.aspx?id=29062
Microsoft SQL Server Management Studio

Para interagir com o SQL Server, utilizaremos um cliente com
interface grfica chamado de Microsoft SQL Server Management
Studio. Porm o Visual Studio j possui uma ferramenta para
interao e manipulao de banco de dados integrada na prpria
IDE.
1.3 Bases de dados (Databases)

Um sistema gerenciador de banco de dados capaz de gerenciar
informaes de diversos sistemas ao mesmo tempo. Por exemplo, as
informaes dos clientes de um banco, alm dos produtos de uma
loja virtual ou do estoque da empresa.
Caso os dados fossem mantidos sem nenhuma separao lgica, a
organizao ficaria prejudicada. Alm disso, seria mais difcil
implementar regras de segurana referentes ao acesso dos dados.
Tais regras criam restries quanto ao contedo acessvel por cada
usurio. Determinado usurio, por exemplo, poderia ter permisso de


acesso aos dados dos clientes do banco, mas no s informaes
dos produtos da loja virtual, ou vice-versa.
Ento, por questes de organizao e segurana, os dados devem
ser armazenados separadamente no SGBD. Da surge o conceito de
base de dados (database).
Uma base de dados um agrupamento lgico das informaes de
um determinado domnio, como, por exemplo, os dados da nossa
livraria.
1.3.1 Criando uma base de dados no SQL Server

Para criar uma base de dados no SQL Server, utilizamos o comando
CREATE DATABASE.

CREATE DATABASE CursoDeal
Repare que alm da base de dados CursoDeal pode haver outras

bases. Existem bases que foram criadas automaticamente pelo
prprio SQL Server para guardar algumas configuraes.Quando
uma base de dados no mais necessria, ela pode ser removida
atravs do comando DROP DATABASE CursoDeal


1.4 Tabelas

Um servidor de banco de dados dividido em bases de dados com o
intuito de separar as informaes de sistemas diferentes. Nessa
mesma linha de raciocnio, podemos dividir os dados de uma base a
fim de agrup-los segundo as suas correlaes. Essa separao
feita atravs de tabelas. Por exemplo, no sistema de um banco,
interessante separar o saldo e o limite de uma conta, do nome e CPF
de um cliente. Ento, poderamos criar uma tabela para os dados
relacionados s contas e outra para os dados relacionados aos
clientes.
Uma tabela formada por registros (linhas) e os registros so
formados por campos (colunas). Por exemplo, suponha uma tabela
para armazenar as informaes dos clientes de um banco. Cada
registro dessa tabela armazena em seus campos os dados de um
determinado cliente.
1.4.1 Criando tabelas no SQL Server

As tabelas no SQL Server so criadas atravs do comando CREATE
TABLE. Na criao de uma tabela necessrio definir quais so os
nomes e os tipos das colunas.


No SQL Server os nomes das tabelas so precedidas pelo ID do

usurio que possui a tabela. No caso do usurio sa, o ID dbo.
Portanto o nome da tabela Livros fica dbo.Livros.
Se uma tabela no for mais desejada ela pode ser removida atravs
do comando DROP TABLE.


1.5 Operaes Bsicas

As operaes bsicas para manipular os dados das tabelas so:
inserir, ler, alterar e remover.
Essas operaes so realizadas atravs da linguagem de consulta
denominada SQL. Esta linguagem oferece quatro comandos bsicos:
INSERT, SELECT, UPDATE e DELETE.
Estes comandos so utilizados para inserir, ler, alterar e remover
registros respectivamente.
INSERT INTO dbo.Livros (Titulo, Preco) VALUES ('ASP.NET

MVC', 2000.00)
SELECT * FROM dbo.Livros


UPDATE dbo.Livros set preco = 3000 where Titulo =
'ASP.NET MVC'
SELECT * FROM dbo.Livros
DELETE FROM dbo.Livros


1.6 Chaves Primria e Estrangeira

Suponha que os livros da nossa livraria so separados por editoras.
Uma editora possui nome e telefone. Para armazenar esses dados,
uma nova tabela deve ser criada.
Nesse momento, teramos duas tabelas (Livros e Editoras).
Eventualmente, ser necessrio descobrir qual a editora de um
determinado livro ou quais so os livros de uma determinada editora.
Para isso, os registros da tabela Editoras devem estar relacionados
aos da tabela Livros.
Na tabela Livros, poderamos adicionar uma coluna para armazenar

o nome da editora a qual ele pertence. Dessa forma, se algum
quiser recuperar as informaes da editora de um determinado livro,
deve consultar a tabela Livros para obter o nome da editora
correspondente. Depois, com esse nome, deve consultar a tabela
Editoras para obter as informaes da editora.
Porm, h um problema nessa abordagem, a tabela Editoras aceita

duas editoras com o mesmo nome. Dessa forma, eventualmente,
no conseguiramos descobrir os dados corretos da editora de um
determinado livro.
Para resolver esse problema, deveramos criar uma restrio na

tabela Editoras que proba a insero de editoras com o mesmo
nome. Para resolver esse problema no SQL Server poderamos
adicionar a propriedade UNIQUE no campo nome da tabela Editoras.


Porm ainda teramos mais um problema: na tabela livro poderamos
adicionar registros com editoras inexistentes, pois no h nenhum
vnculo explcito entre as tabelas. Para solucionar estes problemas,
devemos utilizar o conceito de chave primria e chave estrangeira.
Toda tabela pode ter uma chave primria, que um conjunto de um

ou mais campos que devem ser nicos para cada registro.
Normalmente, um campo numrico escolhido para ser a chave
primria de uma tabela, pois as consultas podem ser realizadas com
melhor desempenho.
Ento, poderamos adicionar um campo numrico na tabela Editoras

e torn-lo chave primria. Vamos chamar esse campo de ID.
Na tabela Livros, podemos adicionar um campo numrico chamado
idEditora que deve ser utilizado para guardar o valor da chave
primria da editora correspondente ao livro. Alm disso, o campo
idEditora deve estar explicitamente vinculado com o campo id da
tabela Editoras. Para estabelecer esse vnculo o campo idEditora
deve ser uma chave estrangeira associada ao campo Id.
Uma chave estrangeira um conjunto de uma ou mais colunas de
uma tabela que possuem valores iguais aos da chave primria de
outra tabela.
Com a definio da chave estrangeira, um livro no pode ser inserido
com o valor do campo idEditora invlido. Caso tentssemos
obteramos uma mensagem de erro.
1.7 Consultas Avanadas

Com o conceito de chave estrangeira, podemos fazer consultas
complexas envolvendo os registros de duas ou mais tabelas. Por
exemplo, descobrir todos os livros de uma determinada editora.
1.8 Exerccios

1. Abra o Microsoft SQL Server Management utilizando as
informaes do servidor como Server Name, SQL Server
Authentication como Authentication, sa como Login e `a senha`
como Password.
2. Crie uma nova base de dados chamada CursoDeal, conforme
mostrado nas figuras anteriores. Voc vai utilizar esta base nos
exerccios seguintes.


3. Crie uma tabela chamada Editoras conforme as figuras
abaixo.
Altere os campos para torn-los obrigatrios, NO permitindo que

eles fiquem em branco NULL.
Alm disso o campo Id deve ser uma chave primria.
O campo Id dever ser incrementado automaticamente. Defina ele

com a propriedade Identity segundo a figura abaixo:


4. Crie uma tabela chamada Livros conforme as figuras abaixo:


Lembrando de NO marcar a opo ALLOW NULL. Alm disso o
campo ID deve ser uma chave primria e automaticamente
incrementada.
Voc precisa tornar o campo ID_EDITORA uma chave estrangeira.

Clique com o boto direito sobre a coluna ID_EDITORA e selecione
a opo Relantioships..., conforme a figura
Devemos acrescentar o relacionamento entre livro e editora. Clique

em Add e posteriormente no boto direita na linha Tables and
Columns Specification.


Devemos informar qual a chave primria que a coluna

ID_EDITORA da tabela Livros faz referncia. Para isto, informe a
tabela Editoras como Primary Key Table e indique a coluna Id como
a chave primria referenciada. Selecione a coluna ID_EDITORA
como a coluna que ir fazer referncia a chave primria da tabela
Editoras.
5. Adicione alguns registros na tabela Editoras. Veja exemplos

abaixo:


INSERT INTO dbo.Editoras (NOME, EMAIL)
VALUES ('Oreilly','oreilly@gmail.com')
VALUES ('Wrox','wrox@live.com')
VALUES ('Atlas','atlas@yahoo.com')
VALUES ('Samuel','samuel@resolvo.com')
6. Adicione alguns registros na tabela Livros. Veja exemplos

abaixo:
INSERT INTO dbo.Livros (TITULO, preco, ID_EDITORA)

VALUES ('Aprendendo C#',19.99,1)

VALUES ('Framework ASP.NET MVC',29.99, 2)

VALUES ('Praticando MVC',39.99,3)

VALUES ('Usufruindo de tudo',99.99,4)
7. Consulte os registros da tabela Editoras, e em seguida

consulte a tabela Livros. Veja exemplos abaixo:


8. Altere alguns dos registros da tabela Livros. Veja o exemplo

abaixo:
UPDATE dbo.Livros set PRECO = 300.00 WHERE ID_LIVRO = 1
9. Altere alguns dos registros da tabela Editoras. Veja o exemplo

abaixo:
UPDATE dbo.Editoras set NOME ='ORelly' WHERE ID = 1
10. Remova alguns registros da tabela Livros. Veja o

exemplo abaixo:
DELETE dbo.Livros where ID_LIVRO = 3



11. Remova alguns registros da tabela Editoras.
DELETE dbo.Editoras where ID = 3

Preste ateno para no remover uma editora que tenha algum livro
relacionado j adicionado no banco.
12. Faa uma consulta para buscar todos os livros de uma

determinada editora. Veja um exemplo na figura abaixo:

SELECT * FROM dbo.Livros, dbo.Editoras WHERE Editoras.ID
= Livros.ID_EDITORA


2. ADO.NET

J aprendemos que utilizar bancos de dados uma boa soluo
para o armazenamento dos dados. Entretanto, voc deve ter
percebido que a interface de utilizao do SQL Server (e dos outros
bancos de dados em geral) no muito amigvel. Ela exige que o
usurio conhea a sintaxe do SQL para escrever as consultas. Alm
disso, quando o volume de dados muito grande, mais difcil
visualizar os resultados.
Na prtica uma aplicao com interface simples desenvolvida para
permitir que os usurios do sistema possam manipular os dados do
banco de dados. De alguma forma, essa aplicao precisa se
comunicar com o banco de dados utilizado no sistema.
Agora ns vamos desenvolver uma aplicao para acessar os dados

do estoque da nossa loja virtual.
2.1 Driver

Como a aplicao precisa conversar com o banco de dados, ela
deve trocar mensagens com ele. O formato das mensagens precisa
ser definido previamente.
Para facilitar o desenvolvimento de aplicaes que devem se
comunicar com bancos de dados, as empresas que so proprietrias
desses bancos oferecem os drivers de conexo.
Os drivers de conexo atuam como tradutores de comandos
escritos em uma determinada linguagem de programao para
comandos no protocolo do banco de dados. Do ponto de vista do
desenvolvedor da aplicao, no necessrio conhecer o complexo
protocolo binrio do banco.
2.2 ODBC

Suponha que os proprietrios dos bancos de dados desenvolvessem
os drivers de maneira totalmente independente. Consequentemente,
cada driver teria sua prpria interface, ou seja, seu prprio conjunto
de instrues. Dessa maneira, o desenvolvedor da aplicao precisa
conhecer as instrues de cada um dos drivers dos respectivos
bancos que ele for utilizar.


Para facilitar o trabalho do desenvolvedor da aplicao, a Microsoft
definiu uma especificao chamada ODBC (Open Database
Connectivity) para padronizar a interface dos drivers de conexo.
Assim, quando uma empresa proprietria de um banco de dados
pretende desenvolver um driver, ela segue essa especificao com o
intuito de populariz-lo.
Os drivers de conexo que respeitam a especificao ODBC, ou
seja, possuem um conjunto de comandos padronizados, so
chamados de drivers de conexo ODBC.
2.3 ODBC Manager

Para que drivers ODBC possam ser instalados em uma mquina e
as aplicaes consigam utiliz-los necessrio ter o ODBC
Manager, que j vem instalado no Windows.
O driver de conexo ODBC j est disponvel para utilizao,
podemos consultar o ODBC Manager do Windows. O ODBC
Manager pode ser executado atravs do item Ferramentas
Administrativas do Painel de Controle.
2.4 Criando uma conexo

Com o driver de conexo ODBC instalado na mquina j possvel
criar uma conexo com o banco de dados correspondente.
O que necessrio para estabelecer uma conexo com o banco de
dados?
Escolher o driver de conexo;
Definir a localizao do banco de dados;
Informar o nome da base de dados;
Ter um usurio e senha cadastrados no banco de dados.
Todas essas informaes so definidas na chamada string de

conexo.


<connectionStrings>
<add name="DefaultConnection" connectionString="Data
Source=(LocalDb)\v11.0;Initial Catalog=aspnet-Curso-
20140203213142;Integrated
Security=SSPI;AttachDBFilename=|DataDirectory|\aspnet-
Curso-20140203213142.mdf"
providerName="System.Data.SqlClient" />
</connectionStrings>

<add name="EntityConnection"
connectionString="metadata=res://*/WebPortal.csdl|res://
*/WebPortal.ssdl|res://*/WebPortal.msl;provider=System.D
ata.SqlClient;provider connection string="data
source=COMPUTADOR;initial catalog=base_de_dados;persist
security info=True;User ID=sa;pwd=sa;
multipleactiveresultsets=True;App=EntityFramework""
providerName="System.Data.EntityClient" />
2.5 Inserindo registros

Estabelecida a conexo com o banco de dados, j podemos executar
comandos. Por exemplo, j podemos inserir registros nas tabelas. O
primeiro passo para executar um comando defini-lo em linguagem
SQL.
string textoDoComando = @"INSERT INTO Editoras

(Nome, Email)
VALUES (Abril, abril@email.com);";
Se a aplicao mantiver as conexes abertas o banco de dados

pode deixar de atender outras aplicaes pois h um limite de
conexes que o banco pode suportar. Portanto, importante que as
conexes sejam fechadas quando no forem mais necessrias.


2.6 SQL Injection

Da maneira que implementamos a insero, h duas falhas: uma de
segurana e outra tcnica. A falha de segurana ocorre quando uma
pessoa mal intencionada ao preencher um formulrio, digita
propositalmente uma sentena em SQL que provoca um
comportamento no previsto.
Esse comportamento, pode por vezes, comprometer a segurana, as
vezes mostrando pessoa mal intencionada informaes
confidenciais que podem levar a apagar informaes do banco.
Esse tipo de ataque conhecido como SQL Injection.
O problema de SQL Injection pode ser resolvido manualmente. Basta

fazer escape dos caracteres especiais, por exemplo: ponto-e-
vrgula e apstrofo. No MySQL Server, os caracteres especiais
devem ser precedidos pelo caractere \. Ento seria necessrio
acrescentar \ em todas as ocorrncias de caracteres especiais nos
valores passados pelo usurio.
Esse processo, alm de trabalhoso, diferente para cada banco de
dados, pois o \ no padronizado e cada banco tem o seu prprio
mtodo de escape de caracteres especiais.
Tornando mais prtica a comunicao com o banco de dados o
prprio driver faz o tratamento das sentenas SQL. Esse processo
denominado sanitize.
// pegando os dados da editora pelo teclado

string nome = Console.ReadLine();
string email = Console.ReadLine();

// definindo a sentena SQL com parmetros
string textoDoComando =
@"INSERT INTO Editoras (Nome, Email) VALUES (?,
?);";

// criando um comando odbc
OdbcCommand comando = new
OdbcCommand(textoDoComando, conexao);



// atribuindo valores aos parmetros

comando.Parameters.AddWithValue("@Nome", nome);
comando.Parameters.AddWithValue("@Email",
email);
Observe que a sentena SQL foi definida com parmetros atravs do
caracter ?. Antes de executar o comando, necessrio atribuir
valores aos parmetros. Isso feito com o mtodo AddWithValue.
Esse mtodo realiza a tarefa de sanitizar os valores enviados pelo
usurio.
2.7 Fbrica de conexes (Factory)

Para cada ao executada no banco de dados, ns precisamos criar
uma conexo. Isso gera um problema relacionado string de
conexo ficar armazenada em diversos locais. Imagine que o driver
do banco foi atualizado e mudamos a sua verso. Isso implicaria
fazer diversas alteraes no cdigo em cada ocorrncia da string de
conexo, tornando o cdigo mais suscetvel a erros e dificultando a
sua manuteno.
Para resolver esta situao, podemos criar uma classe responsvel
pela criao e distribuio de conexes, mantendo assim uma nica
referncia para a conexo, e qualquer alterao no modo em que
nos conectamos base de dados, s implica mudanas nesta
classe.


3. Entity Framework

Entity Framework a ferramenta de Mapeamento Objeto-Relacional
(ORM) criada pela Microsoft e agora liberada dentro do modelo de
licena Open Source Apache 2.0 conforme divulgado no portal
CodePlex (http://entityframework.codeplex.com).
Entity Framework permite aos desenvolvedores, que trabalham com

dados relacionais, utilizarem objetos (domain-specific objects),
eliminando a necessidade do cdigo de acesso a dados que
normalmente temos que escrever.
Com ADO.NET Providers, o Entity Framework oferece suporte para
SQL Server, Oracle, MySQL, PostgreSQL, Sybase, Informix, Firebird,
DB2, Cach, e outros bancos de dados disponveis no mercado.
Arquitetura do Entity Framework
3.1 Mltiplas sintaxes da linguagem SQL

Seria bom se, ao invs de programar direcionado a um determinado
banco de dados, pudssemos programar de uma maneira mais
genrica, voltado uma interface ou especificao, assim
poderamos escrever o cdigo independente de SQL.


3.2 Orientao a Objetos VS Modelo Entidade Relacionamento
Outro problema na comunicao entre uma aplicao C# e um banco

de dados o conflito de paradigmas. O banco de dados
organizado seguindo o modelo entidade relacionamento, enquanto
as aplicaes C#, geralmente, utilizam o paradigma orientado a
objetos.
A transio de dados entre o modelo entidade relacionamento e o
modelo orientado a objetos no simples. Para realizar essa
transio, necessrio definir um mapeamento entre os conceitos
desses dois paradigmas. Por exemplo, classes podem ser mapeadas
para tabelas, objetos para registros, atributos para campos e
referncia entre objetos para chaves estrangeiras.
3.3 Ferramentas ORM
Para facilitar a comunicao entre aplicaes C# que seguem o

modelo orientado a objetos e os banco de dados que seguem o
modelo entidade relacionamento, podemos utilizar ferramentas que
automatizam a transio de dados entre as aplicaes e os diferente
bancos de dados e que so conhecidas como ferramentas de ORM
(Object Relational Mapper).
Outra consequncia, ao utilizar uma ferramenta de ORM, que no
necessrio escrever consultas em SQL, pois a prpria ferramenta
gera as consultas de acordo com a sintaxe da linguagem SQL
correspondente ao banco que est sendo utilizado. A principal
ferramenta ORM para C# o Entity Framework. Mas, existem outras
que possuem o mesmo objetivo.
3.4 Configurao

Antes de comear a utilizar o Entity Framework, necessrio baixar
instalar atravs do pacote
Install-Package EntityFramework -Version 5.0.0
Acompanhe as verses do Framework atravs do site

http://www.nuget.org/packages/EntityFramework/5.0.0


O EF 5.0, disponvel atravs do NuGet compatvel com o Visual
Studio 2010 e Visual Studio 2012 e pode ser utilizado em aplicaes
baseadas no .NET Framework 4.0 e 4.5.
Evoluo do Entity Framework


3.5 Mapeamento

Um dos principais objetivos dos frameworks ORM estabelecer o
mapeamento entre os conceitos do modelo orientado a objetos e os
conceitos do modelo entidade relacionamento.
Podemos definir as seguintes entidades:
public class Livro

{
public int idLivro { get; set; }
public string Titulo { get; set; }
public decimal Preco { get; set; }
public Editora Editora { get; set; }
}

public class Editora
{
public int id { get; set; }
public string Nome { get; set; }
public string Email { get; set; }
public ICollection<Livro> Livros { get; set; }
}
O Entity Framework oferece trs abordagens para desenvolvimento,

com objetivo de atender diferentes cenrios e skills da equipe de
desenvolvimento. As abordagens so: Database First, Model First e
Code First.


Veja abaixo qual a abordagem mais adequada para seu projeto.


Utilizaremosmos o padro Database First para permitir a persistncia

no banco de dados. Isto significa que as propriedades Editoras e
Livros sero mapeadas para as classes utilizando engenharia
reversa.
Cada propriedade definida nas tabelas Livro e Editora mapeada
para objetos no modelo do Entity.
Abaixo o processo de criao do Entity atravs da engenharia

reversa.
1. Crie um novo arquivo chamado Editora.edmx


2. Gere o modelo de um database existente
3. Na primeira vez, precisa criar uma conexo com seu Banco de

Dados


4. Clique em nova conexo e faa a configurao conforme seu
banco de dados
5. Teste a conexo e garanta que esteja funcionando

perfeitamente
6. Aps configurar a conexo, voc retornar para a tela de

escolha de banco de dados, porm agora com a sua conexo.


nesta hora que voc define para o objeto do Entity Data

Model, qual a varivel no web.config que ficar a conexo. No
nosso caso, vamos deixar CursoDealEntities e salvar no
web.config
7. A prxima etapa voc dever escolher os objetos do banco de

dados que devero ser mapeados para o Entity. No nosso
caso, as duas tabelas, Livros e Editoras.


8. Finalizando, temos a janela de diagramas do arquivo EDMX

exibindo as tabelas que foram mapeadas.
Ns no precisamos configurar nada para que a persistncia e o

mapeamento fossem feitos com o Entity - isto ocorreu simplesmente
escolhendo as tabelas no Data Model.
Quando se utiliza o modelo Code First, o processo inverso.

Baseado nas classes o Entity cria a estrutura e o relacionamento
entre as tabelas. Nestes casos, pode utilizar anotaes para
sobrescrever a conveno padro.


Para utilizar anotao adicione a referncia EntityFramework.dll e
System.ComponentModel.DataAnnotations.dll ao projeto e
acrescentar using para o namespace
System.ComponentModel.DataAnnotations.
Segue as principais anotaes:
ColumnAttribute Define o nome e o tipo da coluna no banco de

dados da propriedade mapeada.
DatabaseGeneratedAttribute Utilizado para indicar que o valor do

atributo gerado pelo banco de dados. Para definir como o atributo
gerado voc utiliza trs constantes do enum
DatabaseGenerateOption: DatabaseGeneratedOption.Identity que
define que o valor ser definido na insero e assume que no ser
mais alterado. DatabaseGeneratedOption.Computed que lido na
insero e a cada atualizao. DatabaseGeneratedOption.None
indica que o valor no ser gerado pelo banco de dados.
ForeignKeyAttribute adicionado a propriedade para especificar a

propriedade que define a chave estrangeira do relacionamento.
InversePropertyAttribute Indica a propriedade que define o

relacionamento. Esta anotao utilizada quando temos mltiplos
relacionamentos do mesmo tipo.
Por exemplo, suponha que tenhamos uma entidade Pessoa pode ser
autor ou revisor de um livro. Uma pessoa pode ter livros publicados e
livros revisados, portanto a entidade Pessoa tem dois
relacionamentos diferentes com a entidade Livro.
KeyAttribute Define a propriedades ou propriedades que identificam

uma entidade. Se a classe define propriedades com ID ou Id, ou
nome da classe seguido por ID ou Id, esta propriedade tratada
como chave primria por conveno. Caso contrrio, podemos definir
a nossa chave primria com o KeyAttribute.
MaxLengthAttribute Define o tamanho mximo permitido para um

array ou string.


MinLengthAttribute Define o tamanho mnimo permitido para um
array ou string.
StringLengthAttribute Define o tamanho mnimo e mximo

permitido para o campo string.
NotMappedAttribute Pode ser aplicado em classes ou

propriedades. Quando aplicado em classes ou propriedades indica
que este no ser includo no momento de definio do banco de
dados.
RequiredAttribute Define que este campo obrigatrio. Este

atributo ignorado em propriedades do tipo collection. Quando
definido numa referncia, indica que cardinalidade 1 e a
propriedade da chave estrangeira no-nula.
TableAttribute Define a tabela para o qual a classe mapeada.
3.6 Exerccios

- Crie um projeto novo.
- Crie um novo arquivo EDMX e faa o mapeamento da
estrutura das tabelas criadas
- Crie uma procedure chamada addEditora com o seguinte
cdigo:

CREATE PROCEDURE addEditoraProc
@NOME varchar(200),
@EMAIL varchar(200)
AS
INSERT INTO dbo.Editoras (NOME, EMAIL) VALUES (@NOME,
@EMAIL)

SELECT * FROM dbo.Editoras where ID = @@IDENTITY

GO
Repare que esta procedure retorna o valor da editora j preenchida


- Inclua a procedure dentro do modelo EDMX que foi criado.

Para isto, clique com o boto direito na janela do diagrama e
escolha Update model from Database
- Localize a procedure no modelo


- Assim que terminar o mapeamento, analise o Model Browser

(View -> Other Windows -> Entity Data Model Browser




- De uma olhada em como ficou o arquivo EDMX no editor xml
(este o arquivo que representa o objeto no diagrama)
- De uma olhada como ficou o arquivo EDMX.cs

// Default code generation is disabled for model '\\psf\home\documents\visual
studio 2012\Projects\Curso\Editora.edmx'. // To enable default code generation,
change the value of the 'Code Generation Strategy' designer
// property to an alternate value. This property is available in the Properties
Window when the model is
// open in the designer.
Repare que ainda necessrio um ajuste para poder termos o objeto

em cdigo gerado. No entanto, desta forma existente o Entity j est
pronto para ser utilizado.
- Clique com o boto direito na tela do Diagrama do Entity e

escolha propriedades


- Modifique as propriedades do Code Generation Strategy para

Default
- Analise o cdigo no arquivo Editora.Designer.cs com o

mapeamento em objetos da estrutura MER do SQL.


3.7 Manipulando entidades

Para manipular as entidades da nossa aplicao, devemos utilizar
uma classe Entity.
3.7.1 Persistindo

Para armazenar as informaes de um objeto no banco de dados
basta utilizar o mtodo SAVECHANGES() do DBCONTEXT. As
entidades com o estado Added so inseridas no banco de dados
quando o mtodo SAVECHANGES() chamado.
CursoDealEntities db = new CursoDealEntities();

Editoras editora = new Editoras();
editora.NOME = "Cadastro do entity";
editora.EMAIL = "entity@editora.com";
db.Editoras.AddObject(editora);
db.SaveChanges();
3.7.2 Buscando
Para obter um objeto que contenha informaes do banco de dados

basta utilizar a estrutura LINQ e fazer query diretamente no Entity

var Obj = (from c in db.Livros.Where(c=> c.ID_EDITORA ==
1) select c);
3.7.3 Removendo

As entidades com o estado Deleted so removidas do banco de
dados quando o mtodo SAVECHANGES() chamado. O mtodo
Remove remove a entidade do contexto e adiciona a entidade o
estado Deleted.
db.DeleteObject((from c in db.Editoras.Where(c=> c.NOME
== "Cadastro do entity") select c).First());


db.SaveChanges();
3.7.4 Atualizando

Para alterar os dados de um registro correspondente a um objeto
basta utilizar as propriedades dele. Quando as propriedades de uma
entidade do contexto alterada, o estado Modified adicionado a
esta entidade. Entidades com o estado Modified so atualizados no
banco de dados quando o mtodo SaveChanges chamado.

var livro = (from c in db.Livros.Where(c=> c.ID_LIVRO ==
1) select c).FirstOrDefault();
livro.PRECO = 19.50;
db.SaveChanges();
3.7.5 Listando
Para obter uma listagem com todos os objetos referentes aos

registros de uma tabela, podemos utilizar o Language Integrated
Query LINQ, que permite os desenvolvedores escreverem a consulta
em C#.

var Obj = (from c in db.Editoras select c);
3.8 Exerccios
- Abra seu projeto MVC e insira as manipulaes do entity na

HomeController e na Action Index()
- Debugar o seu projeto e conferir que os dados foram
manipulados na base de dados
- Criar uma nova Action conforme a seguir:
o Inserir (Editoras vmRetorno)
o Listar()
o Excluir (int id)
o Alterar (Editoras vmRetorno)


- Implementar o cdigo respectivo de cada Action
- Executar a chamada da action atravs do browser para garantir
a execuo da Ao.
3.9 Repository

O Entity oferece recursos suficientes para que os objetos do domnio
sejam recuperados ou persistidos no banco de dados. Porm, em
aplicaes com alta complexidade e grande quantidade de cdigo,
espalhar as chamadas aos mtodos do DBCONTEXT e DBSET
pode gerar dificuldades na manuteno e no entendimento do
sistema.
Para melhorar a organizao das nossas aplicaes, diminuindo o

custo de manuteno e aumentando a legibilidade do cdigo,
podemos aplicar o padro Repository do DDD ( Domain Driven
Design). Conceitualmente, um repositrio representa o conjunto de
todos os objetos de um determinado tipo. Ele deve oferecer mtodos
para recuperar e para adicionar elementos. Os repositrios podem
trabalhar com objetos prontos na memria ou reconstru-los com
dados obtidos de um banco de dados. O acesso ao banco de dados
pode ser realizado atravs de ferramenta ORM como o Entity
Framework.


4. Viso Geral do ASP .NET MVC

4.1 Necessidades de uma aplicao web

As aplicaes web so acessadas pelos navegadores (browsers). A
comunicao entre os navegadores e as aplicaes web realizada
atravs de requisies e respostas definidas pelo protocolo HTTP.
Portando, ao desenvolver uma aplicao web, devemos estar
preparados para receber requisies HTTP e enviar respostas HTTP.
Alm disso, na grande maioria dos casos, as aplicaes web devem
ser acessadas por diversos usurios simultaneamente.
Outra necessidade das aplicaes web gerar contedo dinmico.
Por exemplo, quando um usurio de uma aplicao de email acessa
a sua caixa de entrada, ele deseja ver a listagem atualizada dos seus
emails. Portanto, fundamental que a listagem dos emails seja
gerada no momento da requisio do usurio. O desenvolvedor web
precisa utilizar algum mecanismo eficiente que permita que o
contedo que os usurios requisitam seja gerado dinamicamente.
Trabalhar diretamente com as requisies e repostas HTTP e criar

um mecanismo eficiente para permitir o acesso simultneo e para
gerar contedo dinmico no so tarefas simples. Na verdade,
extremamente trabalhoso implementar essas caractersticas. Por
isso, a plataforma .NET oferece uma soluo para diminuir o trabalho
no desenvolvimento de aplicaes web.
4.2 Viso Geral do ASP .NET MVC
O ASP .NET MVC oferece muitos recursos para o desenvolvimento

de uma aplicao web .NET. Cada um desses recursos por si s j
so suficientemente grandes e podem ser abordados em separado.
Porm, no primeiro contato com ASP .NET MVC, interessante ter
uma viso geral dos recursos principais e do relacionamento entre
eles sem se aprofundar em muito nos detalhes individuais de cada
recurso.
Portanto, vamos analisar de forma sucinta e direta o funcionamento e
os conceitos principais do ASP .NET MVC. Discutiremos de maneira
mais detalhada as diversas partes do ASP .NET MVC.


4.3 Aplicao de exemplo
O primeiro passo para construir uma aplicao web utilizando ASP

.NET MVC criar um projeto no Visual Studio a partir do modelo
adequado. No nosso caso, o modelo de projeto que deve ser
utilizado o ASP.NET MVC 4 Web Application.
Devemos escolher Internet Application Project conforme figura

abaixo:


O projeto criado j vem com diversas pastas e arquivos.


A funo de cada pasta e de cada arquivo ser discutida adiante.
4.3.1 Testando a aplicao

Para verificar o funcionamento do projeto, basta execut-lo atravs
do menu: Debug -> Start Debugging. Automaticamente um servidor
de desenvolvimento inicializado na mquina e a aplicao
implantada nesse servidor.
Alm disso, uma janela do navegador padro do sistema aberta na
url principal da aplicao.
O servidor pode ser finalizado atravs do cone ASP.NET
Development Server que fica na barra de tarefas do Windows.
4.3.2 Trocando a porta do servidor

Para trocar a porta utilizada pelo servidor de desenvolvimento que o
Visual Web Developer utiliza, basta alterar as propriedades do
projeto clicando com o boto direito do mouse no projeto e
escolhendo o item properties e depois a aba Web.


4.4 Pgina de Saudao

Comearemos o desenvolvimento da nossa biblioteca do ensino
criando uma pgina de saudao. Essa pgina deve conter uma
mensagem diferente de acordo com o horrio atual.
Para implementar a pgina de saudao, devemos criar uma

controller que receber as requisies vindas do navegador do
usurio e devolver um HTML gerado dinamicamente.
A base das controllers System.Web.Mvc.ControllerBase.
A implementao padro desta classe abstrata
System.Web.Mvc.Controller.
Para criar nossa controller, devemos criar uma classe que seja filha
de System.Web.Mvc.Controller e o nome obrigatoriamente deve
conter o sufixo Controller.
Por padro, a url que deve ser utilizada para enviar uma requisio a
uma controller a concatenao da url principal da aplicao
seguido do nome da controller (ex: http: //localhost/Home).


Por conveno, o arquivo cs contendo o cdigo da controller deve
ser colocado na pasta Controllers.
4.5 Exerccios

- Crie um projeto do tipo ASP.NET MVC 4 Web Application
chamado Curso.
- Implemente uma pgina de saudao criando uma classe
dentro da pasta Controllers chamada SaudacaoController.
4.6 Alterando a pgina inicial
Por padro, as requisies so enviadas a controller Home.

Podemos alterar esse comportamento, modificando o arquivo de
rotas da aplicao, o RouteConfig que fica localizado na pasta
App_Start da sua aplicao.
Este cdigo:
public static void RegisterRoutes(RouteCollection

routes)
{
routes.MapRoute(
"Default", // Nome da Rota


"{controller}/{action}/{id}", // URL com
parametros
new { controller = "Home", action =
"Index", id = UrlParameter.Optional } // Valores Padres
);

}
Deve ser substitudo por este
public static void RegisterRoutes(RouteCollection

routes)
{
routes.MapRoute(
"Default", // Nome da Rota
"{controller}/{action}/{id}", // URL com
parametros
new { controller = "Biblioteca", action =
"Inicial", id = UrlParameter.Optional } // Valores
Padres
);

}
4.7 Integrando o Banco de Dados

A nossa aplicao web vai interagir com o banco de dados para
recuperar ou armazenar informao. Vimos que a comunicao com
uma base de dados pode ser encapsulada atravs do Entity. O entity
com suas classes que representam as entidades do sistema da
livraria devem ser colocadas na pasta Models do projeto web.
4.8 Exerccios
- Crie o objeto EDMX chamado Editora na pasta Models


4.9 Listando entidades

Uma funcionalidade bsica que a nossa aplicao web deve oferecer
para os usurios a listagem das entidades do sistema (livro e
editora). Para cada entidade, ser criado uma controller que ficar
encarregada de montar a lista da entidade correspondente.
Vamos construir um exemplo que lista as editoras a partir da URL
/Editoras.
Repare que a controller responsvel pela lista de editoras interage

com o Entity, fazendo um select com LINQ em deixando o resultado
em um objRetorno.
Alm disso, ele envia uma lista de editoras para a pgina atravs do
mtodo View().
Para listar as editoras que foram passados como parmetro pelo
EditorasController devemos criar uma pgina com o mesmo nome
da Action Index. Alm disso, esta pgina deve ser criada, por
conveno, dentro de uma pasta Editoras, com o mesmo nome do
nosso controller sem o sufixo Controller, dentro da pasta Views.




@model IEnumerable<Curso.Models.Editoras>

@{
ViewBag.Title = "Index";
}

<h2>Index</h2>

<p>
@Html.ActionLink("Create New", "Create")
</p>
<table>
<tr>
<th>
@Html.DisplayNameFor(model => model.NOME)
</th>
<th>
@Html.DisplayNameFor(model => model.EMAIL)
</th>
<th></th>
</tr>

@foreach (var item in Model) {
<tr>
<td>


@Html.DisplayFor(modelItem => item.NOME)
</td>
<td>
@Html.DisplayFor(modelItem => item.EMAIL)
</td>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
@Html.ActionLink("Details", "Details", new { id=item.ID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.ID })
</td>
</tr>
}

</table>
Para gerar o contedo dinmico de nossa pgina, estamos utilizando

Razor que permite acrescentar cdigo de servidor juntamente com
cdigo HTML de forma mais clara e concisa.
No ASP .NET MVC temos os Helpers que so classes que facilitam a

criao de uma pgina e ajudam na renderizao de elementos
HTML. Na nossa pgina Index estamos utilizando a propriedade Html
que uma instncia da classe System.Web.Mvc.HtmlHelper que
prov mtodos para renderizar elementos como input, select, anchor,
form. Veremos com mais detalhes os Helpers e Razor
posteriormente.
4.10 Exerccios

- Implemente uma controller chamada EditorasController para
que liste todas as editoras existentes na base de dados quando
a url /Editoras for requisitada.
- Implemente um controlador chamado LivrosController para que
liste todas as editoras existentes na base de dados quando a
url /Livros for requisitada.
4.11 Inserindo entidades

Outra funcionalidade fundamental que a aplicao web deve oferecer
aos usurios o cadastro de editoras e livros. O primeiro passo, para
implementar essa funcionalidade, criar um formulrio de cadastro
de editora e outro de livro. Por exemplo, suponha que para criar uma
editora devemos acessar a url /Editoras/Create. Primeiro devemos
criar uma mtodo para Action Create na controller EditorasController


que redirecionar para a pgina que contm o formulrio, quando
acessarmos a url /Editoras/Create pelo browser atravs de
requisio GET. Por conveno, o nome do mtodo o mesmo
nome da action.
public ActionResult Create()
{
return View();
}
Devemos agora criar a pgina que contm o formulrio para inserir

uma editora. Por padro, esta pgina dever ser criada na pasta
View/Editoras com o mesmo nome da action, portanto deveremos ter
um arquivo com o nome Create.cshtml.


Quando o usurio clicar no boto "submit", uma action dever
receber a requisio com os dados preenchidos no formulrio pelo
usurio. Os dados sero enviados atravs de uma requisio POST,
por padro, e deveremos ter uma action Create que receber os
dados de uma requisio POST. Por conveno, deveremos ter no
nosso controlador um mtodo com o mesmo nome da action e
restringiremos o mtodo para tratar somente requisies POST com
a anotao HttpPost. Neste mtodo faremos a insero da editora
atravs da classe do Entity.
4.12 Exerccios

- Crie um mtodo para action Create na controller
EditorasController responsvel por apresentar um formulrio de
cadastramento de editoras. Este formulrio dever ser
acessado atravs de uma URL /Editoras/Create. Ao enviar os
dados do formulrio para o servidor atravs de uma requisio
POST, defina um mtodo para esta action que receba estes
dados enviados pelo usurio e salve na base de dados
utilizando a nossa classe Entity.
- Crie um mtodo para action Create na controller
LivrosController responsvel por apresentar um formulrio de
cadastramento de livros. Este formulrio dever ser acessado
atravs de uma URL /Livros/Create. Ao enviar os dados do
formulrio para o servidor atravs de uma requisio POST,
defina um mtodo para esta action que receba estes dados
enviados pelo usurio e salve na base de dados utilizando a
nossa classe Entity.


Devemos permitir que o usurio possa definir a editora a qual o livro
pertence. Para isto, devemos ter uma caixa de seleo com todas as
editoras da nossa base de dados. Antes de criar a caixa de seleo,
devemos enviar uma lista para a nossa View, atravs da propriedade
ViewBag, com todas as editoras da nossa base de dado s.
Para construir a nossa caixa de seleo, podemos utilizar o mtodo

DropDownListFor do helper Html.


4.13 Alterando entidades

Normalmente surge a necessidade de atualizar os dados de uma
editora ou livro. Por exemplo, uma atualizao dos preos. Portanto,
a nossa aplicao deve permitir que o usurio faa alteraes nos
livros e nas editoras.
Suponha que para alterar as informaes da editora, o usurio
precise acessar a URL /Editoras/Edit/1, onde o 1 (um) define o ID da
editora que o usurio deseje alterar as informaes e ser passado
como parmetro na nossa action. O primeiro passo definir um
mtodo para a action Edit na controller EditorasController que
receber o Id da editora fornecido pelo usurio e encaminhar para o
formulrio de edio.
O formulrio de edio dever vir preenchido com as informaes da

editora que o usurio definiu. Para isto, passamos como parmetro
editora no mtodo View e acessamos atravs da propriedade Model.
Ao submeter o formulrio, requisio POST por padro, devemos ter

um mtodo para esta action que receber os dados enviados e far a
alterao em nossa base de dados.
Devemos acrescentar na nossa classe EditoraRepository o mtodo

AtualizarEditora.
4.13.1 Link de alterao
Nas listagens de editoras e livros, podemos acrescentar um link

alterao para cada item. Para isso, devemos alterar as pginas de
listagem.
4.14 Exerccios



- Implemente um mtodo para a action Edit na controller
EditorasController que ser responsvel por apresentar um
formulrio para a atualizao de uma editora. Ao submeter o
formulrio devemos ter um mtodo para esta action que
receber os dados enviados e far a alterao em nossa base
de dados. No esquea da modificar a pgina que lista as
editoras para chamar o formulrio de edio atravs de um
link.
- Implemente um mtodo para a action Edit no controlador
LivrosController que ser responsvel por apresentar um
formulrio para a atualizao de um livro. Ao submeter o
formulrio devemos ter um mtodo para esta action que
receber os dados enviados e far a alterao em nossa base
de dados. No esquea da modificar a pgina que lista os
livros para chamar o formulrio de edio atravs de um link.
4.15 Removendo entidades
Para finalizar nosso conjunto de funcionalidades bsicas,

implementaremos a remoo de entidades. Para isso podemos
adicionar um link de remover para cada item das listagens de
editoras e livros. Assim como fizemos com os links de alterao.
Depois de acrescentado o link de remoo nas listas, o prximo

passo implementar os mtodos para estas Actions nas controllers
que faro a remoo atravs das classes Entity.
Ao enviar uma requisio POST atravs da URL /Editoras/Delete/5, o

mtodo que tratar esta action ser o DeleteConfirmed. Para isto,
renomeamos a action com a anotao ActionName, pois por padro
a action contm o mesmo nome do mtodo da controller. Precisamos
tambm definir uma pgina de confirmao da remoo da entidade.


4.16 Exerccios

- Implemente os mtodos para as actions de remoo no
EditorasController que sero responsveis por remover uma
editora. No se esquea de modificar a pgina de listagem de
editoras para incluir o link de remoo.
- Implemente os mtodos para as actions de remoo no
LivrosController que sero responsveis por remover um livro.
No se esquea de modificar a pgina de listagem de livros
para incluir o link de remoo.
5. Tratamento de Erros

Inevitavelmente, as aplicaes esto sujeitas a erros de vrias
naturezas. Por exemplo, erros gerados pelo preenchimento incorreto
do campos de um formulrio. Esse tipo de erro causado por falhas
dos usurios. Nesse caso, importante mostrar mensagens
informativas com o intuito de fazer o prprio usurio corrigir os
valores preenchidos incorretamente.
Por outro lado, h erros que no so causados por falhas dos
usurios. Por exemplo, um erro de conexo com o banco de dados.
Nesses casos, improvvel que os usurios possam fazer algo que
resolva o problema. E mesmo que pudessem, provavelmente, no
seria conveniente esperar que eles o fizessem.
Quando um erro desse tipo ocorre, o ASP.NET cria uma pgina web
com informaes sobre o erro e a envia aos usurios. Para usurios
locais, o ASP.NET envia uma pgina web com informaes
detalhadas do erro ocorrido. Para usurios remotos, a pgina web
enviada no contm informaes detalhadas.
Em geral, no conveniente que os usurios recebam detalhes
tcnicos sobre os erros gerados por falhas da aplicao.
A primeira justificativa que esses detalhes podem confundir os

usurios. A segunda justificativa que esses detalhes podem expor
alguma falha de segurana da aplicao deixando a mais vulnervel
a ataques.
5.1 Try-Catch



Os erros de aplicao podem ser identificados atravs do comando
try-catch que pode ser colocado nos mtodos das actions das
controllers. Ao identificar a ocorrncia de um erro, a controller pode
mostrar uma pgina web com alguma mensagem para o usurio.
Devemos criar uma pgina Error.cshtml, por padro, na pasta

Views/Shared:
As pginas de erro que sero mostradas pelos controladores teriam

uma mensagem simples informando que houve um erro na aplicao
e que no possvel atender a requisio do usurio naquele
momento.
Inclusive, seria conveniente padronizar a pgina de erro. Em outras
palavras, todas as controllers teriam que mostrar a mesma pgina.
5.1.1 Exerccios
Altere o cdigo do mtodo da action Create da controller

EditorasController para capturar erros usando try-catch.
5.1.2 Custom Errors

Utilizar o comando try-catch nas controller para lidar com os erros de
aplicao no uma boa alternativa pois o cdigo fica mais
complexo. Alm disso, haveria replicao de cdigo nos
controladores pois provavelmente a pgina de erro seria
padronizada.
Qualquer alterao na pgina de erro implicaria em alteraes em
todos os controladores. Por exemplo, se a mensagem tivesse que
ser trocada.
Para lidar com os erros de aplicao de uma maneira mais prtica e
fcil de manter, podemos configurar o ASP.NET para utilizar pginas
de erro padro. O primeiro passo alterar o arquivo de configurao
Web.config, acrescentando a tag customErrors dentro da tag
system.web.
O atributo mode da tag customErrors pode assumir trs valores:

- On: A pgina de erro padro ser enviada para usurios locais
ou remotos.


- Off: A pgina de erro detalhada ser enviada para usurios
locais ou remotos.
- RemoteOnly: A pgina de erro detalhada ser enviada para
usurios locais e a padro para os remotos.
Por conveno, o ASP .NET MVC mantm uma pgina de erro

padro dentro da pasta Views/Shared com o nome Error.cshtml.
Vamos alterar este arquivo, o contedo da pgina de erro

basicamente HTML.
5.1.3 Exerccios

Configure a aplicao para utilizar pginas de erro padro. Lembre-
se que no vamos mais precisar do comando try-catch colocado
anteriormente.
5.1.4 Erros do HTTP
Um dos erros mais conhecidos do HTTP o 404 que ocorre quando

o navegador faz uma requisio por uma url que no existe.
Basicamente, esse erro gerado por falhas dos usurios
ao tentarem digitar diretamente uma url na barra de endereo dos
navegadores ou por links ou botes quebrados nas pginas da
aplicao.
Quando o erro 404 ocorre, o ASP.NET utiliza a pgina padro para
erros de aplicao configurada no Web.config atravs da tag
customErrors.
Porm, esse erro no deve ser considerado um erro de aplicao
pois ele pode ser gerado por falhas dos usurios. Ele tambm no
deve ser considerado um erro de usurio pois ele pode ser gerado
por falhas da aplicao. Consequentemente, comum tratar o erro
404 de maneira particular criando uma pgina de erro especfica
para ele.
<customErrors mode="On">
<error statusCode="404" redirect="~/ErrorPages/NotFound"/>
</customErrors>


No arquivo de configurao, podemos determinar uma pgina web
especfica para o erro 404 ou para os outros erros do HTTP.
Devemos definir uma controller com o nome ErrorPages, por padro,
alm do mtodo para a action NotFound.
5.1.5 Exerccios
- Crie uma pgina de erro e um controlador especfico para o

erro 404 e modifique o arquivo Web.config para fazer
redirecionamento apropriado.
6. Camada de Apresentao (View)

A responsabilidade da camada de apresentao relativamente
simples. Seu principal objetivo gerar o contedo atravs do
modelo. No importa como o controlador obteve atravs de servios
e lgica de negcios os dados que foram necessrios a construo
do objeto do nosso modelo, a camada de apresentao apenas
precisa saber como obter o modelo e gerar o contedo HTML
atravs dele.
Para desenvolver a camada de aplicao necessrio conhecimento
de HTML, CSS e JavaScript (Jquery). A camada de apresentao
responsvel por gerar o contedo da nossa aplicao web e este
contedo dinmico. Vamos ver como podemos gerar contedo
dinmico atravs de funcionalidades do ASP .NET MVC como Inline
Code, HTML Helper e Partial Views.
6.1 Inline Code

No ASP .NET MVC podemos inserir cdigo C# na View utilizando o
Razor ao invs do tradicional ASPX que obriga colocar o cdigo
entre <% ... %>. A principal caracterstica do Razor ser conciso e
simples, diminuindo o nmero de caracteres e tags scripts na View,
pois diferentemente de outras sintaxes, no h necessidade de
explicitar no cdigo HTML um bloco de cdigo de servidor.


Segue abaixo alguns exemplos cdigo utilizando Razor
A maneira mais simples de gerar contedo dinmico atravs de

inline code - que so blocos de cdigo inseridos com a tag @{ }.
@{
int x = 123;
string nome = Samuel;
}
<div>@model.Nome</div>
@foreach(var item in Editoras) {
@if (true) {
@model.Nome e um usuario
}
@* *@
Total de livros @model.Livros.Count()
6.2 Utilizando Inline Code

Suponha que tenhamos uma pgina EditoraDetails.cshtml e
queremos mostrar as informaes de um objeto da classe Editora:
public class Editora
{
public int id { get; set; }
public string Email { get; set; }
public virtual ICollection<Livros> Livros { get; set; }
}


Para mostrar as informaes da editora, utilizaremos a pgina
EditoraDetails.cshtml e a definiremos como strongly typed view
atravs do inline code: @model <seu namespace>.Editora.
@model IEnumerable<Curso.Models.Editoras>
@{
Layout = "~/Views/Shared/_Layout.cshtml";
ViewBag.Title = "Listar";
}
<h2>Listar Editoras</h2>
<p>
@Html.ActionLink("Nova Editora", "Create")
</p>
<table>
<tr>
<th>
@Html.DisplayNameFor(model => model.NOME)
</th>
<th>
@Html.DisplayNameFor(model => model.EMAIL)
</th>
<th></th>
</tr>

@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.NOME)
</td>
<td>
@Html.DisplayFor(modelItem => item.EMAIL)
</td>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
@Html.ActionLink("Details", "Details", new { id=item.ID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.ID })
</td>
</tr>
}

</table>
Deveremos ter a seguinte tela:


6.3 ViewData, ViewBag e Model

No ASP .NET MVC, a controller consegue fornecer dados a View
atravs de:
Dicionrio: Atravs do ViewDataDictionary podemos fornecer

dados atravs de key- >value. Key string e value object.
Por exemplo: ViewData["livros"] = Entity.BuscaTodas();
Propriedade Model: Cada ViewDataDictionary contm um

propriedade Model que armazena uma referncia para um
objeto qualquer. Podemos acessar este objeto atravs da
palavra Model em nossa View, ao invs de ViewData.Model
(ambos apontam para o mesmo objeto).
{ imagem do codigo da action Edit livros com ViewData}
No MVC podemos utilizar ViewBag ao invs de ViewData.

ViewBag uma coleo dinmica que permite o envio de
dados da controller para a View. O suporte a coleo dinmica
fruto do suporte a tipos dinmicos do .NET 4. Segue um
exemplo de ViewBag:
{ imagem do cdigo da action Edit Livros com ViewBag}
Segue abaixo um exemplo da View strongly-typed (a classe

esperada do Model Livro):
A combinao da controller e View ir gerar o seguinte response

HTML:
{ imagem da VIEW rodando}
6.4 HTML Helpers

A funo das pginas .cshtml gerar HTML para enviar aos
navegadores dos usurios. Os arquivos .cshtml misturam tags HTML


com scripts de servidor escritos em C# (ou outra linguagem de
programao suportada pelo .NET). Essa mistura pode prejudicar a
legibilidade do cdigo em alguns casos. Veja o exemplo da listagem
de editoras.
{ IMAGEM COD EXEMPLO @FOREACH COM UMA VIEW}
Para aumentar a legibilidade das pginas .cshtml e

consequentemente facilitar a manuteno da aplicao, o ASP.NET
oferece os chamados HTML Helpers. A funo de um HTML Helper
encapsular um cdigo HTML. Por exemplo, para adicionar um link
podemos usar o mtodo ActionLink do objeto Html, ao invs, da tag
<a>.
6.4.1 ActionLink Helper

O helper ActionLink utilizado para gerar os links das pginas web.
Esse helper aceita vrios parmetros e a maneira mais simples de
utiliz-lo passar a ele dois parmetros: o texto do link e a ao que
ser chamada.
@Html.ActionLink("TEXTO PARA O USURIO", "ACTION" )
Caso queiramos acrescentar um link para redirecionar para um outro

controlador, devemos acrescentar um terceiro parmetro:
@Html.ActionLink("TEXTO PARA O USURIO", "ACTION",

"CONTROLADOR" )
O ActionLink permite que parmetros sejam adicionados no link

gerado. Para isso, basta acrescentar um parmetro.
@Html.ActionLink("TEXTO PARA O USURIO", "ACTION", new

{controller = "CONTROLADOR", param = "valor"} )


6.4.2 Helpers de Formulrios

Para facilitar a criao dos elementos de entrada de dados, h um
conjunto de HTML Helpers.
Para criar um formulrio, podemos utilizar o Helper BeginForm.
@using(Html.BeginForm()) {
Caso no especifiquemos parmetros na chamada do mtodo

BeginForm, o formulrio enviar uma requisio para a mesma URL
da requisio atual.
Ou podemos passar como parmetro a action e o controlador:
@using(Html.BeginForm("ACTION", "Controller")) {
existem tambm os formulrios Ajax, na sua definio padro

usamos:
@using(Ajax.BeginForm(ACTION, Controller, new AjaxOptions() {
HttpMethod = post, // para determinar o post
InsertionMode = InsertionMode.Replace, // para substituir o
contedo
UpdateTargetId =nomedoDiv // nome do elemento html que ser
atualizado no post deste formulrio
})
Por padro, o formulrio enviar uma requisio POST. Devemos

definir na controller o mtodo que ir receber esta requisio.
Para definir os campos do nosso formulrio, podemos utilizar os

HTML Helpers string-based:
Check Box:


@Html.CheckBox("meuCheckBox", false)



<input id="meuCheckBox" name="myCheckbox" type="checkbox" value="true" />
<input name="meuCheckBox" type="hidden" value="false" />

Text Box:

@Html.TextBox("meuTextbox", "valor")

<input id="meuTextbox" name="meuTextbox" type="text" value="valor" />
Text Area:

@Html.TextArea("meuTextarea", "valor")

<textarea cols="20" id="meuTextarea" name="meuTextarea" rows="2">valor</textarea>

Radio Button:

@Html.RadioButton("meuRadiobutton", "valor", true)


<input checked="checked" id="meuRadiobutton" name="meuRadiobutton" type="radio"
value="
valor" />
Hidden Field:


@Html.Hidden("meuHidden", "valor")

<input id="meuHidden" name="meuHidden" type="hidden" value="valor" />
Password Field:

@Html.Password("meuPassword", "valor")

<input id="meuPassword" name="meuPassword" type="password" value="valor" />
Utilizando HTML Helpers strongly typed:
Check Box:

@Html.CheckBoxFor(x => x.IsAtivo)



<input id="IsAtivo" name="IsAtivo" type="checkbox" value="true" />
<input name="IsAtivo" type="hidden" value="false" />
Text Box:

@Html.TextBoxFor(x => x.Nome)

<input id="Nome" name="Nome" type="text" value="Valor do Nome" />
Text Area:

@Html.TextAreaFor(x => x.Descricao)

<textarea cols="20" id="Descricao" name="Descricao" rows="2">Valor da
Descricao</textarea>
Radio Button:

@Html.RadioButtonFor(x => x.IsAtivo, "valor")

<input checked="checked" id="IsAtivo" name="IsAtivo" type="radio" value="valor" />
Hidden Field:


@Html.HiddenFor(model => model.Id)

<input id="Id" name="Id" type="hidden" value="Valor do Id" />
Password Field:

@Html.PasswordFor(x => x.Password)

<input id="Password" name="Password" type="password"/>
Suponha que tenhamos o seguinte exemplo:

@Html.TextBox("Nome")
Isto equivalente a:
@Html.TextBox("Nome", ViewData.Eval("Nome"))


Caso a key Nome da ViewDataDictionary da pgina no exista, o

valor deste elemento ser preenchido com ViewData.Model.Nome.
Lembrando que para acessar o value associado a key, podemos
utilizar, por exemplo, ViewBag.Nome, equivalente a
ViewData["Nome"].
No caso de Helpers HTML strongly typed, o valor do elemento ser

sempre associado a propriedade ViewData.Model da pgina.
6.4.3 DropDownList Helper

No cadastramento dos livros, os usurios podem escolher uma
editora. A editora selecionada atravs de um drop down list. Para
criar um drop down list, podemos utilizar um HTML Helper.
O primeiro passo para utilizar o DropDownList criar uma SelectList
no controlador.
{ IMAGEM CODIGO CONTROLLER ATRIBUINDO LISTA}
O segundo passo adicionar o drop down list na pgina .cshtml.


@Html.DropDownList("EditoraId")


@Html.DropDownListFor(model => model.EditoraId, ViewBag.EditoraId as SelectList)
Pelo fato do Helper HTML strongly typed Drop Down List no aceitar
tipos dinmicos, devemos fazer o cast para SelectList.
6.4.4 Editor Helper
Suponha que tenhamos o seguinte exemplo:
{ imagem editora class}
Para editar o cadastro de uma editora, teramos uma pgina

Edit.cshtml conforme exemplo abaixo:


{ IMAGEM EDIT.CSHTML da editora}
Para cada propriedade do nosso modelo Editora, definimos um

Helper apropriado para gerar o elemento HTML para a entrada de
dados. Por exemplo, no caso da propriedade Nome e Email
utilizamos o Helper Text Box.
Temos a seguinte tela:
{ IMAGEM DA EDIT.CSHTML RODANDO}
Podemos utilizar o Helper Editor que define o Helper HTML

apropriado de acordo com o tipo da propriedade. Para propriedades
e valores do tipo booleano, o helper utilizado ser o Check Box, j
para elementos do tipo string, o helper o Text Box.
Podemos editar a nossa pgina Edit.cshtml para utilizar o Helper

Editor:
{ imagem cdigo da edit.cshtml com os editfor}
Teremos a seguinte tela:
{ imagem da edit.cshtml rodando}
Podemos perceber que a tela ficou "parecida", porm para a

propriedade Id foi definido o Helper Text Box e o mais apropriado o
Helper Hidden. O Helper Editor no consegue definir em todos os
casos, o Helper mais apropriado. Para casos especficos, o MVC
prov templates para definir o Helper mais apropriado para
determinada propriedade do nosso modelo.
Por exemplo, para a propriedade Id, devemos acrescentar uma
anotao indicando que para esta propriedade queremos utilizar o
Helper Hidden.
Na propriedade Id acrescentamos a anotao

System.Web.Mvc.HiddenInputAttribute que definir para esta
propriedade o Helper Hidden. Com isto, teremos a seguinte tela:


{ imagem da edit.cshtml id hidden rodando}
Os templates para entrada de dados so:
Tambm temos o Helper EditorForModel que percorrer todas as

propriedades do ViewData.Model associado a pgina, e definir o
Helper apropriado para cada uma das propriedades.
@Html.EditorForModel()
6.5 Exerccios
Utilize o projeto definido anteriormente e altere o mtodo da

action Edit do controlador Editoras para enviar a informao da
hora do servidor.
Altere a View Editora.cshtml para mostrar a hora do servidor.
Altere a View Editora.cshtml para utilizar somente Helpers
string based.
Acrescente o seguinte trecho cdigo ao controlador Editoras e
verifique o que acontece ao acessar a tela de edio de
editoras.
Hora atual: @ViewBag.Hora
Altere a pgina Edit.cshtml de Editoras para utilizar o helper

Editor.


Altere a classe Editora para que o Helper Editor defina o Helper

Hidden para a propriedade Id.
Altere a pgina Editora.cshtml para utilizar o Helper
EditorForModel.
6.6 Master Pages / Layout
comum que as pginas de uma aplicao web possuam contedo

em comum (por exemplo: um cabealho ou um rodap). O contedo
em comum pode ser replicado em todas as pginas atravs do
CTRL+C e CTRL+V. Porm, essa no uma boa abordagem pois
quando alguma alterao precisa ser realizada, todos os arquivos
devem ser modificados. Tambm comum que as pginas de uma
aplicao web possuam um certo padro visual. Da surge o conceito
de Master Page.
6.6.1 Contedo comum

Tudo que comum a todas as pginas de um determinado grupo
pode ser definido em uma Master Page ou Layout. Dessa forma,
qualquer alterao facilmente realizada modificando apenas um
arquivo. Por exemplo, suponha que toda pgina da aplicao web da
livraria deva ter o mesmo ttulo e a mesma formatao. Podemos
criar um _Layout com o ttulo utilizado nas pginas e com a
referncia ao arquivo CSS que define a formatao padro.
Alguns detalhes:
Estamos acrescentando @RenderBody() que indica onde o
contedo das pginas ser encaixado.
No title acrescentamos @ViewBag.Title, isto permitir que o title
seja especfico a cada pgina.
O prximo passo indicar quais pginas utilizaro esse _Layout. Por
exemplo, podemos atualizar a pgina Edit.cshtml de Editoras para
utilizar a _Layout.cshtml como layout principal:
@model Curso.Models.Editoras
@{
ViewBag.Title = "Criar uma Editora";
}
<h2>Create</h2>
@using (Html.BeginForm()) {
@Html.AntiForgeryToken()


@Html.ValidationSummary(true)

<fieldset>
<legend>Editoras</legend>

<div class="editor-label">
@Html.LabelFor(model => model.NOME)
</div>
<div class="editor-field">
@Html.EditorFor(model => model.NOME)
@Html.ValidationMessageFor(model => model.NOME)
</div>

@Html.LabelFor(model => model.EMAIL)
</div>
@Html.EditorFor(model => model.EMAIL)
@Html.ValidationMessageFor(model => model.EMAIL)
</div>

<p>
<input type="submit" value="Create" />
</p>
</fieldset>
}

<div>
@Html.ActionLink("Voltar", "Listar")
</div>
A pgina Edit.cshtml executada antes de _Layout.cshtml, o que

permitiu acrescentarmos valor ao ViewBag.Title. Isto tambm facilita
na definio de elementos meta e head, por exemplo, para fins de
SEO.
Para definir o layout de Edit.cshtml foi necessrio acrescentar o

caminho completo a propriedade Layout. Este procedimento no
muito prtico, pois em cada pgina devemos definir esta
propriedade.
No ASP .NET MVC, temos uma nova funcionalidade que permitir

definir um layout padro a todas as pginas no havendo
necessidade de definir a propriedade Layout em cada uma. Basta
acrescentarmos a pasta View o arquivo _ViewStart.cshtml:
@{
}

Como este cdigo executado no incio de cada view, no h mais


necessidade de definir a propriedade Layout em cada pgina.
6.6.2 Lacunas

Tambm podemos criar lacunas na Master Page para serem
preenchidas com contedos definidos nas pginas. Segue a pgina
_Layout.cshtml:
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width" />
<title>Curso Deal - @ViewBag.Title</title>
</head>
<body>
<div>
<div style="width:100%;float:left;"><h1>Biblioteca do Ensino</h1></div>
<div style="width:auto;float:left;height:30px;"></div>
<div style="width:100%;float:left;">
@RenderBody()
</div>
<div style="width:100%;float:left;">
@RenderSection("rodape",required:false)
</div>
</div>
@System.Web.Optimization.Scripts.Render("~/bundles/jquery")
@RenderSection("scripts", required: false)
</body>
</html>
Para especificar uma lacuna em nosso layout, devemos utilizar o

helper @RenderSection(string Nome Da Seo, bool
Obrigatoriedade):
Para definir a seo, devemos utilizar o cdigo @section. Segue a
pgina Edit.cshtml de Editoras:
@model Curso.Models.Editoras
@{
ViewBag.Title = "Criar uma Editora";
}
<h2>@ViewBag.Title</h2>
<fieldset>



</div>
</div>

</div>
</div>
<p>
<input type="submit" value="Criar" />
</p>
</fieldset>
}
<div>
@Html.ActionLink("Voltar", "Listar")
</div>
@section rodape {
Ateno este texto do rodap
}
@section Scripts {
@System.Web.Optimization.Scripts.Render("~/bundles/jqueryval")
}
Em cada View voc pode ainda utilizar o mtodo

IsSectionDefined(NomedaSection) para identificar se h no seu
layout aquela section, podendo desta forma inserir contedo
especfico para a determinada seo.
6.7 Exerccios

Crie uma pgina que servir de layout para a nossa aplicao
Altere a pgina Edit.cshtml de Editoras para utilizar a pgina de
layout definido no exerccio anterior.
Defina a pgina _Layout.cshtml como layout padro de cada
view.
Defina sees na pgina _Layout.cshtml.
Acrescente uma lacuna a pgina _Layout.cshtml.
Defina na pgina Edit.cshtml de Editoras a seo rodape
Acrescente uma seo padro as pginas que no definiram a
seo rodape.


6.8 Importao Automtica

Quando necessrio utilizar uma classe ou interface nas pginas
.cshtml, devemos acrescentar a diretiva using adequada. Algumas
classes e interfaces so utilizadas em muitas pginas. Para no ter
que adicionar a diretiva de importao em todas as pginas,
podemos alterar o arquivo de configurao (Web.config) da pasta
Views fazendo com que todas as pginas j tenham acesso a
determinados namespaces.
<pages>
<namespaces>
<add namespace="System.Web.Helpers" />
<add namespace="System.Web.Mvc" />
<add namespace="System.Web.Mvc.Ajax" />
<add namespace="System.Web.Mvc.Html" />
<add namespace="System.Web.Optimization" />
<add namespace="System.Web.Routing" />
<add namespace="System.Web.WebPages" />
</namespaces>
</pages>
6.9 Exerccios

Edite o arquivo Web.config da pasta Views para fazer as importaes
de bibliotecas automaticamente.
6.10 Dividindo o contedo
Quanto mais elaborada uma pgina web maior o seu cdigo.

Quando o cdigo muito extenso a sua legibilidade fica prejudicada.
Para organizar melhor o cdigo, podemos dividir o contedo de uma
pgina web em vrios arquivos .cshtml.
Suponha que desejamos dividir o contedo de uma pgina em duas

partes. Devemos criar um arquivo para cada parte.
Por fim, devemos criar um arquivo .cshtml principal para agrupar as
partes. Utilizaremos o mtodo Partial para inserir o contedo dos
arquivos secundrios no arquivo principal.
O mtodo Partial procura o arquivo Parte1.cshtml e Parte2.cshtml no
mesmo diretrio do arquivo principal. Caso ele no encontre, ele


procura o arquivo na pasta Views/Shared. Isto serve tambm para o
mtodo View que utilizamos na controller.
O Partial View permite criarmos contedo reutilizvel de forma mais

clara e concisa. As informaes entre as Views e Partial Views
podem ser compartilhadas atravs da ViewBag.
Podemos, por exemplo, alterar as pginas Create.cshtml e
Edit.cshtml de Editoras para acrescentar uma partial view do
formulrio, pois ambas as pginas compartilham o mesmo
formulrio.
6.11 Exerccios

Crie uma partial view para o formulrio de Editora
Altere as pginas Create.cshtml e Edit.cshtml de Editoras para

utilizar a partial view _Form.cshtml.
7. Controles (Controller)
No ASP .NET MVC as URLs so mapeadas para classes que so

chamadas de controllers. Os controladores (controllers) processam
as requisies, recebem dados enviados pelos usurios, executam
comandos para recuperar dados do modelo e chamam a view
apropriada para gerar o HTML para a requisio.
Os requisitos para uma classe ser considerada controller :

O nome deve terminar com o sufixo Controller
A classe deve implementar a interface IController ou herdar da
classe System.Web.Mvc.Controller
Raramente voc definir uma classe controller implementando a

interface IController. Comumente definiremos uma classe controller
herdando de System.Web.Mvc.Controller.


7.1 Actions

Nas aplicaes ASP .NET que no utilizam MVC, as interaes do
usurio em torno das pginas, em torno de eventos vindos da
pgina e de seus controles. No ASP .NET MVC a interao do
usurio em torno dos controllers e actions.
Uma classe controller contm mtodos que so as actions.
Uma action utilizada para processar uma requisio HTTP e ela
pode conter 0 (zero) ou mais argumentos.
Para criar uma action preciso definir o mtodo como public e, na
maioria das vezes, o valor de retorno ser uma instncia de uma
classe que deriva de ActionResult.
Quando o usurio faz uma requisio atravs do Browser, o ASP

.NET MVC verifica na tabela de rotas, o controller que ir receber a
requisio.
O controller ir definir o mtodo apropriado para processar a
requisio. Por padro, as URLs seguem a estrutura
{NomeDoController}/{NomeDaAction}. Caso o usurio acesse a URL
http://www.exemplo.com/Editoras/Listagem, por padro, Editoras
ser considerado como o prefixo do nome do controller
(EditorasController, o controlador termina com o sufixo Controller) e
Listagem como o nome da action. Ao acessar a url
/Editoras/Alterar/1, por padro, Alterar ser considerado uma action
do controller EditorasController e 1 ser enviado como parmetro
para o mtodo Alterar.
7.2 ActionResult
Aps o controller receber a requisio e process-la, ele devolve

uma resposta para o usurio. O controller responde basicamente de
trs maneiras:
Retorna uma resposta HTML ao chamar uma View
Redireciona o usurio atravs do HTTP Redirect
Retorna a resposta em outro formato. Por exemplo: XML, Json,
arquivo binrio


No ASP .NET MVC temos uma classe apropriada para cada tipo de
retorno que derivada de ActionResult.
7.3 Parmetros
Vimos que os parmetros enviados pelos usurios podem ser

recuperados nos controladores atravs da propriedade Request.
Mas, h outras maneiras de recuperar esses valores.
7.3.1 Vrios parmetros

Uma das maneiras de recuperar os dados enviados pelos usurios
definir um parmetro C# para cada parmetro HTTP enviado pelo
usurio. necessrio definir os parmetros C# com o mesmo nome
dos parmetros HTTP.


[HttpPost]
public ActionResult Salva(string nome, string email)
{
Editora editora = new Editora { Nome = nome, Email = email };
return View();
}
7.3.2 Por objeto

O ASP.NET tambm capaz de montar objetos com os valores dos
parmetros HTTP enviados pelo usurio e pass-los como
argumento aos controladores.
As propriedades dos objetos recebidos como argumentos nos
mtodos dos controladores precisam ter os mesmos nomes dos
parmetros HTTP.
public ActionResult Alterar (Editoras vmRetorno)
{
return View(vmRetorno);
}
7.4 Exerccios

Adicione na controller Editoras uma action para visualizar o
formulrio de cadastro.
Crie uma pgina Create.cshtml de cadastro de editoras na
pasta Views/Editoras
Defina um mtodo para action HttpPost Create na controller
Editoras que ir receber os dados enviados pelo usurio e
adicionar uma editora ao banco de dados.
Altere o mtodo da action Salva para receber os dados como
parmetro e/ou objeto
7.5 TempData

Ao efetuar um redirecionamento, uma nova requisio efetuada
pelo browser. Nesta nova requisio no temos mais acesso aos
dados e objetos da requisio anterior ao redirecionamento. Caso
haja a necessidade de preservar os dados ao longo do
redirecionamento podemos utilizar o TempData.


Ao salvar uma Editora, por exemplo, efetuamos um redirecionamento
para a tela de listagem. Podemos acrescentar uma mensagem
indicando que a operao foi efetuada com sucesso.
db.SaveChanges();
TempData["mensagem"] = "Editora criada com sucesso!";
return RedirectToAction("Listar");
Devemos acrescentar na tela de listagem o seguinte trecho de

cdigo:
@if (TempData["mensagem"] != null)
{
<p>@TempData["mensagem"]</p>
}
7.6 Exerccios

Ao adicionar uma editora e redirecionar o usurio para a tela
de listagem, mostre uma mensagem ao usurio indicando que
a operao foi realizada com sucesso.
(opcional) Mostre mensagens para o usurio nas operaes de
atualizao e remoo de editoras.


8. Rotas

Para acessar uma determinada ao da nossa aplicao, os
usurios devem utilizar a URL correspondente ao. Por exemplo,
para acessar a listagem de categorias, necessrio digitar na barra
de endereo do navegador a seguinte url: http://localhost/Editoras/
Lista. Perceba que o padro concatenar o nome a controller com o
nome do mtodo desejado. Esse padro definido por uma rota
criada no arquivo RouteConfig.cs.
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id =
UrlParameter.Optional }
);
O primeiro argumento do mtodo MapRoute o nome da rota, o

segundo a expresso que define o formato da rota e o terceiro o
conjunto de valores padres dos parmetros da rota.
A expresso que determina do formato da rota define trs
parmetros: o controlador que deve ser criado, o mtodo que deve
ser chamado no controlador e um argumento para esse mtodo.
Dessa forma, se o usurio digitar a
http://localhost/Editoras/Remove/1 na barra de endereo do seu
navegador o ASP.NET criar uma instncia do controlador de
editoras e executar o mtodo Remove passando o valor 1 como
argumento.
EditorasController controlador = new EditorasController(conexao);

controlador.Remove(1);
A rota define um padro para URL e define como ela ser tratada.


8.1 Adicionando uma rota
Para acrescentar uma rota podemos utilizar o mtodo MapRoute. A

ordem em que as rotas so acrescentadas muito importante.
Acrescente rotas mais especficas antes de rotas menos especficas.
Suponha que queiramos acessar a nossa lista de livros atravs da
URL /Biblioteca.
routes.MapRoute("Nova Rota", "Biblioteca",new { controller = "Livros", action = "Index" });
8.2 Definindo parmetros
Podemos acrescentar parmetros a nossa rota. Podemos definir, por

exemplo, a listagem de livros por editora.
routes.MapRoute("Nova Rota", "Biblioteca/{editora}",new { controller = "Livros", action =

"Index" });
Quando definimos o parmetro editora na rota acima,

obrigatoriamente devemos pass-la na nossa URL. Para torn-la
opcional, podemos utilizar UrlParameter.Optional.
routes.MapRoute("Nova Rota", "Biblioteca/{editora}", new { controller = "Livros", action =

"Index", editora = UrlParameter.Optional });
Ao definir parmetros opcionais, devemos utilizar parmetros do tipo

nullable type nos mtodos das actions. Pois quando no definimos o
parmetro na URL, atribudo o valor null ao parmetro do mtodo.
No caso de int e double, por exemplo, devemos utilizar int?, double?


8.3 Exerccios
Acrescente uma nova rota para acessarmos a lista de livros

atravs da URL /Biblioteca.
Acrescente um parmetro editora a rota criada no exerccio
anterior.
Verifique o que acontece ao acessar a URL /Biblioteca aps o
acrscimo do parmetro editora rota. Corrija este problema
definindo o parmetro editora como opcional.
Altere o mtodo de listagem de livros para receber o parmetro
editora da URL.
(opcional) Defina a lgica para listar os livros de acordo com o
parmetro editora da URL.
9. Validao
Os usurios podem cometer erros ao preencher um formulrio. Por

exemplo, esquecer de preencher um campo que obrigatrio. Os
parmetros enviados pelos usurios devem ser validados pela
aplicao com o intuito de no permitir o armazenamento de
informaes erradas.
9.1 Controller

O primeiro passo para implementar a validao dos parmetros
enviados pelos usurios definir a lgica de validao.
if (editora.NOME == null || editora.NOME.Trim().Length == 0)
{
// Erro de Validao
}
O segundo passo definir mensagens informativas para enviar aos

usurios. O ASP.NET possui um objeto especializado no
armazenamento de mensagens de erros de validao (ModelState).

{
// Erro de Validao
ModelState.AddModelError("Nome", "O preenchimento do campo Nome obrigatrio");
}


As mensagens so armazenadas no ModelState atravs do mtodo
AddModelError. Esse mtodo permite que as mensagens sejam
agrupadas logicamente pois ele possui dois parmetros: o primeiro
o grupo da mensagem e o segundo e a mensagem propriamente.
O cdigo de validao pode ser colocado nas controllers, mais

especificamente nas aes. Se algum erro for encontrado, o fluxo de
execuo pode ser redirecionado para uma view que mostre as
mensagens informativas aos usurios.
Normalmente, essa view a mesma do formulrio que foi preenchido
incorretamente. O objeto ModelState possui uma propriedade que
indica se erros foram adicionados ou no. Essa propriedade se
chama IsValid.
{
ModelState.AddModelError("Nome", "O preenchimento do campo Nome obrigatrio");
}
if (ModelState.IsValid)
{
db.SaveChanges();
}
return View(editora);
O ASP.NET tambm pode adicionar mensagens no ModelState

antes do controlador ser chamado. Normalmente, essas mensagens
esto relacionadas a erros de converso. Por exemplo, um campo
que espera um nmero preenchido com letras.
9.2 View

As mensagens dos erros de validao podem ser acrescentadas na
pgina web atravs do mtodo ValidationSummary da propriedade
Html. importante salientar que esse mtodo adiciona todas as
mensagens de erro.


<fieldset>

</div>
</div>

</div>
</div>
<p>
<input type="submit" value="Criar" />
</p>
</fieldset>
}
Podemos utilizar o mtodo Html.ValidationMessage para mostrar

somente as mensagens de erro de um determinado grupo. Para no
mostrar erros das propriedades devemos acrescentar true ao nosso
mtodo ValidationSummary.
9.3 Exerccios
Insira a validao dos campos nas editoras e livros da nossa

aplicao. A editora deve ter obrigatoriamente nome e email, e
o livro deve ter o nome, preo e editora relacionada. No caso
do livro, o preo tambm no pode ser menor que zero. Voc
deve informar ao usurio o erro ocorrido atravs do mtodo
Html.ValidationMessage ou Html.ValidationMessageFor.
9.4 Anotaes

As lgicas de validao mais utilizadas tambm podem ser
implementadas atravs de anotaes adicionadas nas classes de
model. Dessa forma, essas lgicas no estariam mais nas
controllers, o que conceitualmente o ideal pois nas controllers s
deveria existir lgica para controlar o fluxo da execuo da aplicao.


Para utilizar essas anotaes, necessrio adicionar uma dll na
aplicao. O nome da dll :
System.ComponentModel.DataAnnotations.dll
9.4.1 Required

Uma das validaes mais comuns a de campo obrigatrio. Ela
pode ser realizada atravs da anotao Required.

[Required]
Com essa anotao a lgica de validao pode ser retirada da

controller.
if (ModelState.IsValid)
{
db.SaveChanges();
}
return View(editora);
9.4.2 Alterando a mensagem

As anotaes de validaes possuem mensagens padres que
podem ser alteradas atravs da propriedade ErrorMessage
[Required(ErrorMessage="O campo Nome obrigatrio")]
9.4.3 Outros validadores

H outras anotaes para validao:
Range
Compare
ReqularExpression
StringLength


9.5 Validao no lado do Cliente

No ASP .NET MVC a validao no cliente est habilitada por padro.
Para funcionar corretamente a validao, voc deve acrescentar as
referncias corretas das bibliotecas javascript jQuery e jQuery
Validation na View. Utilize para isto o BundleConfig onde dever ficar
a organizao de seus ScriptBundle e StyleBundle.
O bundle parte do Web.Optimization e deve ser includo na
referencia do web.config <add namespace="System.Web.Optimization" /> para
que possa ser utilizado em suas pginas.
Insira na View do _Layout o bundle para o seu Jquery:
@System.Web.Optimization.Scripts.Render("~/bundles/jquery")

Insira na View do _Layout o bundle para o seu Css:
@System.Web.Optimization.Styles.Render("~/Content/css")

9.6 Exerccios

Altere as validaes feitas anteriormente, para utilizar
DataAnnotations.
Lembre-se de alterar todas as mensagens de erro para a
lngua portuguesa.
Acrescente tambm a validao no cliente.
10. Sesso

Quando um cliente for navegar na aplicao ele pode ter, por
exemplo, um carrinho de compras, que uma informao gerada
durante a navegao de um e-commerce. A medida que ele visita as
Views, ele pode adicionar ou remover itens do seu carrinho virtual.
Porm isto um problema, j que o protocolo HTTP no armazena
estado (stateless) das pginas visitadas anteriormente. Desse modo
no podemos armazenar a informao entre uma pgina e outra.


10.1 Sesso

Nossa tarefa encontrar um modo de armazenar estes dados no
servidor e deixar a informao disponvel para diferentes pginas da
aplicao. Para solucionar este problema, utilizado o conceito de
sesso. Uma sesso uma maneira de armazenar informaes
geradas durante a navegao no lado do servidor. Como o sistema
pode ter vrios usurios navegando simultaneamente, tambm
devemos encontrar uma maneira de separar este conjunto de
informaes por usurio, para que no haja nenhum tipo de conflito.
Para isto precisamos identificar unicamente cada usurio da nossa
aplicao de maneira que cada um tenha sua prpria sesso.
10.1.1 Identificando o Usurio

Uma primeira abordagem seria distinguir cada usurio utilizando o
endereo de IP. Porm, caso existam usurios em uma rede local,
eles teriam o mesmo IP e no seria possvel identifica-los
individualmente. Podemos considerar ainda o caso de um usurio
com o IP dinmico, caso ele reconecte durante a navegao, toda a
informao do seu histrico recente ser perdida.
A soluo seria deixar a cargo do servidor a gerao de um
identificador nico e envi-lo para cada usurio. Desta maneira, a
cada requisio, o cliente envia de volta este ID de forma que a
aplicao possa reconhec-lo. O cliente pode reenviar o seu ID de
diferentes formas.
As mais utilizadas so:
Reescrita de URL: Nesta maneira, o ID embutido nas

prprias URLs da aplicao. Sendo assim o ID pode ser
reconhecido pela aplicao em todas as requisies. Uma
desvantagem que todas as pginas devem ser geradas
dinamicamente para conter o ID em todos os links e actions.
Outro problema que este ID fica aparente na barra de
navegao do navegador facilitando o acesso de pessoas mal
intencionadas que poderiam, por sua vez, obter informaes
confidenciais. Uma vez que a URL no contm mais o
identificador, a aplicao considera que o usurio no tem uma
sesso associada.


Cookies: um arquivo criado pelo servidor no navegador do

cliente. Uma de suas funes persistir o ID da sesso. A
cada requisio a aplicao consulta o ID da sesso no cookie
para recuperar as informaes do usurio. Esta a maneira
mais utilizada. A sesso pode ser encerrada com a retirada do
cookie no navegador. Podemos fazer explicitamente atravs de
uma rotina de logout no servidor, ou podemos deix-la expirar
por tempo de inatividade, ou seja, caso o usurio fique um
determinado tempo sem fazer novas requisies, a sesso
encerrada.
10.2 Utilizando Session no ASP.NET

No ASP.NET, a sesso um dicionrio. Para armazenar
informaes, voc deve adicionar uma chave e um valor no objeto
Session. Imagine um objeto do tipo Editora que agrupa as
informaes sobre um determinada editora. O cdigo a seguir um
exemplo de como podemos guardar as informaes relacionadas ao
cliente no momento do login.
Session["Editora"] = editora;

Voc pode adicionar qualquer tipo de valor na sesso. De forma
anloga, para resgatar a informao armazenada, basta acessar a
chave correspondente no objeto Session, como no exemplo a seguir:
Editora editora = (Editora)Session["Editora"];
string saudacao = "Bem vindo " + editora.Nome;
Caso um usurio deslogue do sistema preciso eliminar a

informao acumulada em sua sesso. Para isto podemos
simplesmente remover todas as chaves do dicionrio como no
exemplo a seguir.
Session.RemoveAll();
Contudo, fazendo isto no estaramos terminando com a sesso, o

que desejvel ao fazer um logout. Ento, para terminar com a
sesso, voc deve utilizar o comando Session.Abandon().

Session.Abandon();


11. Filtros
Muitas vezes em um sistema ns queremos restringir o acesso

determinadas reas, seja por segurana ou por organizao. Por
exemplo, na nossa aplicao poderamos definir que para poder
adicionar, alterar e remover tanto editoras quanto livros, o usurio
deveria estar logado no sistema. Caso contrrio, o usurio apenas
pode listar as editoras e os livros.
if (Session["cliente"] != null)
{
return View();
}
else
{
return RedirectToAction("Index", "Login");
}
No exemplo acima, o mtodo vai verificar se o usurio j est logado,

atravs do uso da sesso. Se no estiver logado, ele ser
redirecionado para a pgina de Login . Apesar de funcionar, este
cdigo apresenta uma inconvenincia. Temos que adicionar essa
lgica a todas as Actions que queremos que tenha o mesmo
comportamento, ou seja, que apenas permitam o acesso de usurios
logados.
Em outros casos, podemos querer que algumas Actions executem

alguma tarefa em comum. Por exemplo, na nossa Biblioteca,
poderamos adicionar uma mensagem em um arquivo de Log
sempre que uma Action fosse realizada. Desse modo, poderamos
guardar um histrico sobre o que a aplicao mais realizou, qual foi a
pgina mais visitada, etc.
Mas novamente, teramos que adicionar a mesma tarefa em todas as
Actions da nossa aplicao.
Nesses casos, em que vrias Actions possuem um mesmo
comportamento em comum, podemos utilizar o conceito de Filtros.
Um filtro semelhante a um mtodo que executado antes ou
depois que uma Action realizada.


11.1 Filtro de Autenticao
O ASP.NET j possui alguns filtros prontos para serem utilizados,

como o filtro de autenticao. Podemos utilizar ele para o nosso
primeiro exemplo, onde exigimos que o usurio esteja logado
(autenticado) para acessar determinadas reas da aplicao. Para
isso precisamos adicionar o seguinte cdigo no nosso mtodo de
login:
FormsAuthentication.SetAuthCookie(cliente.Usuario, false);
Isto adiciona um novo cookie utilizado para a autenticao do

usurio. Este novo cookie independente do cookie utilizado para
armazenar informaes da sesso. O primeiro parmetro referente
ao nome do usurio (ou algo que o identifique). O segundo
parmetro um booleano relativo ao tipo do cookie, se permanente
ou no. Caso seja true, ele sempre ir considerar que o usurio est
autenticado aps a primeira autenticao.
Para eliminar o cookie de autenticao, devemos realizar o seguinte
cdigo no logout:
FormsAuthentication.SignOut();
Para adicionar o filtro, devemos incluir a anotao Authorize nas

Actions em que desejamos a autenticao:
[Authorize]
public ActionResult Index()
{
return View();
}
Se queremos aplicar o mesmo filtro a todas as Actions de um

controller, podemos adicionar a notao Authorize na classe:
[Authorize]
public class HomeController : Controller
{
[Authorize]
{
return View();
}
}


Desse modo, todas as Actions presentes na controller exigem que o
usurio esteja autenticado.
Quando o filtro de autenticao barra um usurio de acessar uma
pgina, podemos redirecion-lo para a pgina de login.
Devemos incluir o seguinte cdigo dentro da tag <system.web>:
<authentication mode="Forms">
<forms loginUrl="~/Conta/Index" timeout="2880"/>
</authentication>
Para checar se a sesso est autenticada, podemos utilizar o

atributo IsAuthenticated, como a seguir:
if (User.Identity.IsAuthenticated)
{
//...
}
Podemos pegar a informao de quem est autenticado atravs do

seguinte comando:
string nome = User.Identity.Name;
Isto ir pegar o nome que passamos como parmetro para o mtodo

SetAuthCookie.
11.2 Exerccios

Altere a aplicao do captulo anterior para incluir autenticao
nas Actions de adicionar, alterar e remover de editoras e livros.
Na Action de Login do ContaController, adicione o cookie de
autenticao como visto na seo anterior, passando o nome
de usuario como parmetro.
No layout principal, altere a seo que mostra o nome do
usurio, para utilizar a informao do cookie de autenticao, e
no mais da sesso.
Caso o usurio no esteja autenticado, e tente acessar uma
das Actions acima, redirecione atravs do Web.Config para a
Action de Login.


11.3 Action Filters

O filtro de autenticao no o nico filtro que existe no ASP.NET
MVC. Outro tipo muito usado so os chamados Action Filters.
Geralmente so usados quando queremos executar uma ao
especfica para mais de uma Action. Por exemplo, quando queremos
gravar as aes que esto sendo realizadas em um arquivo de log.
Para criar um Action Filter voc deve utilizar o sufixo Attribute no

nome da classe, e herdar a classe ActionFilterAttribute.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Http.Filters;

namespace Curso
{
public class LogAttribute : ActionFilterAttribute
{
//...
}
}
O nome utilizado na classe o mesmo utilizado nas anotaes das

Actions, excluindo o sufixo attribute. Por exemplo, para aplicar o filtro
LogAttribute no mtodo que lista as Editoras:
[Log]
{
return View();
}
Para fazer o filtro funcionar, deve ser implementado um ou mais dos

seguintes mtodos:
OnActionExecuting(ActionExecutedContext filterContext);
OnActionExecuted(ActionExecutingContext filterContext);
OnResultExecuting(ResultExecutedContext filterContext);
OnResultExecuted(ResultExecutingContext filterContext);
Eles so executados na mesma ordem em que aparecem acima,

sendo que todos so executados antes da renderizao da pgina.


Logo, o nosso exemplo com o filtro de log poderia ficar assim:
{

public override void OnActionExecuted(ActionExecutedContext filterContext)
{
// escreve informao de log
}
}
Tambm possvel passar parmetros para o filtro da seguinte

maneira:
[Log(Message="Executando lista de editoras")]
public ActionResult Listar()
{
List<Editoras> objRetorno = (from c in db.Editoras select c).ToList();
return View(objRetorno);
}
Sendo que a classe LogAttribute precisa ter um atributo ou

propriedade com o mesmo nome do parmetro passado.

{
public string Message { get; set; }

public override void OnActionExecuted(ActionExecutedContext filterContext)
{
// escreve informao de log
}
}
Voc pode passar vrios parmetros na anotao, separando-os por

vrgulas.
11.4 Exerccios
Crie um filtro chamado LogAttribute, que grava mensagens em

um arquivo de Log, chamado log.txt sempre que uma Action
chamada.
A informao no log deve incluir a data, horrio e pequena
descrio da Action realizada.
Aplique este filtro a todas as Actions da bibiloteca.


12. Projeto

Nos captulos anteriores, vimos os recursos do ASP .NET MVC e do
Entity Framework. Agora, vamos solidificar os conhecimentos obtidos
e, alm disso, mostraremos alguns padres e conceitos relacionados
ao desenvolvimento de aplicaes web.
Como exemplo de aplicao desenvolveremos uma aplicao de

cadastro de biblioteca, com autenticao do usurio, cadastro de
editoras e de livros, bem como pesquisas e consultas destes.
12.1 Modelo

Por onde comear o desenvolvimento de uma aplicao? Essa
uma questo recorrente. Um timo ponto de partida desenvolver as
entidades principais da aplicao. No nosso caso, vamos nos
restringir s entidades Usuario, Editoras e Livros. Devemos
estabelecer um relacionamento entre essas entidades j que uma
editora possui uma lista de livros.
12.2 Exerccios
Crie um projeto do tipo ASP.NET MVC chamado Curso;

Adicione na pasta Models um Entity mapeado para seu
banco de dados.
Adicione propriedades e anotaes.
12.3 Persistncia Repositrios

Vamos deixar os repositrios para acessar as entidades da nossa
aplicao preparados. Os repositrios precisam de mtodos para
operarem com o banco de dados.
12.4 Apresentao Template

Vamos definir um template para as telas da nossa aplicao.
Aplicaremos algumas regras CSS para melhorar a parte visual das
telas


Na pasta Content, altere o arquivo Site.css acrescentando algumas
regras css
Altere o arquivo _Layout.cshtml.
12.5 Cadastrando e Listando Editoras

Na tela de editoras, vamos adicionar um formulrio para cadastrar
nova editora e uma tabela para apresentar as j cadastradas.
Aplicaremos regras de validao especficas para garantir que
nenhum dado incorreto seja armazenado no banco de dados.
12.6 Exerccios

Para cadastrar a editora, devemos definir a controller.
Vamos criar uma tela Create.cshtml para cadastrar as editoras.
Adicione o arquivo a pasta Views/Editoras com o seguinte contedo.
O prximo passo definir a action que ir salvar a editora no nosso

banco de dados. Devemos tambm acrescentar as validaes a
nossa entidade.
Defina a action e a pgina para listar todas as entidades de seleo.

Vamos definir a tela de listagem de Editoras como a pgina principal
do nosso site.
Altere a rota padro no arquivo RouteConfig.
12.7 Removendo Editoras

Vamos acrescentar a funcionalidade de remover editoras.
12.8 Exerccios

Acrescente uma coluna na tabela de listagem de editora.
Defina um mtodo Busca na classe Editora Repository que
retorna uma entidade editora a partir de um parmetro id.
Defina uma action Delete que ir mostrar a tela de confirmao

de remoo da entidade.


Defina a tela de confirmao de remoo da editora.

Defina um mtodo na classe Editora Repository que remove
uma entidade editora a partir de um parmetro id.
Defina a action que remove a editora do banco de dados.
12.9 Cadastrando, Listando e Removendo Livros

Na tela de Livros, vamos adicionar um formulrio para cadastrar
novos livros e uma tabela para apresentar os j cadastrados.
Aplicaremos regras de validao especficas para garantir que
nenhum dado incorreto seja armazenado no banco de dados.
12.10 Exerccios

Para cadastrar o livro, devemos definir a controller.
Vamos criar uma tela Create.cshtml para cadastrar os livros.
Adicione o arquivo a pasta Views/Livros com o seguinte
contedo.
O prximo passo definir a action que ir salvar o livro no
nosso banco de dados.
Devemos tambm acrescentar as validaes a nossa entidade.
Defina a action e a pgina para listar todas as entidades de
jogador.
12.11 Removendo Livros

Vamos acrescentar a funcionalidade de remover Livros.
12.12 Exerccios

Acrescente uma coluna na tabela de listagem de livros.
Defina um mtodo Busca na classe Livros Repository que
retorna uma entidade livro a partir de um parmetro id.
Defina uma action Delete que ir mostrar a tela de confirmao
de remoo da entidade.
Defina a tela de confirmao de remoo do livro.
Defina um mtodo na classe Livros Repository que remove
uma entidade jogador a partir de um parmetro id.


Defina a action que remove o livro do banco de dados.
12.13 Membership e Autorizao

Na maioria dos casos, as aplicaes devem controlar o acesso dos
usurios. Vamos implementar um mecanismo de autenticao na
nossa aplicao utilizando filtro e Membership. As requisies feitas
pelos usurios passaro pelo filtro. A funo do filtro verificar se o
usurio est logado ou no. Se estiver logado o filtro autoriza o
acesso. Caso contrrio, o filtro redirecionar o usurio para a tela de
login
12.14 Exerccios

Adicione a seguinte classe a pasta Models:
Acrescente a seguinte classe a pasta Controllers.
Crie uma pasta Usuario na pasta Views e acrescente os quatro

arquivos.
12.21.1 Adicionando um Usurio Administrador com ASP .NET Configuration

Antes de definir o filtro Authorize nos controladores de nosso site,
vamos criar um usurio com acesso. A maneira mais fcil de criar o
usurio atravs do Configuration.
12.15 Exerccios

12.15.1 Autorizao Role-based

Podemos restringir o acesso as pginas com o filtro Authorize e
podemos especificar o role que o usurio precisa ter para ter acesso
a pgina.
12.16 Exerccios



Altere o filtro de autenticao no Web.config para redirecionar o
usurio para a action Index da controller Conta.
12.17 Controle de Erro

Podemos configurar uma pgina de erro padro para ser utilizada
toda vez que um erro ocorrer.
12.18 Exerccios
Acrescente ao arquivo Web.config a tag customErrors para

especificar a pgina de erro padro.
A tag customErrors fica dentro da tag system.web.
Defina a controller Erro e as pginas de erros padro.
As pginas de erro padro sero criadas dentro da pasta Views
numa subpasta Erro.
Altere o mtodo de listagem de livros para criar um erro em
nosso site.
Altere a tela de erro adicionando um formulrio para o usurio
escrever uma mensagem para os administradores da
aplicao.
Crie uma controller que envie as mensagens para o banco de
dados utilizando uma nova tabela de erro.
Crie uma pgina Envia.cshtml para mostrar ao usurio que a

mensagem foi enviada com sucesso e acrescente um link para
a pgina inicial do site.

Apostila MVC

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Apostila MVC

Caricato da

Copyright:

Formati disponibili

Resolvo

Tecnologia & Solues

Samuel Vaz eu@resolvo.com.br

Samuel Vaz eu@resolvo.com.br

Samuel Vaz eu@resolvo.com.br

O nosso objetivo desenvolver aplicaes que necessitam

Considerando todos esses aspectos, conclumos que seria

Samuel Vaz eu@resolvo.com.br

1.2 SQL Server

Neste treinamento, utilizaremos o SQL Server, que mantido pela

Microsoft SQL Server Management Studio

1.3 Bases de dados (Databases)

Samuel Vaz eu@resolvo.com.br

1.3.1 Criando uma base de dados no SQL Server

Repare que alm da base de dados CursoDeal pode haver outras

Samuel Vaz eu@resolvo.com.br

Samuel Vaz eu@resolvo.com.br

No SQL Server os nomes das tabelas so precedidas pelo ID do

INSERT INTO dbo.Livros (Titulo, Preco) VALUES ('ASP.NET

SELECT * FROM dbo.Livros

Samuel Vaz eu@resolvo.com.br

SELECT * FROM dbo.Livros

DELETE FROM dbo.Livros

Samuel Vaz eu@resolvo.com.br

1.6 Chaves Primria e Estrangeira

Na tabela Livros, poderamos adicionar uma coluna para armazenar

Porm, h um problema nessa abordagem, a tabela Editoras aceita

Para resolver esse problema, deveramos criar uma restrio na

Samuel Vaz eu@resolvo.com.br

Toda tabela pode ter uma chave primria, que um conjunto de um

Ento, poderamos adicionar um campo numrico na tabela Editoras

Altere os campos para torn-los obrigatrios, NO permitindo que

Alm disso o campo Id deve ser uma chave primria.

O campo Id dever ser incrementado automaticamente. Defina ele

Samuel Vaz eu@resolvo.com.br

4. Crie uma tabela chamada Livros conforme as figuras abaixo:

Samuel Vaz eu@resolvo.com.br

Voc precisa tornar o campo ID_EDITORA uma chave estrangeira.

Devemos acrescentar o relacionamento entre livro e editora. Clique

Samuel Vaz eu@resolvo.com.br

Devemos informar qual a chave primria que a coluna

5. Adicione alguns registros na tabela Editoras. Veja exemplos

Samuel Vaz eu@resolvo.com.br

6. Adicione alguns registros na tabela Livros. Veja exemplos

INSERT INTO dbo.Livros (TITULO, preco, ID_EDITORA)

7. Consulte os registros da tabela Editoras, e em seguida

Samuel Vaz eu@resolvo.com.br

8. Altere alguns dos registros da tabela Livros. Veja o exemplo

UPDATE dbo.Livros set PRECO = 300.00 WHERE ID_LIVRO = 1

9. Altere alguns dos registros da tabela Editoras. Veja o exemplo

UPDATE dbo.Editoras set NOME ='ORelly' WHERE ID = 1

10. Remova alguns registros da tabela Livros. Veja o

DELETE dbo.Livros where ID_LIVRO = 3

11. Remova alguns registros da tabela Editoras.

DELETE dbo.Editoras where ID = 3

12. Faa uma consulta para buscar todos os livros de uma

Samuel Vaz eu@resolvo.com.br

Agora ns vamos desenvolver uma aplicao para acessar os dados

2.3 ODBC Manager

2.4 Criando uma conexo

Todas essas informaes so definidas na chamada string de

Samuel Vaz eu@resolvo.com.br

2.5 Inserindo registros

string textoDoComando = @"INSERT INTO Editoras