Certifications: Skills measured by Exam 70-316

febrero 27, 2013

Skills measured by Exam 70-316 Course 2389B Course 2555
Creating user services
Create a Windows Form by using the Windows Forms Designer.

Add and set properties on a Windows Form.

Create a Windows Form by using visual inheritance.

Build graphical interface elements by using the System.Drawing namespace.

Add controls to a Windows Form.

Set properties on controls.

Load controls dynamically.

Write code to handle control events and add the code to a control.

Instantiate and invoke an ActiveX control.

Configure control licensing.

Create menus and menu items.

Implement navigation for the user interface (UI).

Configure the order of tabs.

Validate user input.

Validate non-Latin user input.

Implement error handling in the UI.

Create and implement custom error messages.

Create and implement custom error handlers.

Raise and handle errors.

Implement online user assistance.

Display and update data.

Transform and filter data.

Bind data to the UI.

Instantiate and invoke a Web service or component.

Instantiate and invoke a Web service.

Instantiate and invoke a COM or COM+ component.

Instantiate and invoke a .NET component.

Call native functions by using platform invoke.

Implement globalization.

Implement localizability for the UI.

Convert existing encodings.

Implement right-to-left and left-to-right mirroring.

Prepare culture-specific formatting.

Create, implement, and handle events.

Implement print capability.

Implement accessibility features.

Creating and managing components and .NET assemblies
Create and modify a .NET assembly.

Create and implement satellite assemblies.

Create resource-only assemblies.

Create a Windows control.

Create a Windows control by using visual inheritance.

Host a Windows control inside Microsoft Internet Explorer.

Consuming and manipulating data
Access and manipulate data from a Microsoft SQL Server database by creating and using ad hoc queries and stored procedures.

Access and manipulate data from a data store. Data stores include relational databases, XML documents, and flat files. Methods include XML techniques and ADO .NET.

Handle data errors.

Testing and debugging
Create a unit test plan.

Implement tracing.

Add trace listeners and trace switches to an application.

Display trace output.

Debug, rework, and resolve defects in code.

Configure the debugging environment.

Create and apply debugging code to components and applications.

Provide multicultural test data to components and applications.

Execute tests.

Resolve errors and rework code.

Deploying a Windows-based application
Plan the deployment of a Windows-based application.

Plan a deployment that uses removable media.

Plan a Web-based deployment.

Plan a network-based deployment.

Ensure that the application conforms to Windows Installer requirements and Windows Logo Program requirements.

Create a setup program that installs an application and allows for the application to be uninstalled.

Register components and assemblies.

Perform an install-time compilation of a Windows-based application.

Deploy a Windows-based application.

Use setup and deployment projects.

Add assemblies to the Global Assembly Cache.

Verify security policies for a deployed application.

Launch a remote application (URL remoting).

Maintaining and supporting a Windows-based application
Optimize the performance of a Windows-based application.

Diagnose and resolve errors and issues.

Configuring and securing a Windows-based application
Configure a Windows-based application.

Configure security for a Windows-based application.

Select and configure authentication type. Authentication types include Windows authentication, none, forms-based, Windows Live ID (formerly Microsoft Passport), and custom authentication.

Specify the security level for an application.

Use custom attributes to configure security.

Configure authorization.

Configure role-based authorization.

Implement identity management.

Pipes en c#

diciembre 11, 2012

Las Pipes son un medio de comunicación entre procesos. Existen dos tipos de Pipes:

Pipes anónimos.

Los Pipes anónimos permiten la comunicación entre procesos en un equipo local. Los Pipes anónimos ofrecen servicios limitados pero requieren menos esfuerzo que los Named Pipes. Los Pipes anónimos son unidireccionales y no se pueden utilizar a través de una red. Sólo admiten una instancia de servidor única. Son útiles para la comunicación entre subprocesos o entre procesos primarios y secundarios

Pipes con nombre (Named Pipes).

Los Named pipes permiten la comunicación entre procesos entre un servidor de canalización y uno o varios clientes de canalización. pueden ser unidireccionales o dúplex. Admiten la comunicación mediante mensajes y permiten que varios clientes se conecten simultáneamente al proceso de servidor utilizando el mismo Named Pipe. También admiten la suplantación, que permite a los procesos que se conectan utilizar sus propios permisos en servidores remotos.

vamos a ver un sencillo ejemplo

using System;
using System.Text;
using System.IO.Pipes;

namespace PipeServer
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Esperando conexión");
            while (true)
            {
                var namedPipeServerStream = new NamedPipeServerStream("MundoNetPipe");
                namedPipeServerStream.WaitForConnection();
                byte[] buffer = new byte[255];
                namedPipeServerStream.Read(buffer, 0, 255);
                string request = ASCIIEncoding.ASCII.GetString(buffer);
                Console.WriteLine(request);
                request=request.Trim('\0');
                if(request.ToLower()=="cerrar")
                    break;
                namedPipeServerStream.Close();
            }
            Console.WriteLine("Fin");
            Console.ReadLine();
        }
    }
}
using System;
using System.Text;
using System.IO.Pipes;

namespace PipeCliente
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                var clienteStream = new NamedPipeClientStream("MundoNetPipe");
                clienteStream.Connect(60);
                Console.WriteLine("Escribe un Mensaje");
                string line = Console.ReadLine();
                if (line.ToLower() == "salir")
                    break;
                byte[] buffer = ASCIIEncoding.ASCII.GetBytes(line);
                clienteStream.Write(buffer, 0, buffer.Length);
                clienteStream.Close();
            }
        }
    }
}

Named Pipes

Son dos aplicaciones de Consola, una para asumir el papel de Servidor y la otra el de Cliente, el Servidor solo espera en un bucle y cuando se establece una conexión con el cliente, el servidor se hace eco de los datos del cliente en la consola

como vemos en la imagen lo que escribimos en consola en la aplicación cliente se escribe en la consola de la aplicación servidor

Además:

Si ingresamos la palabra “salir” se haría un break al bucle while

 if (line.ToLower() == "salir")
 break;

Y el cliente abandonaría el canal de comunicación

clienteStream.Close();

Si se ingresa la palabra “cerrar” el servidor cerraría el canal de comunicación

 if(request.ToLower()=="cerrar")
                    break;
 namedPipeServerStream.Close();

Threading en C#

diciembre 7, 2012

Un hilo de ejecución es la unidad de procesamiento más pequeña que puede ser planificada por un sistema operativo.
La creación de un nuevo hilo es una característica que permite a una aplicación realizar varias tareas a la vez (concurrentemente). Los distintos hilos de ejecución comparten una serie de recursos tales como el espacio de memoria, los archivos abiertos, situación de autenticación, etc. Esta técnica permite simplificar el diseño de una aplicación que debe llevar a cabo distintas funciones simultáneamente.
Un hilo es básicamente una tarea que puede ser ejecutada en paralelo con otra tarea.

using System;
using System.Threading;

namespace Threads
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = new Thread(Write);
            t.Start();
            Console.ReadLine();
        }

        static void Write()
        {
            for (int i = 0; i < 1500; i++)
            {
                Console.WriteLine("x");
            }
        }
    }

}

En el sencillo ejemplo creamos un tread pasandole como parámetro un método que se ejecutara en otro hilo de ejecución.

var t = new Thread(Write);

Iniciamos el mismo:

t.Start();

ahora vamos a ver cómo es esto de dos hilos de ejecución, mientras se ejecuta el método Write en otro hilo, sigue ejecutándose el método Main

using System;
using System.Threading;

namespace Threads
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = new Thread(Write);
            t.Start();
            for (int i = 0; i < 150; i++)
            {
                Console.Write("a");
            }
            Console.WriteLine("Mundo .NET");
            Console.ReadLine();
        }

        static void Write()
        {
            for (int i = 0; i < 150; i++)
            {
                Console.Write("b");
            }
        }
    }

}

el siguiente es el resultado de la ejecución del código anterior:

threads

Ahora vamos a ver un ejemplo del uso del método. JOIN, este método indica que se debe esperar a que termine la ejecución del thread antes de continuar

using System;
using System.Threading;

namespace Threads
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = new Thread(Write);
            t.Start();
            t.Join();
            
            for (int i = 0; i < 150; i++)
            {
                Console.Write("a");
            }

            Console.WriteLine("Mundo .NET");
            Console.ReadLine();
        }

        static void Write()
        {
            for (int i = 0; i < 150; i++)
            {
                Console.Write("b");
            }
        }
    }
}

threads2

Como vemos en la imagen se ejecuta el método Write que escribe en la consola la letra: b y al terminar la ejecución de este continúa recién ahí la ejecución del métod Main con el bucle for que tiene como única línea la que escribe en consola la lerta a

Expresiones de consulta LINQ

octubre 22, 2012

Una expresión de consulta comienza con la palabra clave from luego debemos utilizar una variable de rango.
Una variable de rango representa cada elemento sucesivo de la secuencia de origen mientras esta se recorre
La variable de rango está fuertemente tipada, basada en el tipo de elementos del origen de datos, esto quiere decir que se puede utilizar el operador punto para acceder a cualquier miembro disponible del tipo

veamos un ejemplo

vamos a consultar la Tabla Clientes de la Base Prueba:

Para ello vamos a agregar un modelo Entity Framework

click derecho sobre el proyecto en el explorador de soluciones, seleccionar la opción agregar y luego: nuevo elemento:

Agregar Modelo Entity Framework

Seleccionar la opción Generar desde la base de datos

Generar modelo desde la base de Datos Entity Framework

Click en: Nueva Conexión

Seleccionar la conexión Entity Framework

Ingresar el nombre del servidor, seleccionar la base de datos y hacer click en Aceptar

Entity Framework .net

Presionar Siguiente

Seleccionar la conexión Entity Framework

Seleccionar los objetos de la base de datos que queremos incluir en nuestro modelo

Seleccionar elementos de la base de datos Entity Framework .net

En nuestro caso seleccionamos solo la tabla Clientes:

Entity Framework .net

ahora si podemos hacer nuestras consultas…

  public IEnumerable<Clientes> Listar()
        {
            var contexto = new Contexto();
            var query = from c in contexto.Clientes select c;
            return query;
        }

De esta forma listamos todos los clientes de nuestra entidad Clientes,como vemos se usa la variable de rango “c” y como se dijo antes, esta variable está fuertemente tipada, entonces vamos a utilizar el operador punto “.” para acceder a sus atributos

 public IEnumerable<Clientes> Buscar(string apellido)
        {
            var contexto = new Contexto();
            var query = from c in contexto.Clientes 
                        where c.Apellido==apellido select c;
            return query;
        }

De esta forma obtenemos los clientes cuyos apellidos coincidan con el apellido recibido por parámetro.
Ahora vamos a ver algunas cosas interesantes que podemos hacer…

Por ejemplo de esta forma obtenemos los clientes cuyos Apellidos contengan el valor recibido en el parámetro apellido

var query = from c in contexto.Clientes where c.Apellido.Contains(apellido) select c;

para nuestra tabla:

Consulta linq

si pasamos como parámetro “Marchetti” devolverá el cliente

Consulta Linq

Los clientes con apellidos que comiencen con el valor de parámetro apellido:

 var query = from c in contexto.Clientes where c.Apellido.StartsWith(apellido) select c;

Además podemos personalizar nuestras consultas como nos parezca:

 public IEnumerable Buscar(string apellido)
        {
            var contexto = new Contexto();
            var query = from c in contexto.Clientes 
                        where c.Apellido==apellido 
                        select new
                            {
                                Datos=c.Apellido+", "+c.Nombre
                            };
            return query;
        }

Helpers MVC 3

octubre 19, 2012

Creamos un nuevo proyecto de aplicación web asp.net MVC 3 y lo nombramos Prueba_Helpers

creamos una carpeta llamada Entidades dentro de la carpeta Models
en esta carpeta agregamos una clase y le ponemos el nombre: Usuarios.cs

namespace Prueba_Helpers.Models.Entidades
{
    public class Usuarios
    {
        public string Apellido { get; set; }
        public string Nombre { get; set; }
        public int Edad { get; set; }
    }
}

en la carpeta Models agregamos una clase y la nombramos GestionUsuarios.cs

using System.Collections.Generic;
using Prueba_Helpers.Models.Entidades;

namespace Prueba_Helpers.Models
{
    public class GestionUsuarios
    {
        public List<Usuarios> Listar()
        {
            var usuario1 = new Usuarios { Apellido = "Marchetti", Nombre = "Javier", Edad = 29 };
            var usuario2 = new Usuarios { Apellido = "Perez", Nombre = "Juan", Edad = 12 };
            var usuario3 = new Usuarios { Apellido = "Lopez", Nombre = "Diego", Edad = 50 };

            var lista = new List<Usuarios> { usuario1, usuario2, usuario3 };

            return lista;
        }
    }
}

Modelo - Modelo Vista Controlador MVC 3

En nuestra carpeta Controllers agregamos un nuevo controlador: UsuariosController.cs

Controlador - MVC 3

using System.Web.Mvc;
using Prueba_Helpers.Models;

namespace Prueba_Helpers.Controllers
{    
    public class UsuariosController : Controller
    {
        public ActionResult Listar()
        {
            var gestionUsuarios = new GestionUsuarios();
            var listaUsuarios=gestionUsuarios.Listar();
            return View(listaUsuarios);
        }
    }
}

y agregamos la vista que devolverá el Action: “Listar”

Vista - Modelo Vista Controlador MVC 3

Ahora llegó el momento de los Helpers

la sintaxis es la siguiente:

@helper IdentificadorHelper(parametros) { ... }

estos encapsulan bloques de código html y de servidor reutilizables

podemos crear helpers en una vista o algo más interesante, para poder usarlos en todas las vistas de nuestras aplicación…

Vamos a crear una carpeta llamada App_Code, dentro de esta agredamos un archivo con el nombre: HelperFile y en este agregamos nuestro helper:

@helper MostrarEdad(int edad)
    {
        if (edad > 21)
        {
    <span>Mayor </span>
        }
        else
        {
    <span>Menor </span>
        }
}

ahora en nuestra vista:

@using Prueba_Helpers.Models.Entidades
@model List<Usuarios>
@foreach (var usuario in Model)
{
    <span>
        @usuario.Apellido
    </span>    
    <span>
        @usuario.Nombre
    </span>
    @HelperFile.MostrarEdad(usuario.Edad)
    <br />
}

como vemos usamos nuestro helper haciendo referencia a HelperFile que es el archivo donde está el mismo y le pasamos como parámetro la edad

@HelperFile.MostrarEdad(usuario.Edad)

EditorForModel

octubre 17, 2012

este interesante “Helper” devuelve un elemento input HTML para cada propiedad del modelo

@Html.EditorForModel()

creamos un nuevo proyecto de aplicación web de ASP.NET MVC 3 y lo nombramos: Ejemplo_EditorForModel

Creamos una nueva clase en la carpeta Models (haciendo click derecho sobre la misma y seleccionando agregar y luego clase) nombramos a esta: Clientes

Agregamos a esta tres propiedades:
Apellido, Nombre, Tel

namespace Ejemplo_EditorForModel.Models
{
    public class Clientes
    {
        public string Apellido { get; set; }
        public string Nombre { get; set; }
        public string Tel { get; set; }
    }
}

Agregamos un controlador a nuestra carpeta Controllers

Agregamos un Action a nuestro controlador llamado Editar

using System.Web.Mvc;

namespace Ejemplo_EditorForModel.Controllers
{
    public class ClientesController : Controller
    {
        public ActionResult Editar()
        {
            return View();
        }
    }
}

Hacemos click derecho sobre View y seleccionamos la opción Agregar Vista

@model Ejemplo_EditorForModel.Models.Clientes
           
@{
    ViewBag.Title = "Editar";
}

<h2>Editar</h2>

@Html.EditorForModel()

Ejecutamos nuestra aplicación y vemos cómo se genera un Input con su correspondiente etiqueta por cada una de las propiedades del modelo

$.Load()

octubre 15, 2012

Realiza una request al servidor y carga el html devuelto en el elemento que se indique:


$.load
( url,
[data],
[complete(responsEnlaceeText, textStatus,XMLHttpRequest)]
)

url: Cadena de caracteres que contiene la URL del archivo que se envía.

data: Cadena de caracteres que contiene la respuesta del servidor.

complete: (responseText, textStatus, XMLHttpRequest) Funcion que se ejecuta cuando la solicitud se completó.

Ejemplo:

$("#divContenedor").load("pagina2.html");

vamos a demostrar como funciona en una pequeña aplicación con MVC

Click derecho en la carpeta Models
Seleccionar la opción Agregar
Seleccionar Clase
cambiar el nombre por Usuarios.cs

namespace Prueba_MVC3.Models
{
    public class Usuarios
    {
        public string Apellido { get; set; }

        public string Nombre { get; set; }
    }
}

Agregar un nuevo controlador en la carpeta: Controllers. Llamamos a este: UserController

Agregamos en nuestro controlador el siguiente Action:

   public ActionResult ListarUsuarios()
        {
            var usuario1 = new Usuarios { Apellido = "Marchetti", Nombre = "Javier" };
            var usuario2 = new Usuarios { Apellido = "Perez", Nombre = "Juan" };
            var usuario3 = new Usuarios { Apellido = "Diehl", Nombre = "Russell" };

            var listaUsuarios = new List<Usuarios> { usuario1, usuario2, usuario3 };
           
            return PartialView();
        }

Agregar una vista parcial, haciendo click derecho sobre PartialView y seleccionando la opción agregar vista, como muestra la imagen siguiente:

Chequear la opción Crear como vista parcial

cambiar el nombre de la vista por: ListarUsuarios y presionar Agregar

pasar como parámetros al método PartialView:

El nombre de la vista parcial: “ListarUsuarios”
y la lista: listaUsuarios

el action quedaría de la siguiente manera:

     public ActionResult ListarUsuarios()
        {
            var usuario1 = new Usuarios { Apellido = "Marchetti", Nombre = "Javier" };
            var usuario2 = new Usuarios { Apellido = "Perez", Nombre = "Juan" };
            var usuario3 = new Usuarios { Apellido = "Diehl", Nombre = "Russell" };

            var listaUsuarios = new List<Usuarios> { usuario1, usuario2, usuario3 };
           
            return PartialView("ListarUsuarios",listaUsuarios);
        }

el controlador completo:

using System.Web.Mvc;
using Prueba_MVC3.Models;
using System.Collections.Generic;

namespace Prueba_MVC3.Controllers
{
    public class UserController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }
        
        public ActionResult ListarUsuarios()
        {
            var usuario1 = new Usuarios
                {
                    Apellido = "Marchetti", Nombre = "Javier"
                };
            var usuario2 = new Usuarios
                {
                    Apellido = "Perez", Nombre = "Juan"
                };
            var usuario3 = new Usuarios
                {
                    Apellido = "Diehl", Nombre = "Russell"
                };

             var listaUsuarios = new List<Usuarios>
                {
                    usuario1, usuario2, usuario3
                };
           
            return PartialView("ListarUsuarios",listaUsuarios);
        }
    }

modificar la vista parcial de la siguiente manera:

@using System.Collections
@model IEnumerable<Prueba_MVC3.Models.Usuarios>
@foreach (var usuario in Model)
{
    <div>
        <p>@usuario.Apellido</p>
        <p>@usuario.Nombre</p>        
    </div>       
}

en la vista: Index agregar un enlace:

<a id="Listar" href="#" onclick="Listar()">Listar</a>

un div llamado: “divContenedor”

<div id="divContenedor"></div>

y en la sección de scripts la función Listar:

<script type="text/javascript">
    function Listar() {
        $("#divContenedor").load("../User/ListarUsuarios");
    }
</script>

quedaría de la siguiente manera:

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

<a id="Listar" href="#" onclick="Listar()">Listar</a>
<br/>
<div id="divContenedor"></div>

<script type="text/javascript">
    function Listar() {
        $("#divContenedor").load("../User/ListarUsuarios");
    }
</script>

en esta función es donde usaremos nuestro $.Load()

$("#divContenedor").load("../User/ListarUsuarios");

esta cargará el contenido html de la respuesta del servidor a la petición (que es controlada por el Action: ListarUsuarios del Controlador: User) en el divContenedor

vamos a probar…

Ejecutamos nuestra aplicación (F5)

en la barra de direcciones colocamos la url correspondiente: http://localhost:xxxx/User/Index


presionamos sobre nuestro enlace Listar

$.ajax()

octubre 10, 2012
$.ajax({
    url: 'Usuarios/Guardar',
    data: {
        nombre: 'Javier',
        apellido: 'Marchetti'
    },
    type: 'POST',
    dataType: 'json',
    success: function(datos){
        $('#respuesta').text(datos.respuesta).fadeIn('slow');
    }
});

url: La URL a la que vamos a hacer la petición.

data: Los datos que vamos a enviar. Puede ser una cadena, o un objeto JavaScript cuyas propiedades son las que se van a recibir en la petición. Un ejemplo de esta segunda forma:

type: Tipo de petición que se realiza. Puede ser POST o GET. POST si vamos a modificar datos en nuestra aplicación y GET en caso de que estemos solicitando datos a la aplicación.

dataType: Este es el tipo de datos que la función espera de vuelta. En nuestro caso esperamos json aunque podríamos usar xml, html o script por ejemplo.

success: Aquí es donde ponemos en práctica la parte asíncrona de la petición. En success incluímos una función que será ejecutada cuando la petición sea completada y esta tenga éxito. En la función únicamente mostramos el json que nos devuelve el servidor

tenemos en nuestra vista dos textBoxes (apellido y nombre) con sus respectivas etiquetas, un link (Guardar) que tiene asociada al evento click la función GuardarUsuario:

Al hacer click sobre Guardar se invoca entonces a la función GuardarUsuario, esta realiza la petición asíncrona al servidor

@{
    ViewBag.Title = "Usuarios";
}

@Html.Label("Apellido:")
@Html.TextBox("apellido")
<br/>
@Html.Label("Nombre:")
@Html.TextBox("nombre") 
<br/>
<a id="Guardar" href="#" onclick="GuardarUsuario()">Guardar</a> 
<br/>
<div id="respuesta"></div>
<script type="text/javascript">
    function GuardarUsuario() {
        var txt_Apellido = $("#apellido").val();
        var txt_Nombre = $("#nombre").val();
        $.ajax({
            url: '../User/Guardar',
            data: {
                nombre: txt_Apellido, 
                apellido: txt_Nombre
            },
            type: 'POST',
            dataType: 'json',
            success: function (datos) {
            $('#respuesta').text(datos.Respuesta).fadeIn('slow');
            }
        });        
    }
</script>

se realiza la petición al action Guardar del Controlador User:

 url: '../User/Guardar',

Se recuperan los valores de los textBoxes:

 var txt_Apellido = $("#apellido").val();
 var txt_Nombre = $("#nombre").val();

y se pasan como parámetros

  data: { nombre: txt_Apellido, apellido: txt_Nombre },

al recibir la respuesta del servidor, se ejecuta la función asociada al success

 success: function (datos) {
  $('#respuesta').text(datos.Respuesta).fadeIn('slow');
  }

Ahora veamos el controlador:

using System.Web.Mvc;

namespace Prueba_MVC3.Controllers
{
    public class UserController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }
        public ActionResult Guardar(string apellido, string nombre)
        {
            var usuario = new Usuarios
                {
                    Apellido = apellido,
                    Nombre = nombre
                };

            var gestionUsuarios = new GestionUsuarios();
            gestionUsuarios.Guardar(usuario);

            return Json(new Mensaje
                {
                    Respuesta = "El usuario fue dado de alta"
                },
                JsonRequestBehavior.AllowGet);
        }
    }

    class Mensaje
    {
        public string Respuesta { get; set; }
    }

    class Usuarios
    {
        public string Apellido { get; set; }

        public string Nombre { get; set; }
    }
}

hagamos un pequeño análisis del código anterior:
el Action recibe como parámetros: el apellido y el nombre

public ActionResult Guardar(string apellido, string nombre)

Se instancia la clase Usuarios y se asignan los valores de estos parámetros a los atributos de esta:

var usuario = new Usuarios
                {
                    Apellido = apellido,
                    Nombre = nombre
                };

Se intancia la clase GestionUsuarios y se invoca al método:Guardar

 var gestionUsuarios = new GestionUsuarios();
            gestionUsuarios.Guardar(usuario);

y por último se retorna el Json con el mensaje correspondiente:

return Json(new Mensaje
                {
                    Respuesta = "El usuario fue dado de alta"
                },
                JsonRequestBehavior.AllowGet);

Pasar dos objetos a una vista

septiembre 27, 2012

Para pasar dos objetos a una vista vamos a utilizar el ViewModel que utilizamos para el ejemplo del post anterior

using MVC_EntityFramework.Models;
namespace MVC_EntityFramework.ViewModels
{  
    public class FormViewModel
    {
        public Clientes Cliente { get; set; }
        public Productos Producto { get; set; }
    }
}

Agregamos a nuestro controller Home el action TestFormView

En este instanciamos la clase Clientes

namespace MVC_EntityFramework.Models
{
    public class Clientes
    {
        public string Apellido { get; set; }
        public string Nombre { get; set; }
    }
}

y la clase Productos

namespace MVC_EntityFramework.Models
{
    public class Productos
    {
        public string Codigo { get; set; }
        public string Nombre { get; set; }
        public decimal Precio { get; set; }
    }
}

que se encuentran en el Modelo:

Modelo - MVC

Se asignan los valores a los Atributos Cliente y Producto de formViewModel

 public ActionResult TestFormView()
        {
            var formViewModel = new FormViewModel();
            var cliente = new Clientes { Apellido = "Marchetti", Nombre = "Javier" };
            var producto = new Productos { Codigo = "01", Nombre = "computadora", Precio = 5000 };

            formViewModel.Cliente = cliente;
            formViewModel.Producto = producto;

            return View(formViewModel);
        }

hacemos doble click sobre View y Agregamos una nueva vista

checamos la opción Crear vista fuertemente tipada y seleccionamos nustro FormViewModel como clase de modelo

presionamos Agregar

observemos nuestra vista:

 @model MVC_EntityFramework.ViewModels.FormViewModel

esta línea nos indica que el controller ahora tiene que enviar como parametro un objeto del tipo FormViewModel

 return View(formViewModel);

En nuestra vista para acceder a esos datos hacemos uso de @Model como vemos en el siguiente código:

@model MVC_EntityFramework.ViewModels.FormViewModel

<h3>Cliente:</h3>
Apellido: @Model.Cliente.Apellido
<br/>
Nombre: @Model.Cliente.Nombre
<br/>
<h3>Producto</h3>
Código: @Model.Producto.Codigo
<br/>
Nombre: @Model.Producto.Nombre
<br/>
Precio: @Model.Producto.Precio

Ejecutamos e ingresamos la url:
http://localhost:xxxx/Home/TestFormView o agregamos el siguiente enlace en la vista index:

<a href="../Home/TestFormView">TestFormView</a>

El resultado es el siguiente:

MVC 3 en español

septiembre 27, 2012

Continuando con nuestro Post Anterior

Muchas veces es necesario mostrar datos de uno o más objetos. Aquí es donde el ViewModel entra en juego. Un ViewModel es simplemente una clase que contiene todos los datos que se necesitan para una vista.

para mostrar como funciona esto, vamos a Agregar una nueva carpeta llamada ViewModels

Nueva Carpeta Visual Studio

dentro de esta carpeta agregamos una nueva clase: FormViewModel

 public class FormViewModel
    {
        public string Apellido { get; set; }
        public string Nombre { get; set; }
    }

en nuestro Controller hacemos uso del espacio de nombres

using MVC_EntityFramework.ViewModels;

en el action Guardar:

 public ActionResult Guardar(FormCollection form)
        {
            var apellido = form["txtApellido"];
            var nombre = form["txtNombre"];

            var formViewModel = new FormViewModel();
            formViewModel.Apellido = apellido;
            formViewModel.Nombre = nombre;

            return View(formViewModel);
        }

o…

  public ActionResult Guardar(FormCollection form)
        {
            return View(new FormViewModel { Apellido = form["txtApellido"], Nombre = form["txtNombre"] });
        }

que es lo mismo

recordemos que este controlaba las request de:

<form action=@Url.Action("Guardar", "Home")>
Apellido: @Html.TextBox("txtApellido")
Nombre: @Html.TextBox("txtNombre")
<input type="submit" value="Guardar"/>
</form>

En la vista “Guardar.cshtml”:

@model MVC_EntityFramework.ViewModels.FormViewModel

Apellido: @Model.Apellido
Nombre: @Model.Nombre

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.