Introducción

    • Session en ASP.NET  es el objeto que interacciona con las cookies, guardando y sacando datos de ellas. Las ventajas de Session es que sólo guarda los datos de un usuario, es decir, para una web customizada en la que interaccionan varios usuarios con diferentes intereses, crea una ‘experiencia’ personalizada para cada uno. Esto es capaz de lograrlo porque guarda un estado de lo que el usuario quiere, y esto no es posible en HTTP porque este no mantiene estados.
    • Otra ventaja de Session respecto a otros es que este guarda los datos hasta el final de la sesión, mientras que en otros casos, por ejemplo TempData, sólo lo guardan hasta que se usan y luego los destruyen.

 

Caso práctico

  • En este ejercicio haremos un caso práctico de Session en el que crearemos una lista de la compra para el usuario desde una base de datos que tenemos creada. Para ello necesitaremos:
    • 1 base de datos
    • 1 archivo LINQ to SQL.
    • 1 Controller para la zona.
    • 1 zona llamada Tienda con 3 vistas: Index, TiendaProductosElegidos y TiendaVista.
    • 1 clase llamada Tienda.
    • 2 imágenes de una cesta(una con aspa) [OPCIONAL].
    1. Primero debemos crear un nuevo proyecto.
      2016-12-15_00h28_10
    2. Este proyecto será del tipo Aplicación web ASP.NET -> MVC
      2016-12-15_00h28_272016-12-15_00h29_32
    3. Para este ejemplo tenemos una base de datos creada con los datos a usar, pero puede usarse otros métodos para almacenar los datos.2016-12-15_00h33_332016-12-15_00h33_45
    4. Conectamos la base de datos a nuestro proyecto.
      2016-12-15_00h34_212016-12-15_00h34_36
    5. Crearemos un contexto con la tabla que tenemos (en la carpeta Models creamos un nuevo archivo de tipo LINQ to SQL)2016-12-15_00h39_292016-12-15_00h40_03
    6. Creamos la nueva zona en Views, el controlador en Controllers y la clase en Models.2016-12-15_00h40_41
    7. Lo primero que editaremos será la clase Tienda. En un principio necesitaremos 2 métodos iniciales: Uno para enlazar con el contexto de la bd y así conseguir los datos de ella., y otro para crear una lista del total de productos en nuestra bd que mostraremos para que el usuario pueda elegir qué productos desea.
      Clase Tienda
      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Web;
      5. namespace VideoTutorial.Models
      6. {
      7. public class Tienda
      8. {
      9. contextoTiendaDataContext contexto;
      10. public Tienda()
      11. {
      12. this.contexto = new contextoTiendaDataContext();
      13. }
      14. public List GetProductos()
      15. {
      16. var consulta = from datos in contexto.PRODUCTOS
      17. select datos;
      18. return consulta.ToList();
      19. }
      20. }
      21. }
    8. En nuestra zona, vamos a la vista de Index, donde pondremos un link a nuestra página principal de compras. La segunda página no se pondrá, ya que se supone que sólo podrá ser accesible desde la principal(están comentadas para que no den conflictos con el código de la página).
      Clase Producto
      1. @{
      2. ViewBag.Title = “Index”;
      3. }
      4. <h2> Index</h2>
      5. <ul class=”list-group”>
      6. <li class=”list-group-item”>@Html.ActionLink(“Productos a la venta”,”TiendaVista”, “Tienda”)</li>
      7. </ul>
    9. La página principal tendrá que tener un código donde cargue dinámicamente los productos que poseemos en la bd, además de darle la opción de poder seleccionar el producto que desee añadir a su cesta (como en este caso es una lista de videojuegos, debemos dejar que el cliente pueda seleccionar varias veces el mismo producto) y una zona donde se muestre el total de productos y precio que lleva en su cesta. Para terminar habrá un botón que le envíe a la siguiente vista.
      Clase Producto
      1. @{
      2. ViewBag.Title = “TiendaVista”;
      3. }
      4. @model List
      5. <h2>Productos a la venta</h2>
      6. <hr />
      7. <table border=”1″ class=”table-bordered”>
      8. <tr>
      9. <th>Nombre juego</th>
      10. <th>Precio</th>
      11. <th></th>
      12. </tr>
      13. @foreach (var prod in Model)
      14. {
      15. <tr>
      16. <td>@prod.NPRODUCTO</td>
      17. <td>@prod.PRECIO €</td>
      18. <td>
      19. <a href=’@Url.Action(“TiendaVista”, “Tienda”, new { producto = prod.IDPRODUCTO, precio=prod.PRECIO }, null)’>
      20. <img src=’@Url.Content(“~/Images/carrito.jpg”)’ height=”30″ width=”30″ />
      21. </a>
      22. </td>
      23. </tr>
      24. }
      25. </table>
      26. <br />
      27. @if (ViewBag.TotalProductos != null && ViewBag.PrecioTotal != null)
      28. {
      29. <table class=”table-responsive, table-bordered”>
      30. <tr>
      31. <th>Total productos</th>
      32. <th>Precio Total</th>
      33. </tr>
      34. <tr>
      35. <td>@ViewBag.TotalProductos</td>
      36. <td>@ViewBag.PrecioTotal</td>
      37. </tr>
      38. </table>
      39. }
      40. <button type=”button” onclick=”location.href=’@Url.Action(“TiendaProductosElegidos”, “Tienda”)'” class=”btn-success”>
      41. Comprar
      42. </button>
    10. Iremos al controlador y crearemos un public para el modelo (incluyendo el using de Models).
      Clase Producto
      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Web;
      5. using System.Web.Mvc;
      6. using VideoTutorial.Models;
      7. namespace VideoTutorial.Controllers
      8. {
      9. public class TiendaController : Controller
      10. {
      11. Tienda modelo;
      12. public TiendaController()
      13. {
      14. this.modelo = new Tienda();
      15. }
      16. // GET: Tienda
      17. public ActionResult Index()
      18. {
      19. return View();
      20. }
      21. }
      22. }
    11. Después crearemos un get para la nueva vista. Tenemos que tener en cuenta que habrá dos “procesos”: El cargar la página por primera vez (sin un producto seleccionado) y cuando el usuario seleccione un producto deseado.
      Clase Producto
      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Web;
      5. using System.Web.Mvc;
      6. using VideoTutorial.Models;
      7. namespace VideoTutorial.Controllers
      8. {
      9. public class TiendaController : Controller
      10. {
      11. Tienda modelo;
      12. public TiendaController()
      13. {
      14. this.modelo = new Tienda();
      15. }
      16. // GET: Tienda
      17. public ActionResult Index()
      18. {
      19. return View();
      20. }
      21. public ActionResult TiendaVista(int? producto, decimal? precio)
      22. {
      23. List listaproductos = this.modelo.GetProductos();
      24. decimal suma = 0;
      25. if (producto != null && precio != null)
      26. {
      27. //aquí tenemos el id de un producto y su precio. queremos almacenar múltiples
      28. List idproductos;
      29. List precios;
      30. if (Session[“PRODUCTOS”] == null)
      31. {
      32. //si no existe creamos la colección
      33. idproductos = new List();
      34. precios = new List();
      35. }
      36. else
      37. {
      38. //si existe, recuperamos la colección de la sesión
      39. idproductos = (List)Session[“PRODUCTOS”];
      40. precios = (List)Session[“PRECIOS”];
      41. }
      42. //añadimos el nuevo id en la colección con su precio
      43. idproductos.Add(producto.GetValueOrDefault());
      44. precios.Add(precio.GetValueOrDefault());
      45. Session[“PRODUCTOS”] = idproductos;
      46. Session[“PRECIOS”] = precios;
      47. //como es una lista de la compra, los precios deben sumarse a un total
      48. for (int i = 0; i < precios.Count(); i++)
      49. {
      50. suma += precios[i];
      51. }
      52. //devolvemos el total productos y el total precio por viewbag
      53. ViewBag.PrecioTotal = suma + “€”;
      54. ViewBag.TotalProductos = idproductos.Count();
      55. }
      56. //devolvemos siempre la lista de productos
      57. return View(listaproductos);
      58. }
      59. }
      60. }
    12. El usuario debería poder ver un listado de nuestros productos y almacenar el Session los que él desee haciendo click sobre la imagen de la cesta.
      CapturaCaptura1Captura3
    13. El siguiente paso es crear el código de la vista de confirmación de la compra, en la que deberemos visualizar los productos que el usuario ha seleccionado con la opción a cancelar alguno o todos, además de un mensaje de alerta por si la lista está vacía.
      Clase Producto

      <

        >

      1. @{
      2. ViewBag.Title = “TiendaProductosElegidos”;
      3. }
      4. @model List
      5. <h2> Lista de la compra</h2>
      6. @if (Session[“PRODUCTOS”] == null)
      7. {
      8. //La lista de la compra está vacía
      9. <h2 class=”text-danger”> Su lista de la compra está vacía</h2>
      10. }
      11. <hr />
      12. @if (Model != null)
      13. {
      14. <table class=”table-bordered”>
      15. <tr>
      16. <th> Nombre juego</th>
      17. <th> Precio</th>
      18. <th> </th>
      19. </tr>
      20. @foreach (var prod in Model)
      21. {
      22. <tr>
      23. <td> @prod.NPRODUCTO</td>
      24. <td> @prod.PRECIO €</td>
      25. <td>
      26. <a href=’@Url.Action(“TiendaProductosElegidos”, “Tienda”, new { borrarproducto = prod.IDPRODUCTO, borrarprecio=prod.PRECIO }, null)’>
      27. <img src=’@Url.Content(“~/Images/delete.png”)’ height=”30″ width=”30″ />
      28. </a>
      29. </td>
      30. </tr>
      31. }
      32. </table>
      33. }<br />
      34. @if (ViewBag.TotalProductos != null && ViewBag.PrecioTotal != null)
      35. {
      36. <table class=”table-bordered”>
      37. <tr>
      38. <th> Total productos</th>
      39. <th> Precio Total</th>
      40. </tr>
      41. <tr>
      42. <td> @ViewBag.TotalProductos</td>
      43. <td> @ViewBag.PrecioTotal</td>
      44. </tr>
      45. </table>
      46. }
      47. <button type=”button” onclick=”location.href=’@Url.Action(“TiendaVista”, “Tienda”)'” class=”btn-warning”>
      48. Volver
      49. </button>
    14. Como vamos a dar la opción a eliminar productos de su lista, debemos crear un nuevo método en la clase Tienda donde busquemos en la lista creada el producto concreto.
      Clase Tienda
      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Web;
      5. namespace VideoTutorial.Models
      6. {
      7. public class Tienda
      8. {
      9. contextoTiendaDataContext contexto;
      10. public Tienda()
      11. {
      12. this.contexto = new contextoTiendaDataContext();
      13. }
      14. public List GetProductos()
      15. {
      16. var consulta = from datos in contexto.PRODUCTOS
      17. select datos;
      18. return consulta.ToList();
      19. }
      20. public List GetProductosSesion(List idproductos)
      21. {
      22. var consulta = from datos in contexto.PRODUCTOS
      23. where idproductos.Contains(datos.IDPRODUCTO)
      24. select datos;
      25. return consulta.ToList();
      26. }
      27. }
      28. }
    15. Ahora vamos al Controller y creamos el Get para la 2ª página. Como en el anterior, deberemos tener en cuenta varios casos: que haya o no productos, si los hay cargarlos todos y si cancela alguno, quitarlo de la lista.
      Clase Producto
      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Web;
      5. using System.Web.Mvc;
      6. using VideoTutorial.Models;
      7. namespace VideoTutorial.Controllers
      8. {
      9. public class TiendaController : Controller
      10. {
      11. Tienda modelo;
      12. public TiendaController()
      13. {
      14. this.modelo = new Tienda();
      15. }
      16. // GET: Tienda
      17. public ActionResult Index()
      18. {
      19. return View();
      20. }
      21. public ActionResult TiendaVista(int? producto, decimal? precio)
      22. {
      23. List listaproductos = this.modelo.GetProductos();
      24. decimal suma = 0;
      25. if (producto != null && precio != null)
      26. {
      27. //aquí tenemos el id de un producto y su precio. queremos almacenar múltiples
      28. List idproductos;
      29. List precios;
      30. if (Session[“PRODUCTOS”] == null)
      31. {
      32. //si no existe creamos la colección
      33. idproductos = new List();
      34. precios = new List();
      35. }
      36. else
      37. {
      38. //si existe, recuperamos la colección de la sesión
      39. idproductos = (List)Session[“PRODUCTOS”];
      40. precios = (List)Session[“PRECIOS”];
      41. }
      42. //añadimos el nuevo id en la colección con su precio
      43. idproductos.Add(producto.GetValueOrDefault());
      44. precios.Add(precio.GetValueOrDefault());
      45. Session[“PRODUCTOS”] = idproductos;
      46. Session[“PRECIOS”] = precios;
      47. //como es una lista de la compra, los precios deben sumarse a un total
      48. for (int i = 0; i < precios.Count(); i++)
      49. {
      50. suma += precios[i];
      51. }
      52. //devolvemos el total productos y el total precio por viewbag
      53. ViewBag.PrecioTotal = suma + “€”;
      54. ViewBag.TotalProductos = idproductos.Count();
      55. }
      56. //devolvemos siempre la lista de productos
      57. return View(listaproductos);
      58. }
      59. public ActionResult TiendaProductosElegidos(int? borrarproducto, decimal? borrarprecio)
      60. {
      61. //recuperamos las listas de la sesión que se han creado en la página principal
      62. List idproductos = (List)Session[“PRODUCTOS”];
      63. List precios = (List)Session[“PRECIOS”];
      64. decimal suma = 0;
      65. if (borrarproducto != null)
      66. {
      67. //si el usuario ha deseado cancelar un producto de la lista entra aquí
      68. //y recuperamos el valor
      69. idproductos.Remove(borrarproducto.GetValueOrDefault());
      70. precios.Remove(borrarprecio.GetValueOrDefault());
      71. if (idproductos.Count() == 0)
      72. {
      73. //si ya no hay productos en la lista, ponemos todo a null
      74. Session[“PRODUCTOS”] = null;
      75. Session[“PRECIOS”] = null;
      76. ViewBag.PrecioTotal = null;
      77. ViewBag.TotalProductos = null;
      78. }
      79. else
      80. {
      81. //si la lista aún no está vacía, recuperamos el resto
      82. Session[“PRODUCTOS”] = idproductos;
      83. Session[“PRECIOS”] = precios;
      84. }
      85. }
      86. if (Session[“PRODUCTOS”] != null)
      87. {
      88. //si existe contenido en la sesión lo recuperamos
      89. //recuperamos los productos y su precio a partir de la colección
      90. List listaproductos = this.modelo.GetProductosSesion(idproductos);
      91. //volvemos a hacer una suma total de precios de los
      92. //productos que estén en la colección
      93. for (int i = 0; i < precios.Count(); i++)
      94. {
      95. suma += precios[i];
      96. }
      97. //volvemos a enviar los ViewBag
      98. ViewBag.PrecioTotal = suma + “€”;
      99. ViewBag.TotalProductos = idproductos.Count();
      100. return View(listaproductos);
      101. }
      102. return View();
      103. }
      104. }
      105. }
    16. Así sería como quedaría la página de la lista.
      Captura4Captura5Captura6

 

Descripción: Cómo hacer una lista de la compra en MVC4 usando Session.
Autor/a: Sergio Palacios Navarro
Curso: Microsoft MCSD Web Applications + SharePoint Apps
Centro: Tajamar
Año académico: 2016-2017