viernes, 26 de julio de 2013

Jquery y JSON , combo cascada.

Introducción :

Muchas veces en los sistemas de información , se requiere cargar información a partir de un parámetro para otros controles ,y normal es que puedas hacerlo cargando cada control con un autopostback o un refresh de página , esto puede ser algo molesto ya que para cada cambio se tendrá que refrescar la página y esto puede ocasionar alguna perdida de datos sin mencionar que para un sistema profesional no es para nada óptimo hacer el llenado de datos via autopostback, este trabajo puede ser tedioso si buscas la manera de como hacerlo en entorno MVC ya que aqui no existe alguna propiedad para realizar el autopostback en controles html.

Hoy veremos como realizar un combo cascada por medio de Jquery y Json , los cuales nos ayudarán a realizar dicha tarea.

Que es JSON ?

Json es un formato simple y ligero para poder intercambiar información ya que podemos cargar información desde el servidor mediante peticiones a determinadas URLs.
En este caso utilizaremos la función get.Json de la libreria Jquery, la cual trabaja con la misma sintaxis.
Podemos ver mas información acerca de esto en la documentación de Json  en JSON

A continuación realizaremos un ejemplo sencillo haciendo un listado de categorías en un select y al escoger se liste otro select con los productos que pertenecen a esa categoría.

1. Realizamos la conexión a la base de datos Neptuno mediante el Entity Framework y usaremos procedimientos almacenados agregados al EF, los cuales son los siguientes.
CREATE PROCEDURE ListarCategorias
AS
SELECT IdCategoria,NombreCategoria FROM Categorias
GO

CREATE PROCEDURE ListarProductosXCategoria 
@IdCategoria INT
AS
SELECT IdProducto,NombreProducto FROM Productos
WHERE IdCategoria=@IdCategoria
GO

2. Como mencione anteriormente las acciones pueden devolver varias tipos de resultado , en este caso para usar Json , retornaremos un resultado en formato Json , por tanto hacemos lo siguiente.
public class Categorias_ProductosController : Controller
    {
        NeptunoEntities db = new NeptunoEntities();

        public ActionResult ListarCategorias()
        {
            var Listado = db.ListarCategorias().ToList();
            ViewBag.Categorias = Listado;
            return View();
        }

        public JsonResult ListarProductosXCategoria(int IdCategoria)
        {
            var Listado = db.ListarProductosXCategoria(IdCategoria);
            var JsonListado = Json(Listado.ToList(), JsonRequestBehavior.AllowGet);
            return JsonListado;
        
        }
       
    }
Aqui uso directamente los procedimientos almacenados hechos en SQL e importados al EF,tan solo llamandolos desde la variables instanciada, esta variable me guardara todas las entidades del EF , y podre llamarlas en cualquier controlador y por tanto acción.

Como dije al comienzo estamos usando ahora un JSON RESULT , pero que es lo que hago exactamente aquí ?

Para resumir , explico la sintaxis de Json, la cual es la siguiente :

Json (object Data , JsonRequestBehavior Behavior)

Json --> Creará un objeto en formato Json
object data --> son los datos que queremos serializar.
JsonRequestBehavior --> Clase que indica si este Json va aceptar o no peticiones Http.
Behavior --> Respuesta si aceptaremos o no las peticiones http, estas puedes ser 2 , "AllowGet" la cual hace referencia que si aceptará peticiones y "DenyGet" que indica que no aceptará peticiones http.

Sabiendo esto, podemos realizar la llamada desde Jquery en la vista.

3. Creamos los "select" en la vista , en primer select lo llenamos con un foreach como ya l hemos realizado antes.
@using Combo_Cascada.Models;

ListarCategorias

Categorias
Productos
y usando jquery hacemos la llamada a JsonResult.

como se daran cuenta usamos get.JSON cuya sintaxis es la siguiente :

get.JSON (URL)

Sabemos de por si , que los controladores y acciones vienen a ser url , ya que si lo notas cuando ejecutas un controlador en la barra de direcciones aparece su ruta, por tanto definimos el controlador y accion que corresponde en este caso ("ListarProductosXCategoria", "Categorias_Productos") y enviandole el parámetro IdCategoria el cual capturamos por medio del selector del select categorias (id), y realizando un foreach con el resultado y le agregamos los items al segundo select.
Sabemos que en (data) , se guarda el resultado de la petición.

Por último  mediante el selector del select Categorias (id) y la funcion change cargamos el método  que llena el segundo select , asi que cada vez que seleccionemos un item cambiará el contenido del segundo select.

Espero que este post te haya sido de utilidad, aquí dejo la solución por si deseas descargarla.

domingo, 21 de julio de 2013

Vista Parcial (PartialView)

Introducción:
Siempre que realizamos una consulta y queremos ver datos específicos , enviamos parámetros para que nuestra consulta sea mas precisa, y se estarán preguntando como se podría hacer eso en MVC , para eso usaremos las vistas parciales o PartialView que nos ayudarán dinámicamente a mostrar datos según parámetros.
Como ejemplo usaremos una consulta de detalles de pedidos que recibirá como parámetro el id de pedido de la bd Neptuno.

Que es un PartialView?
Un PartialView es una vista que podemos renderizar en otra vista , esta otra vista se le llama comúnmente como Vista padre, asi que por lógica una vista padre puede tener varias Vistas parciales. La vista principal es la que mandará los datos de parámetros para que las vistas parciales muestren resultados segun esos parámetros, estas pueden actualizarse mas no la vista principal, en resumen los PartialView dependen de una vista principal o vista padre para mostrar sus resultados.
Si quieres saber mas acerca de esto puede revisar. Partial View C#

1. Creamos los modelos, uno para llenar un Select con los id de pedidos y otro que recibirá los datos que se mostrarán.
  
public class PedidosModels
    {
        public int IdPedido { get; set; }
    }

    public class DetallePedidosModels
    {
        public int IdPedido { get; set; }
        public string NombreProducto { get; set; }
        public decimal PrecioUnidad { get; set; }
        public int Cantidad { get; set; }
        public decimal Total { get; set; }

    }
2. Ahora en el controlador , realizamos las consultas correspondientes para la vista principal y el partial view.
public class DetallePedidosController : Controller
    {
        NeptunoEntities db = new NeptunoEntities();

        public ActionResult Pedido()
        {
            var Pedidos = from p in db.Pedidos
                          where p.IdPedido < 10260
                          select new PedidosModels
                          {
                              IdPedido = p.IdPedido
                          };
            var ListadoPedidos = Pedidos.Distinct().ToList();
            ViewBag.ListadoPedidos = ListadoPedidos;
            return View();
        }

        public ActionResult DetallePedido(int IdPedido)
        {
            var DetallePedido = from p in db.Pedidos
                                join dp in db.Detalles_de_pedidos on p.IdPedido equals dp.IdPedido
                                join pr in db.Productos on dp.IdProducto equals pr.IdProducto
                                where p.IdPedido == IdPedido
                                select new DetallePedidosModels
                                {
                                    IdPedido = p.IdPedido,
                                    NombreProducto = pr.NombreProducto,
                                    PrecioUnidad = dp.PrecioUnidad,
                                    Cantidad = dp.Cantidad,
                                    Total = (dp.PrecioUnidad * dp.Cantidad)
                                };
            var ListadoDetalle = DetallePedido.ToList();
            ViewBag.ListadoDetalle = ListadoDetalle;
            return PartialView(ViewBag.ListadoDetalle);
        }

    }
Si se dan cuenta , la action "DetallePedido" , ahora debe recibir un parámetro el cual es "IdPedido" , asi que mediante ese parametro mostrará los datos , si se fijan en el "where" , veran que alli le mando la condición y también como retorno ya no mando "View" , ahora es "PartialView". 3. Crear una Vista Parcial de una acción. Para crear una vista parcial , encima del nombre de la acción, damos click derecho y seleccionamos "Agregar Vista".


Luego debemos de habilitar el check de "Crear como Vista Partial".


3. Construyendo la vista parcial. Si se dan cuenta una vista parcial no es muy distinta que una vista principal, pero tiene una gran diferencia , la cual es que la vista principal tiene referencia el Layout y una vista parcial no lo tiene. El Layout guarda los un diseño maestro para mostrarlos en todas las vistas padres, es el equivalente a Master Page en asp.net.
@using Aplicacion_PartialView.Models;
<table>
<thead>
    <tr>
        <th>IdPedido</th>
        <th>NombreProducto</th>
        <th>PrecioUnidad</th>
        <th>Cantidad</th>
        <th>Total</th>
    </tr>
</thead>

<tbody>
@foreach (var d in ViewBag.ListadoDetalle as List<DetallePedidosModels>)
{
    <tr>
        <td>@d.IdPedido</td>
        <td>@d.NombreProducto</td>
        <td>@d.PrecioUnidad</td>
        <td>@d.Cantidad</td>
        <td>@d.Total</td>
    </tr>

}
</tbody>
</table>

4. Construyendo la Vista Principal , llenamos el select con los IdPedidos mediante un foreach , y ponemos un boton al lado para llamar al PartialView con el IdPedido seleccionado.
@using Aplicacion_PartialView.Models;

<label>Pedidos</label>
<select id="IdPedidos">
@foreach (var p in ViewBag.ListadoPedidos as List<PedidosModels>)
{ 
<option value="@p.IdPedido">@p.IdPedido</option>
}
</select>
<input id="BuscarDetalle" type="button" value="Buscar"/>

@*Este Div contendra el resultado del PartialView.*@
<div id="DetallePedido">

</div>

En el DIV con id "DetallePedido" renderizaremos el partialView , usando JQUERY y utilizaremos como selector el Id del boton de la siguiente manera.
<script type="text/javascript">

    $("#BuscarDetalle").click(function () {
        $("#DetallePedido").load('@Url.Action("DetallePedido","DetallePedidos")', {IdPedido:$('#IdPedidos').val()})
    });

</script>

Usando la funcion "load" , renderizo el resultado dentro del DIV. Si lo notan ,ahora envio un parametro a la accion , "{IdPedido:$('#IdPedidos').val()}", capturando el valor del select mediante su selector.
Resumiendo , cada vez que presione el boton , llamará al PartialView segun el parametro seleccionado en el Select.

Aquí dejo la solución , por si deseas descargarlo.

viernes, 19 de julio de 2013

Asignación de Datos a Entidades con Sintaxis Linq

Introducción :
Siempre que usamos un Entity Framework , si queremos podemos usar o no Linq , aunque generalmente cuando trabajas con este tipo de conexión de datos es optimo usar linq ya que puedes ejecutar las consultas a través del code behind con mayor flexibilidad.
En este post , veremos como realizar una consulta con linq y asignarle valores a las Entidades que usaremos para mostrar nuestra data en los View.

Que es Linq ? 

Lenguaje integrado de consultas, es un componente de .NET , y nos permite realizar consultas en los lenguajes de .NET , en este caso C# con la sintaxis de consultas de sql.
Pueden ver mas información de la Microsoft Microsoft - Sintaxis LINQ

1. Creamos nuestro Entity Framework (para crear un EF puede ver Entity Framework).

2. Creamos el modelo o Entity model , en este caso creare uno para productos.
public class ProductoModel
    {
        public int IdProducto { get; set; }
        public string NombreProducto { get; set; }
        public string NombreProveedor { get; set; }
        public string NombreCategoria { get; set; }
        public string CantidadPorUnidad { get; set; }
        public decimal? PrecioUnidad { get; set; }
    }

3. Luego en el controlador realizamos la consulta con LINQ, tal y como lo harias en SQL.
public class ProductosController : Controller
    {
        NeptunoEntities db = new NeptunoEntities();

        public ActionResult ListaProductos()
        {
            var Listado = from p in db.Productos
                          join pr in db.Proveedores on p.IdProveedor equals pr.IdProveedor
                          join c in db.Categorias on p.IdCategoria equals c.IdCategoria
            return View();
        }

    }


Si te das cuenta , esto es lo mismo que una consulta en SQL.
select 
p.IdProducto,
p.NombreProducto,
pro.NombreCompañia as Proveedor,
c.NombreCategoria,
p.CantidadPorUnidad,
p.PrecioUnidad
from productos p
inner join Proveedores pro on p.IdProveedor= pro.IdProveedor
inner join Categorias c on p.IdCategoria = c.IdCategoria

4.Asignamos los valores a las propiedades del Modelo de la siguiente manera.
public ActionResult ListaProductos()
        {
            var Listado = from p in db.Productos
                          join pr in db.Proveedores on p.IdProveedor equals pr.IdProveedor
                          join c in db.Categorias on p.IdCategoria equals c.IdCategoria
                          select new ProductoModel
                          {
                              IdProducto = p.IdProducto,
                              NombreProducto = p.NombreProducto,
                              NombreProveedor = pr.NombreCompañia,
                              NombreCategoria = c.NombreCategoria,
                              CantidadPorUnidad = p.CantidadPorUnidad,
                              PrecioUnidad = p.PrecioUnidad
                          };
            var Productos = Listado.ToList();
            ViewBag.ListadoProductos = Productos;
            return View(Productos);
        }


Si te das cuenta aqui le asigno mas directamente los valores a las propiedades del modelo ya que el Entity Framework me creo automaticamente las Entidades.

5.Finalmente retornamos los datos a la vista correspondiente.
@{ViewBag.Title = "ListaProductos";}
@using Linq_Entidades.Models;

<h2>ListaProductos</h2>

<table>
<thead>
    <tr>
        <th>IdProducto</th>
        <th>NombreProducto</th>
        <th>Proveedor</th>
        <th>NombreCategoria</th>
        <th>CantidadPorUnidad</th>
        <th>PrecioUnidad</th>
    </tr>
</thead>

<tbody>
@foreach (var p in ViewBag.ListadoProductos as List<ProductoModel>)
    {
    <tr>
        <td>@p.IdProducto</td>
        <td>@p.NombreProducto</td>
        <td>@p.NombreProveedor</td>
        <td>@p.NombreCategoria</td>
        <td>@p.CantidadPorUnidad</td>
        <td>@p.PrecioUnidad</td>
    </tr>
    }
</tbody>
</table>

Espero te haya servido este post, si deseas puedes descargar la solución .


jueves, 18 de julio de 2013

Razor y MVC 4 .NET

Introducción :

Se sabe que generalmente para cada acción perteneciente a un controlador , se debe generar una vista . Digo no siempre ya que , no todas las acciones devuelven un resultado físico , sino también pueden devolver uno lógico como por ejemplo , que te devuelva una acción de un INSERT , UPDATE o DELETE, y el tipo de resultados pueden variar , tales como ActionResult , JsonResult , JavaScriptResult u otros.
En esta ocasión veremos como pasar resultados de un controlador a una vista, en si esto es continuación del post anteriormente realizado Acceso a Datos y Entidades.

Antes que nada , explicaré brevemente que es Razor.

Razor , es un motor de vistas que nos permite programar un codigo flexible en html, ya sea C# o VB , resumiendo en palabras entendibles , puedes programar el code behind en html , iniciando cada bloque de codigo con el caracter @.

Puede ver mas acerca de esto donde la Microsoft explica mejor su sintaxis. Sintaxis Razor .NET

1. Para crear la vista de una acción , debemos dar click derecho encima del nombre del mismo y seleccionamos "Agregar Vista".


el cual nos creará la vista , pero primero creando su carpeta respectiva.


2. Para pasar los datos de un controlador a una vista , podemos guardar el resultado en un "diccionario de datos", tales como un ViewBag o ViewData , en los cuales puedes asignarles un grupo de datos para poder recuperarlos en la vista que le corresponde a la acción, tal y como lo hice en el anterior post.
public class ClienteController : Controller
    {
        Models.AccesoDatos db = new AccesoDatos();

        public ActionResult Clientes()
        {
             var Clientes = db.ListarClientes();

             var lista = new List<ClienteModel>();

             foreach (DataRow r in Clientes.Rows)
             {
                 lista.Add(new ClienteModel(r.ItemArray));
             }

            var ListaClientes = lista.ToList();

            ViewBag.ListaClientes = ListaClientes;
            
            return View();
        }

    }

3.Construyendo la vista por medio del "ViewBag".
@{
    ViewBag.Title = "Clientes";
}

<h2>Clientes</h2>
<table>
    <thead>
        <tr>
            <th>IdCliente</th>
            <th>Cliente</th>
            <th>Direccion</th>
            <th>Pais</th>
         </tr>
    </thead>
    <tbody>
    @foreach (var c in ViewBag.ListaClientes as List<MvcApplication1.Models.ClienteModel>)
    {
        <tr>
            <td>@c.IdCliente</td>
            <td>@c.NombreCompañia</td>
            <td>@c.Direccion</td>
            <td>@c.Pais</td>
        </tr>
    }
    </tbody>
</table>

Que hago aqui ?

1.Las vistas reconocen los ViewBag o ViewDatas , provenientes de mi accion correspondiente, por eso es que llamo directamente a mi ViewBag en la vista.
2.Mediante "Razor" , abro un bloque de codigo con el caracter @, veran que puedo ingresar codigo C#.
3. Por medio de un for each haciendo referencia a una variable e indicandole que es una Entidad , en este caso ClienteModel , puedo acceder a las propieades del model y pasar a llenar mi tabla con los datos.

Espero les sirva este pequeño instructivo.
Aqui dejo un enlace donde pueden descargar la solución.

lunes, 15 de julio de 2013

Acceso a Datos y Entidades

Introducción :

Muchas veces , se suele usar Entity Framework por su facilidad , ya que este nos crea automáticamente todas las entidades que necesitemos, sin embargo todo lo fácil tiene sus desventajas ,como por ejemplo si modificamos un procedimiento almacenado , este no se refleja de inmediato en la aplicación , por lo que debemos actualizarlo manualmente. Hoy veremos como accesar a datos y asignar valores a las entidades mediante clases, usando la conocida base de datos "Neptuno".

1.Cadena de Conexión : Creamos la cadena de conexión en el archivo Web.Config
  <connectionStrings>
    <add name="ConexionNeptuno" connectionString="Data Source=localhost;Initial Catalog=Neptuno; integrated security = SSPI" providerName="System.Data.SqlClient"/>
  </connectionStrings>


 2. Creamos un procedimiento almacenado sencillo para demostración.
USE [Neptuno]
GO

CREATE PROC ListarClientes
AS
SELECT IdCliente,NombreCompañia,Direccion,Pais FROM Clientes

3.  Creamos el método que nos devolverá el resultado del procedimiento almacenado, en este caso usaremos como retorno un Datatable, no se olviden que para usar el "ConfigurationManager" , debemos importar la libreria "System.Configuration" asi como para el "SqlConnecion" y "SqlCommand"  el ""System.Data.SqlClient".
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Configuration;
using System.Data.SqlClient;
using System.Data;

namespace MvcApplication1.Models
{
    public class AccesoDatos
    {
        string conex = ConfigurationManager.ConnectionStrings["ConexionNeptuno"].ConnectionString;
       
        public DataTable ListarClientes()
        {
            SqlConnection conexion = new SqlConnection(conex);
            SqlCommand comand = new SqlCommand("ListarClientes", conexion);
            comand.CommandType = CommandType.StoredProcedure;
            DataTable dt = new DataTable();
            conexion.Open();
            dt.Load(comand.ExecuteReader());
            conexion.Close();
            return dt;

        }
    }
}


4. Creando la Entidad Cliente , y definiendo sus propiedades. Aqui como lo dije al comienzo , como no usaremos las entidades autogeneradas del Entity Framework, creamos la Entidad manualmente, por lo que debemos definir un constructor.

Se preguntaran que es un constructor ?
Cada vez que se crea una clase o estructura, se llama a su constructor. Una clase o estructura puede tener varios constructores que toman argumentos diferentes. Los constructores permiten al programador establecer valores predeterminados, limitar la creación de instancias y escribir código flexible y fácil de leer.
Microsoft nos da un concepto bien claro acerca de esto : Constructores C#
public class ClienteModel
    {
        public string IdCliente { get; set; }
        public string NombreCompañia { get; set; }
        public string Direccion { get; set; }
        public string Pais { get; set; }

        public ClienteModel(object[] constructor)

        { 
            this.IdCliente = (string)constructor[0];
            this.NombreCompañia = (string)constructor[1];
            this.Direccion = (string)constructor[2];
            this.Pais = (string)constructor[3];
        }


Aqui creo un constructor llamado de igual manera que la Entidad cuyo parametro lo defino como un array.

5. Asignando valores a la Entidad.

Nos encontramos en el controlador "ClienteController" , donde podremos asignar los valores a las propiedades de la Entidad Cliente.
public class ClienteController : Controller
    {
        Models.AccesoDatos db = new AccesoDatos();

        public ActionResult Clientes()
        {
             var Clientes = db.ListarClientes();

             var lista = new List<ClienteModel>();

             foreach (DataRow r in Clientes.Rows)
             {
                 lista.Add(new ClienteModel(r.ItemArray));
             }

            var ListaClientes = lista.ToList();

            ViewBag.ListaClientes = ListaClientes;
            
            return View();
        }

    }


Que Estoy haciendo aquí ?
  1. Primero instanciamos la clase "AccesoDatos" para obtener el metodo "ListarClientes" y lo guardaremos en una variable , en este caso llamada "Clientes".
  2. Instanciamos en la variable "lista" la entidad.
  3. Como el método nos devuelve una tabla , podemos hacer un for each a la variable que guarda el resultado del mismo, definiendo una variable tipo DataRow , y recorreremos fila por fila el Datatable

        4. Finalmente con "lista.add(new ClienteModel(r.ItemArray))" , agregamos los valores a la 
            Entidad Cliente.

        Espero te sirva este pequeño instructivo , en un proximo post , veremos como llevar el 
        resultado de un controlador a una vista mediante "Razor".

jueves, 11 de julio de 2013

Entity Framework

Introducción

Entity Framework se implementó en .NET desde el framework 3.5 y esta disponible hasta el actual , cuya utilidad es enorme ya que nos reducirá una gran parte de código al programar.

Nos permite crear un modelo conceptual a partir de una base de datos , así como los métodos que solemos utilizar para acceder a una tabla , como grabar , modificar y eliminar , entre muchas otras cosas.

Básicamente nos trae todas las tablas de la base de datos , y nos las muestra como un diagrama parecido al de SQL , de esta manera podemos trabajar compatiblemente con Language Integrated Query (Linq) , que nos proporciona una validación de la sintaxis en el momento de la compilación para las consultas en un modelo conceptual.


Creando un esquema Entity Framework :

Creando un nuevo proyecto en Visual Studio y seguimos los siguientes pasos.

1. Agregamos un nuevo elemento al proyecto.


2. Elegimos ADO.NET Entity Data Model.



3. Para el contenido del Modelo , seleccionamos "Generar desde la base de datos" y le damos 
     siguiente.



4. Le damos a "Nueva Conexión"



5. Elegimos el tipo de origen de datos y le damos continuar.



6. Elegimos el servidor donde esta la base de datos , en este caso solo le pondré un punto por      ser local , pero en caso de que estuvieses trabajando con un servidor , deberás poner la ip        del servidor y debajo el usuario y password para acceder al mismo, en el momento de              elegir el servidor , se cargaran las base de datos disponibles, donde deben elegir con la que      se trabajara , en mi caso usar una BD llamada BalProcter , y le damos aceptar.



7. Como ven , se ha generado una cadena de conexión a partir del servidor y la base de datos      seleccionada , el mismo que aparecerá en el archivo Web.Config de la aplicación. por otro          lado también vemos en nombre generado del conjunto de entidades.



8. Por ultimo , vemos que efectivamente tenemos las tablas , procedimiento almacenados y         vistas , solo queda seleccionar con las que deseemos trabajar.


     Como vez se ha generar un esquema conceptual de las tablas pertenecientes a la base        de datos con la que hiciste la conexión.           


9. Al lado derecho verán las tablas , procedimiento o vistas que hayan elegido.


10. En caso de que no vean el Explorador de Modelos , den click derecho en cualquier parte            en blanco del esquema y eligen "Explorador de Modelos".



      Espero que te haya sido de ayuda esta pequeña guía. 

miércoles, 10 de julio de 2013

Introducción a ASP.NET MVC 4

MVC , cuyas siglas significan Modelo Vista Controlador ,  es un patrón de arquitectura de software que lo separa en 3 partes fundamentales :

Modelo : Esta parte es mas que todo los datos con los que vas a trabajar , me refiero a la Base de datos y/o tablas.

Controlador : Su nombre lo dice , "controlador" , pero controlar que ? , pues bien , esta parte de encarga de mostrar los datos en las vistas , según peticiones del lado de cliente. 

Vista : La vistas son en si los Web Forms , por así decirlo , pues esta sera la interfaz donde va a interactuar el cliente con el sistema.

Cabe decir que MVC , no es para nada moderno , pues ya tiene muchos años atrás de haberse creado , tampoco es que Microsoft haya creado este patrón , simplemente lo tomo, lo estudio y así nació MVC , que por cierto fueron 4 versiones.

Que hay que saber para programar en MVC 4 ?

Básicamente para empezar con MVC 4, se deberá tener nociones de HTML , ya que en este patrón ya no existen controles de servidor , es decir en ASP.NET , recordaran que para hacer una caja de texto , usaban el <asp:textbox></texbox>  por ejemplo , y tenían el cuadro de herramientas en un lado con todos los controles de .net , solo para arrastrarlos a el web form, pues bien , aquí solamente se puede usar html puro , es decir , si quieres una caja de texto tendrás que el hacer el tradicional <input type="text">.

Seguramente te preguntaras que al decirte que no existen controles de servidor , y por tanto no habiendo tampoco eventos de los mismos , ¿donde programo mi código? o mas importante aun ¿como asigno el código a el control que quiero?

Pues bien aqui viene la otra parte que debes saber , el famoso lenguaje de programación "JavaScript" y su libreria estrella "Jquery", mediante estos amigos lograremos todas las acciones que deseemos , ya que como lo mencione MVC mas trabaja en el lado de cliente esta herramienta nos ayudara mucho , mediante jquery podremos asignar acciones en los eventos de los controles que esta libreria nos ofrece.

Por ejemplo.

Se acuerdan del <asp:button></button> , a cuyo evento accedíamos dándole doble click al control el cual nos llevaba al Button1_Click.

Pues bien , en escenario MVC 4, seria algo como esto

tienes <input type="button" id="boton1"/> , por medio del correcto uso de los selectores podremos hacer lo siguiente.

$("#boton1").click(function(){

alert ("Hola MVC");
});

Por ultimo para entrar a MVC 4, definitivamente has debido de pasa primero por .NET

Para acabar aqui te dejo un manual de ASP.NET MVC 4 .

ASP.NET MVC 4 Professional Manual

martes, 9 de julio de 2013

Acerca de mí - Santiago Campusmana.

Introducción :

Antes que todo , hablarles un poco acerca de mi ..
En la Actualidad soy un estudiante de computación e informática y sistemas en un instituto privado llamado IDAT , en Perú. 
Tengo 23 años y actualmente estoy trabajando en una consultora de sistemas , donde trabajamos con los productos de Microsoft , mas específicamente con ASP.NET Clásico y ASP.NET MVC 4 , SQL server 2008 R2 , Servidores IIS , ISA Server y viendo posibilidad de programar en otras plataformas.
En estos momentos mi meta es certificarme en una de las tecnologías de Microsoft ,a la cual tengo mas cercanas las ya mencionadas.

Les comento que a mi al comienzo no me gustaba para nada la programación, incluso tenia pensando salirme del trabajo por una idea que se me había metido , la cual era que no sabia programar, pero verán, felizmente no me salí , gracias a eso he aprendido muchísimas cosas de los programadores Senior de la consultora, lo que antes lo veía difícil ahora lo veo muy fácil  aunque aun me falta mucho por aprender , estoy aun encaminándome a un mundo donde la información no tiene fin.

Muy aparte de eso , soy un gamer , me gustan mucho los juegos On line , en la actualidad juego el World Of WarCraft , un juego multijugador de rol masivo , muy entretenido , me hizo conocer personas de varios paises , hablar entre todos, es muy bueno.

centrandome en el tema, este Blog , estará dedicado a compartir mis conocimientos de ASP.NET y ASP.NET MVC 4 hacia todos, lo poco o mucho que sepa lo compartiré con ejemplos y tutoriales , se me hizo muy difícil aprender MVC 4, es algo totalmente distinto a .NET clásico, por lo que deseo que todos los que comienzen a programar en esta plataforma, vean este blog como una especie de guia para los inconvenientes diarios de su programación.

Empezaré con cosas con la que lidiamos diariamente, que en muchos casos son básico para mi pero que en su momento fue difícil.

No solo me centrare exclusivamente en .NET , sino en otros temas , ya sea de software , hardware , etc.

Espero que sea de utilidad en su totalidad el contenido de este Blog, ya que también me sirve como un libro donde guardo todo lo que aprendo.