CREACIN DE UNA APLICACIN WEB

ASP.NET MVC
1) New -> Project -> Aplicacin Web -> MVC -> Marcar opcin para agregar
Unit Test
2) Estructura de la solucin:

Carpetas de informacin sobre la aplicacin:

Properties
References

Carpetas propias de la aplicacin:

App_Data: almacena los datos de la aplicacin, generalmente las bases de

datos de Microsoft Sql. Por defecto est vaca
App_Start: contiene los archivos de cdigo que se ejecuta para realizar todas
las configuraciones necesarias al iniciarse la aplicacin.
Content: contiene las hojas de estilo (.css), conos, imgenes, temas.
Controllers: archivos de controlador (.cs) que contienen la lgica de negocio;
reciben peticiones HTTP desde la aplicacin y realizan las gestiones
correspondientes. MVC requiere que todos los archivos de controladores
finalicen con el texto "Controller". Por defecto se crean 2 controladores uno
para el inicio de sesin (AccountController) y otro para el inicio de la aplicacin
(HomeController).
Models: contiene las clases que representan el modelo de la aplicacin. Se
encargan de manipular los datos de la aplicacin
Scripts: contiene los archivos javascript (.js), es decir todo el cdigo que se
ejecuta del lado del cliente. Por defecto se agrega un conjunto de ficheros que
se usan para las llamadas AJAX y la biblioteca de JQuery (que es la que usa por
defecto el Visual Studio)
Views: contiene archivos de vistas, los cuales se relacionan con la "Interface
de Usuario". En la carpeta de vistas existe una carpeta por cada controlador y
adems la carpeta "Shared" que posee todo aquello que sea comn para todos
los controladores, entre ellas _Layout.cshtml que posee un comportamiento
similar a las MasterPages de los WebForms, podemos alojar tambin
ViewUserControl comunes.

Archivo de configuracin:

Global.asax: este archivo es la clase de entrada a nuestra aplicacin, a partir

del mtodo Application_Start(). En el vamos a definir el enrutmamiento de las
direcciones URL
Packages.config
Web.config: archivo XML que posee toda la configuracin de la aplicacin

CONTROLLER
Para agergar un nuevo controlador: clic derecho en carpeta Controller->New>Controller->Empty Controller
Nos crea una nueva clase y dentro de sta un nico mtodo Index que sera el
mtodo de acceso a nuestro controlador. El mtodo devuelve ActionResult que
lo debe generar la llamada a View().
Como comentario nos indica cmo podremos acceder a nuestro controlador.

Enrutamiento:
El enrutamiento ASP.NET permite usar direcciones URL que no es necesario
asignar a archivos especficos del sitio web, por lo tanto se pueden usar
direcciones URL que describan la accin del usuario y por tanto, sean ms
fciles de comprender.
(En una aplicacin que no usa enrutamiento, una slicitud entrante de una URL
se asigna a un archivo fsico que controla la solicitud, como un archivo .aspx )
Adems, en el enrutamiento de ASP.NET se se pueden incluir marcadores de
posicin en un modelo de direccin URL de modo que se puedan pasar datos
variables al controlador de solicitudes sin necesidad de una cadena de
consulta.
Los modelos de direccin URL para las rutas en las aplicaciones de MVC suelen
incluir los marcadores de posicin {controller} y {action}.
Por ejemplo, una direccin URL que incluye la ruta de acceso /Products est
asignada a un controlador denominado ProductsController. El valor del
parmetro action es el nombre del mtodo de accin que se invoca. Una
direccin URL que incluye la ruta de acceso /Products/show dara lugar a una
llamada al mtodo Show de la clase ProductsController.

El Modelo de direccin URL predeterminado es el siguiente:

{controller}/{action}/{id}
y una direccin que se corresponde con este enrutamiento sera:
http://server/Catalogo/Listado/cursos
Controller: Catalogo
Action: Listado
Id: cursos
En caso de que el mtodo no sea Index entonces debemos especificarlo.
public string Listado()
{
return "Acceso al listado";
}

Parmetros
Lo normal es que al menos en los mtodos de edicin, borrado o detalle
enviemos un parmetro, que puede ser el ID del modelo con el que trabaje el
controlador.
En ese caso lo ms sencillo es usar el parmetro por defecto que nos ofrece el
entorno que no es otro que ID.
public string Editar(int id)
{
return "Acceso al mtodo editar con el parmetro id a " +
id.ToString(CultureInfo.InvariantCulture);
}

Lo primero que nos preguntamos es, qu ha pasado con los parmetros por
QueryString?. No hay que preocuparse sigue funcionando igual, y se puede

reemplazar y acceder como hasta ahora.

Si ponemos la direccin http://localhost:52314/UA/Editar/?id=2, veremos que el
resultado es el mismo. Incluso si cambiamos la llamada al mtodo y quitamos
el parmetro y lo leemos desde dentro funciona igual.
public string Editar()
{
return "Acceso al mtodo editar con el parmetro id a " +
Request.QueryString["id"];
}

Pasar ms de un parmetro
En ocasiones necesitaremos pasar ms de un parmetro al mtodo por
ejemplo el id y el tipo de salida:
public string Editar(int id, string salida)
{
return "Acceso al mtodo editar con el parmetro id a " +
id.ToString(CultureInfo.InvariantCulture) +
" y salida a " + salida;
}

Y lo llamaramos con dos parmetros:

Obtendramos el mismo resultados con:

http://localhost:49166/Demo/Editar/2?salida=texto
http://localhost:49166/Demo/Editar?id=2&salida=texto

Configurar enrutamiento en MVC3

El enrutamiento que se define por defecto al crear el proyecto con la plantilla el
fichero global.asax:
public class MvcApplication : System.Web.HttpApplication
{
public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
filters.Add(new HandleErrorAttribute());
}

public static void RegisterRoutes(RouteCollection routes)

{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.MapRoute(
"Default", // Route name
"{controller}/{action}/{id}", // URL with parameters
new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
}
}

Si quisiramos aadir un tercer parmetro a la ruta que indicara el idioma de la

aplicacin, sera tan sencillo como aadir en la seccin MapRoute el parmetro
{language}.
routes.MapRoute(
name: "Default",
url: "{language}/{controller}/{action}/{id}",
defaults: new {languaje = "es", controller = "Home", action = "Index", id = UrlParameter.Optional }

Enrutamiento en MVC4
El proceso es muy parecido pero en ficheros diferentes. En MVC 4 no se usa
global.asax para estas funciones y se gestiona en el fichero RouteConfig.cs,
dentro de la carpeta App_Start.
public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
}
public class RouteConfig
{
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
//Aqu se define el formato
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);
}
}

VISTA
Despus de crear el controlador debemos personalizarlo para visualizarlo:
public class DemoController : Controller
{
// GET: Demo
public ActionResult Index()
{
return View();
}

Si la palabra View aparece subrayado significa que no se ha declarado la vista

para ese mtodo. Para hacerlo nos ponemos dentro del cdigo del mtodo y
pulsamos botn derecho y luego Add View:

Aparece una ventana con muchas opciones, pero la mayora desactivadas. Las
opciones por defecto seleccionan el motor de trabajo Razor y que utilice layout
o master page. La dejamos tal cual y pulsamos Add.

Nos genera un cdigo muy bsico:

@{
ViewBag.Title = "Index";
}
<h2>Index</h2>

Que si lo visualizamos en el navegador obtendremos

Del cdigo generado destacar tres cosas:

1) La sintaxis @{ .. } es de Razor y nos permite ejecutar cdigo C# o el

lenguaje con el que se trabaje en el proyecto
2) Aparece un objeto ViewBag que no hemos declarado, pero que tiene
propiedades, en este caso Title. Este objeto se usa para pasar datos entre
nuestro controlador y la vista.
3) Por defecto usa como master page el que est definido por defecto (Views
> Shared > _Layout.cshtml)
Por ejemplo si queremos mostrar el mensaje "Acceso al mtodo por defecto"
dentro de la vista y que sea el propio controlador quien se lo mande,
deberamos incluir una lnea ms en el controlador, asignando una nueva
propiedad a ViewBag el texto que queramos. En este caso se los asigno a
Mensaje, pero podra usarse cualquier otro nombre.
public ActionResult Index()
{
ViewBag.Mensaje = "Acceso al mtodo por defecto";
return View();
}

Pulsando e botn derecho dentro del cdigo del mtodo y en esta ocasin
seleccionar Go To View

Accediendo a la capeta Views, desplegar Demo y visualizaremos

Index.cshtml. Doble clic sobre el fichero y lo tendremos abierto para trabajar.

Ahora incorporamos cdigo para visualizar el mensaje. Con Razor se hace con
@NombreVariable o @NombreObjeto.Propiedad

@{
ViewBag.Title = "Index";
}
<h2>Index</h2>
@ViewBag.Mensaje

El resultado sera el siguiente:

La primera impresin que tenemos al trabajar con Razor es que estamos

volviendo al ASP clsico (VBScript) o que tenemos que aprender un nuevo
lenguaje.
Con un ejemplo creo que quedar ms claro. Con WebForms cuando queramos
escribir cdigo tenamos dos formas en el ASPX o en el CS.
ASPX
<% if(User.Type == admin) { %>
<span>Hola, <%= User.Username %></span>
<% } %>
<% else { %>
<span>Debes identificarte para poder acceder a esta seccin</span>
<% } %>

CS
if(User.Type == admin) {
Response.Write (<span>Hola, + User.Username + </span>);
}
else {
Response.Write (<span>Debes identificarte para poder acceder a esta
seccin</span>);
}

En Razor queda menos engorroso el cdigo, ya que el HTML y la sintaxis propia,

se integran perfectamente.
@if(User.Type == "admin") {
<span>Hola, @User.Username</span>
} else {
<span> Debes identificarte para poder acceder a esta seccin </span>
}

Razor
En una sintaxis basada en C# (aunque se puede programar en Visual
Basic) que permite usarse como motor de programacin en las vistas o
plantillas de nuestros controladores. Es una de las novedades de ASP.NET
MVC 3.
No es el nico motor para trabajar con ASP.NET MVC. Entre los motores
disponibles
destaco
los
ms
conocidos:
Spark,
NHaml,
Brail,
StringTemplate o NVelocity, algunos de ellos son conversiones de otros
lenguajes de programacin.
Con ASP.NET MVC 4 se ha incorporado nuevas funcionalidades a Razor
que simplifican algunas tareas cotidianas
Tambin destacar que dispone IntelliSense dentro de Visual Studio con
lo que agiliza enormemente programar dentro de las vistas.
@{ var miVariable = valor; }
@{
var miVariable1 = valor1;
var miVariable2 = valor2;

- Cada lnea debe llevar su ; al final de sta.

- Mi recomendacin es utilizar var en vez del tipo de dato, siempre que
inicialicemos la variable, independiente del tipo.
@{
var mensaje = ;
if(User.Type == admin) {
mensaje = Administrador del sistema; }
else { mensaje = Gestor; }
}

Muestra de variables
<p>El valor de la variable es @miVariable</p>

Todos las variables que mostremos con @ son parseadas con HTML Encode.
Lo que hace es remplazar smbolos <, > o & por sus correpondientes cdigos.
De esta manera evitemos que nos introduzcan cdigo mal intencionado que
pueda alterar el comportamiento de nuesto programa.
Si lo que quiere mostrar est dentro de etiquetas HTML (por ejemplo span) se
puede escribir
@if(true)
{ <span>La hora es:
else

@DateTime.Now</span>

<span>Aqu no se debera acceder nunca</span> }

En caso de que no hubiera etiquetas este cdigo dara error

<span>
@if(true)
{ La hora es: @DateTime.Now }
else
{ Aqu no se debera acceder nunca }
</span>

Porque no sabe si es cdigo HTML o cdigo C#. Para definrselo anteponemos

@: (si slo es una lnea) para decirle que es HTML
<span>
@if(true)
{
@:La hora es: @DateTime.Now
}
else
{
@:Aqu no se debera acceder nunca
}
</span>

O etiquetando el bloque (o una sola lnea) de cdigo con <text>

<span>
@if(true){
<text>La hora es: @DateTime.Now</text>
}
else
{
<text>Aqu no se debera acceder nunca</text>
}
</span>

Comentarios
Se usa la etiquetas @* y *@ con el texto dentro.
@* Una lnea de comentario *@
@*
Ms de una lnea de comentario
Puede tener tantas como se necesiten
*@

Dentro de bloques se cdigo tambin se permite // y /* */

@{
@* Ttulo de la pgina *@

ViewBag.Title = "Index";
}
@{
// Ttulo de la pgina
ViewBag.Title = "Index";
}
@{
/* Ttulo de la pgina
que se visualiza en la parte superior del navegador */
ViewBag.Title = "Index";
}

MODELO
El proceso de traspaso de informacin entre el controlador y la vista se puede
hacer interminable cuando queremos pasar mucha informacin. Para eso se
crea el modelo. Para crear un modelo nos vamos a la carpeta Models, y con el
botn derecho seleccionamos Agregar > Clase

En la siguiente ventana estar seleccionada la plantilla Clase. Le ponemos

como nombre Libro.cs

El cdigo que nos genera:

namespace MVC_3.Models
{
public class Libro
{
}
}

Es importante destacar el namespace porque para acceder a la clase Libro

desde fuera (por ejemplo controlador) deberemos incluir el namespace con
using.
Le aadimos propiedades. No es necesario crear unos privados y luego
los pblicos que hacen referencia a los privados. Se declaran pblicos
y con {get; set; } indicamos si se puede leer su valor (get) o modificar
su valor (set). Lo normal es poner ambos.
public class Libro
{
public string Isbn { get; set; }
public string Titulo { get; set; }
public string TipoLibro { get; set; }
}

Usar un modelo dentro de un controlador / vista

Para llamarlo desde nuestro controlador Demo, deberemos hacer una
llamada al namespace del modelo.
using MVC_3.Models;

A continuacin en el mtodo del controlador creamos un libro y se lo pasamos

a la vista:
public ActionResult Index()
{
var libro = new Libro {Isbn = "1122", Titulo = "El principito",
TipoLibro = "Novela"};
return View(libro);
}

Por ltimo dentro de la vista tenemos que indicar que tipo de datos vamos a
recibir. En la primera lnea aadimos
@model MVC_3.Models.Libro

Y donde lo queramos mostrar Model.Propiedad

El ttulo del libro es <strong>@Model.Titulo</strong>
Quedara:
@{
@model AppDaianaMVC.Models.Libro
ViewBag.Title = "Index";
}
<h2>@ViewBag.Mensage</h2>
El ttulo del libro es <strong>@Model.Titulo</strong>

o la variable se puede declarar afuera del @{..}

@model AppDaianaMVC.Models.Libro
@{
ViewBag.Title = "Index";
}
<h2>@ViewBag.Mensage</h2>
El ttulo del libro es <strong>@Model.Titulo</strong>

El resultado es:

Otro caso que nos encontraremos habitualmente ser el generar un listado de

datos, en nuestro caso de libros. El proceso es muy similar, por una parte el
controlador deber enviar el listado de libros
public ActionResult Index()
{
var libros = new List<Libro>
{
new Libro {Isbn = "1122", Titulo = "El principito", TipoLibro = "Novela"},
new Libro {Isbn = "1122", Titulo = "Steve Jobs", TipoLibro = "Biografa"}
};
return View(libros);
}

Y en la vista debemos indicar el tipo de datos del modelo, en este caso un

listado de libros. Para ello en vez de usar List<MVC_3.Models.Libro> se debe
remplazar por <MVC_3.Models.Libro>
@model IEnumerable<MVC_3.Models.Libro>

Para recorrer los datos con Razor:

Listado de libros
<ul>
@foreach(var libro in Model)
{
<li>@libro.Titulo (@libro.TipoLibro)</li>
}
</ul>

Cuando tengamos que pasar un conjunto de datos a la vista podemos usar dos
tcnica crear un nuevo modelo que recoja todos los que se necesiten enviar (lo
recomendado) o usar el objeto ViewBag:
public ActionResult Index()
{
var libros = new List<Libro>
{
new Libro {Isbn = "1122", Titulo = "El principito", TipoLibro = "Novela"},
new Libro {Isbn = "1122", Titulo = "Steve Jobs", TipoLibro = "Biografa"}

};
ViewBag.Libros = libros;
return View();
}

La diferencia en la vista es que es recomendable especificar el tipo de datos de

la propiedad Libros de ViewBag para que el asistente nos ayude cuando
escribimos:
Listado de libros
<ul>
@foreach(var libro in (IEnumerable<MVC_3.Models.Libro>)ViewBag.Libros)
{
<li>@libro.Titulo (@libro.TipoLibro)</li>
}
</ul>

Partial Views y Child Actions en ASP.NET MVC

Una de las ventajas que nos brinda ASP.NET MVC es la reutilizacin de cdigo en diferentes partes
de nuestro proyecto. Hoy vamos a ver un ejemplo que nos permite utilizar vistas parciales y child
actions para simplificar nuestro cdigo.

Partial Views
Supongamos que estamos creando un sitio de e-commerce y tenemos una entidad llamada Producto
en nuestro modelo.
public class Producto
{
public int Codigo { get; set; }
public string Nombre { get; set; }
public string Descripcion { get; set; }
public decimal Precio { get; set; }
}

Tambin tenemos un controller con una accin que muestra una lista de productos.
public class ProductoController : Controller
{

// GET: Producto
public ActionResult Index()
{
List<Producto> productos
{
new Producto {Codigo
"Producto 1", Precio = 100m},
new Producto {Codigo
"Producto 2", Precio = 200m},
new Producto {Codigo
"Producto 3", Precio = 300m},
new Producto {Codigo
"Producto 4", Precio = 400m}
};
return View(productos);
}
}

= new List<Producto>()
= 1, Descripcion = "Descripcin 1", Nombre =
= 2, Descripcion = "Descripcin 2", Nombre =
= 3, Descripcion = "Descripcin 3", Nombre =
= 4, Descripcion = "Descripcin 4", Nombre =

Y finalmente una vista que muestra los datos.

@model List<Ejemplo.Models.Producto>
@{
ViewBag.Title = "Productos";
}
<h2>Productos</h2>
@foreach (var producto in Model)
{
<div style="background-color:lightblue; text-align: center; padding-bottom:
10px">
Codigo: <span>@producto.Codigo</span>
Name: <span>@producto.Nombre</span>
Description: <span>@producto.Descripcion</span>
Price: <span>@producto.Precio</span>
</div>
}

Al ejecutar nuestro ejemplo podemos ver lo siguiente:

Hasta ac todo perfecto, el problema comienza cuando tenemos que mostrar los productos en otra
vista (por algn motivo) y tenemos que volver a escribir todo el cdigo de la vista que los est
mostrando.
Cuando necesitamos reutilizar fragmentos de Razor y HTML en varios lados, nos conviene usar

Partial Views (o vistas parciales).

Para agregar una vista parcial vamos a la carpeta "Shared" y ponemos "Agregar > Vista".

La parte ms importante es tildar la casilla "Crear como vista parcial".

En esta vista parcial vamos a copiar el cdigo que est dentro del foreach de la vista anterior:
@model Ejemplo.Models.Producto
<div style="background-color:lightblue; text-align: center; padding-bottom:
10px">
Codigo: <span>@Model.Codigo</span>
Name: <span>@Model.Nombre</span>
Description: <span>@Model.Descripcion</span>
Price: <span>@Model.Precio</span>
</div>

Para utilizar esta vista parcial es necesario que en la vista llamemos al helper Html.Partial. Este
mtodo espera que pasemos como primer argumento el nombre de la vista parcial y como segundo
un modelo.
@model List<Ejemplo.Models.Producto>
@{
ViewBag.Title = "Productos";
}
<h2>Productos</h2>
@foreach (var producto in Model)
{
@Html.Partial("DetalleProducto", producto)
}

Si probamos la aplicacin veremos que sigue todo funcionando igual, la diferencia es que ahora
podemos reutilizar esta vista parcial llamndola desde diferentes lugares. Si queremos modificar la
forma de mostrar los productos, slo tendremos que tocar un archivo y se reflejar en todos lados al
mismo tiempo.

Child Actions
Las Child Actions son a las acciones, lo que las Partial Views son a las vistas. En general las Child
Actions se utilizan para renderizar pequeas partes de una pgina, en lugar de una vista entera.
Es posible llamar a una Child Action desde una vista utilizando el helper Html.Action.
Vamos a crear un Child Action dentro de nuestro controller.
[ChildActionOnly]
public ActionResult MostrarProducto(Producto producto)
{
return PartialView("DetalleProducto", producto);
}

Este mtodo va a estar renderizando una vista parcial en lugar de una vista comn, es por eso que el
valor de retorno es PartialView y no View. Adems, se marca a la accin con el atributo
ChildActionOnly. De esta forma nos aseguramos que no pueda accederse a esta accin a travs de
la url.
Ahora tenemos que modificar nuestra vista para que llame a la accin en lugar de la vista parcial.
@model List<Ejemplo.Models.Producto>
@{
ViewBag.Title = "Productos";
}
<h2>Productos</h2>
@foreach (var producto in Model)
{
@Html.Action("MostrarProducto", producto)
}

La aplicacin va a seguir funcionando, con la diferencia que ahora podemos tener mayor
manipulacin de los datos. Por ejemplo, podramos cambiar los valores en la Child Action antes de
renderizarlos.

VALIDACION BSICA
Atributos:

1) Required: indicamos que el campo es obligatorio

[Required]
public string Email { get; set; }

2) StringLenght: indicamos nmero mximo de caracteres

[StringLength(200)]
public string Email { get; set; }

3) RegularExpression: indicamos que debe cumplir determinado criterio

[RegularExpression(@"^[0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@(ua)\.(es)
$")]

public string Email { get; set; }

4) Range: indicamos valor mnimo y mximo

[Range(2, 10)]
public int Asignaturas { get; set; }

PERSONALIZACIN DE MENSAJES
[RegularExpression(@"^[0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@(ua)\.(es)$",
ErrorMessage = "El formato del correo no se corresponde con uno de la Universidad
de Alicante.")]
public string Email { get; set; }

Para mostrar dentro del mensaje alguno de los valores:

[StringLength(200, ErrorMessage = "El nombre no puede ser mayor de {0}
caracteres.")]
public string NombreCompleto { get; set; }

Ya vimos como personalizar las descripciones en diferentes idiomas con los ficheros de recursos.
Para hacerlo con los mensajes de error podemos aplicar la misma tcnica, indicamos en
ErrorMessageResourceType = typeof([carpeta de recursos].[nombre fichero de recursos sin
extension]) y en ErrorMessageResourceName = [Nombre de la clave dentro del fichero de
recursos].
[RegularExpression(@"^[0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@(ua)\.(es)$",
ErrorMessageResourceType = typeof(Resources.Alumno),
ErrorMessageResourceName = "ErrorFormatoCorreoUA")]
[Required(ErrorMessageResourceType = typeof(Resources.Resources),
ErrorMessageResourceName = "PasswordRequired")]
public string Email { get; set; }

Validando el modelo en el controlador

Para validar los valores ingresados en el formulario para operaciones de alta o actualizacin:
if (ModelState.IsValid)
{

Indicar el tipo de dato de los campos

Para indicar el formato del campo se usa el atributo DataType. Los posibles valores son:

DateTime. Muestra la fecha y la hora de un valor de tipo DateTime

Date. Muestra la parte de la fecha de un valor de tipo DateTime
Time. Muestra la parte de la hora de un valor de tipo DateTime
Text. Muestra un campo de texto sencillo
MultilineText. Muestra el campo como un TextArea
Password. Campo para escribir contraseas. Todo lo que escribamos aparecern como
aseriscos.
Url. Muestra el valor como una direccin URL.
EmailAddress. Muestra el valor como una direccin de correo electrnico.
PhoneNumber. Muestra el valor como un nmero de telfono.
Currency. Muestra a cantidad como moneda del pas.
ImageUrl. Muestra el valor como una direccin a una imagen.

La forma de usarlo es como un atributo ms del campo.

[DataType(DataType.Password)]
public string Password { get; set; }

Validacin completa del modelo

En algunos casos no necesitamos realizar la validacin por atributos si no que
debemos aplicarla a nivel de modelo. En este caso, se hace que el propio
modelo herede de IValidatableObject y hay un mtodo Validate que se
encarga de todas las operaciones de validacin:
public class Profesor : IValidatableObject
{
public IEnumerable<ValidationResult> Validate(
ValidationContext validationContext)
{
if (NombreCompleto != null &&
NombreCompleto.Split(' ').Length > 200)
{
yield return new ValidationResult("El nombre del profesor ",
new[] { "NombreCompleto" });
}
}
public string NombreCompleto { get; set; }
}

El mtodo devuelve un conjunto de ValidationResult y yield lo que permite es ir

concatenando returns. Es decir que si hacemos 3 comprobaciones y cada uno hace el return con
yield, al final el mtodo, en caso de que hayan fallado las 3 comprobaciones, devolver un
IEnumerable<ValidationResult> con 3 ValidationResult.

Vistas Parciales
Sirven para crear componentes visuales mediante HTML. Ejemplo:
Creemos un archivo llamado ListadoEnumerable.cshtml en la carpeta: Views/Shared. Sobre la
carpeta hacemos click derecho Add -> View. Ponemos el nombre y damos click en Crear como vista
parcial (Create as partial view).

Nos crear un archivo vaco. Ahora agreguemos este cdigo que bsicamente espera un modelo
IEnumerable de tipo Object y utiliza el mtodo toString() para imprimir la lista en pantalla:
@model IEnumerable<Object>
@if (Model != null)

{
<div class="grid">
<table>
<thead>
<tr>
<th>Nombre</th>
</tr>
</thead>
<tbody>
@foreach (var item in Model)
{
<tr>
<td>@item.ToString()</td>
</tr>
}
</tbody>
</table>
</div>
}

Utilizamos un ciclo ForEach para recorrer el modelo enumerable e imprimimos el ToString.

Ahora mandemos a llamar eso en el index suponiendo que nosotros pasamos un
enumerable como modelo desde el controlador. Solamente debemos agregar al
Views/Home/Index.cshtml:
1@Html.Partial(&amp;quot;ListadoEnumerable&amp;quot;, Model)

Utilizamos el nombre del archivo ListadoEnumerable como primer parmetro y el

modelo como segundo parmetro. Y obtendremos algo as:

Vista Parcial
Para obtener esto debern modificar el mtodo Index del HomeController y tener algo as:
1
2
3

public ActionResult Index()

{
ViewBag.Message = &amp;quot;Modify this template to jump-start your
ASP.NET MVC application.&amp;quot;;

4
5

List&amp;lt;String&amp;gt; listado = new List&amp;lt;String&amp;gt;();

6
7
8

for (int i = 0; i &amp;lt; 10; i++)

listado.Add(&amp;quot;Nombre&amp;quot; + i);

9
10
11

return View(listado);
}

Y agregar el modelo arriba del Views/Home/Index.cshtml:

1@model IEnumerable&amp;lt;Object&amp;gt;

Con esos cambios deberan ver el poder obtener el mismo resultado de la imagen.