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.
   
2. Este proyecto será del tipo Aplicación web ASP.NET -> MVC
   
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.
4. Conectamos la base de datos a nuestro proyecto.
   
5. Crearemos un contexto con la tabla que tenemos (en la carpeta Models creamos un nuevo archivo de tipo LINQ to SQL)
6. Creamos la nueva zona en Views, el controlador en Controllers y la clase en Models.
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;
   7. namespace VideoTutorial.Models
   8. {
   9. public class Tienda
   10. {
   11. contextoTiendaDataContext contexto;
   12. public Tienda()
   13. {
   14. this.contexto = new contextoTiendaDataContext();
   15. }
   17. public List GetProductos()
   18. {
   19. var consulta = from datos in contexto.PRODUCTOS
   20. select datos;
   21. return consulta.ToList();
   23. }
   24. }
   25. }
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. }
   5. <h2> Index</h2>
   6. <ul class=»list-group»>
   7. <li class=»list-group-item»>@Html.ActionLink(«Productos a la venta»,»TiendaVista», «Tienda»)</li>
   8. </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. }
   5. @model List
   7. <h2>Productos a la venta</h2>
   8. <hr />
   9. <table border=»1″ class=»table-bordered»>
   10. <tr>
   11. <th>Nombre juego</th>
   12. <th>Precio</th>
   13. <th></th>
   14. </tr>
   15. @foreach (var prod in Model)
   16. {
   17. <tr>
   18. <td>@prod.NPRODUCTO</td>
   19. <td>@prod.PRECIO €</td>
   20. <td>
   21. <a href=’@Url.Action(«TiendaVista», «Tienda», new { producto = prod.IDPRODUCTO, precio=prod.PRECIO }, null)’>
   22. <img src=’@Url.Content(«~/Images/carrito.jpg»)’ height=»30″ width=»30″ />
   23. </a>
   24. </td>
   25. </tr>
   26. }
   27. </table>
   28. <br />
   30. @if (ViewBag.TotalProductos != null && ViewBag.PrecioTotal != null)
   31. {
   32. <table class=»table-responsive, table-bordered»>
   33. <tr>
   34. <th>Total productos</th>
   35. <th>Precio Total</th>
   36. </tr>
   37. <tr>
   38. <td>@ViewBag.TotalProductos</td>
   39. <td>@ViewBag.PrecioTotal</td>
   40. </tr>
   41. </table>
   42. }
   44. <button type=»button» onclick=»location.href=’@Url.Action(«TiendaProductosElegidos», «Tienda»)'» class=»btn-success»>
   45. Comprar
   46. </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. }
    23. public ActionResult TiendaVista(int? producto, decimal? precio)
    24. {
    25. List listaproductos = this.modelo.GetProductos();
    26. decimal suma = 0;
    27. if (producto != null && precio != null)
    28. {
    29. //aquí tenemos el id de un producto y su precio. queremos almacenar múltiples
    30. List idproductos;
    31. List precios;
    33. if (Session[«PRODUCTOS»] == null)
    34. {
    35. //si no existe creamos la colección
    36. idproductos = new List();
    37. precios = new List();
    38. }
    39. else
    40. {
    41. //si existe, recuperamos la colección de la sesión
    42. idproductos = (List)Session[«PRODUCTOS»];
    43. precios = (List)Session[«PRECIOS»];
    44. }
    45. //añadimos el nuevo id en la colección con su precio
    46. idproductos.Add(producto.GetValueOrDefault());
    47. precios.Add(precio.GetValueOrDefault());
    48. Session[«PRODUCTOS»] = idproductos;
    49. Session[«PRECIOS»] = precios;
    50. //como es una lista de la compra, los precios deben sumarse a un total
    51. for (int i = 0; i < precios.Count(); i++)
    52. {
    53. suma += precios[i];
    54. }
    56. //devolvemos el total productos y el total precio por viewbag
    57. ViewBag.PrecioTotal = suma + «€»;
    58. ViewBag.TotalProductos = idproductos.Count();
    59. }
    60. //devolvemos siempre la lista de productos
    61. return View(listaproductos);
    62. }
    63. }
    64. }
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.
    
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. }
    12. <hr />
    13. @if (Model != null)
    14. {
    15. <table class=»table-bordered»>
    16. <tr>
    17. <th> Nombre juego</th>
    18. <th> Precio</th>
    19. <th> </th>
    20. </tr>
    21. @foreach (var prod in Model)
    22. {
    23. <tr>
    24. <td> @prod.NPRODUCTO</td>
    25. <td> @prod.PRECIO €</td>
    26. <td>
    27. <a href=’@Url.Action(«TiendaProductosElegidos», «Tienda», new { borrarproducto = prod.IDPRODUCTO, borrarprecio=prod.PRECIO }, null)’>
    28. <img src=’@Url.Content(«~/Images/delete.png»)’ height=»30″ width=»30″ />
    29. </a>
    30. </td>
    31. </tr>
    32. }
    33. </table>
    34. }<br />
    36. @if (ViewBag.TotalProductos != null && ViewBag.PrecioTotal != null)
    37. {
    38. <table class=»table-bordered»>
    39. <tr>
    40. <th> Total productos</th>
    41. <th> Precio Total</th>
    42. </tr>
    43. <tr>
    44. <td> @ViewBag.TotalProductos</td>
    45. <td> @ViewBag.PrecioTotal</td>
    46. </tr>
    47. </table>
    48. }
    50. <button type=»button» onclick=»location.href=’@Url.Action(«TiendaVista», «Tienda»)'» class=»btn-warning»>
    51. Volver
    52. </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;
    7. namespace VideoTutorial.Models
    8. {
    9. public class Tienda
    10. {
    11. contextoTiendaDataContext contexto;
    12. public Tienda()
    13. {
    14. this.contexto = new contextoTiendaDataContext();
    15. }
    17. public List GetProductos()
    18. {
    19. var consulta = from datos in contexto.PRODUCTOS
    20. select datos;
    21. return consulta.ToList();
    23. }
    24. public List GetProductosSesion(List idproductos)
    25. {
    26. var consulta = from datos in contexto.PRODUCTOS
    27. where idproductos.Contains(datos.IDPRODUCTO)
    28. select datos;
    29. return consulta.ToList();
    31. }
    32. }
    33. }
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. }
    23. public ActionResult TiendaVista(int? producto, decimal? precio)
    24. {
    25. List listaproductos = this.modelo.GetProductos();
    26. decimal suma = 0;
    27. if (producto != null && precio != null)
    28. {
    29. //aquí tenemos el id de un producto y su precio. queremos almacenar múltiples
    30. List idproductos;
    31. List precios;
    33. if (Session[«PRODUCTOS»] == null)
    34. {
    35. //si no existe creamos la colección
    36. idproductos = new List();
    37. precios = new List();
    38. }
    39. else
    40. {
    41. //si existe, recuperamos la colección de la sesión
    42. idproductos = (List)Session[«PRODUCTOS»];
    43. precios = (List)Session[«PRECIOS»];
    44. }
    45. //añadimos el nuevo id en la colección con su precio
    46. idproductos.Add(producto.GetValueOrDefault());
    47. precios.Add(precio.GetValueOrDefault());
    48. Session[«PRODUCTOS»] = idproductos;
    49. Session[«PRECIOS»] = precios;
    50. //como es una lista de la compra, los precios deben sumarse a un total
    51. for (int i = 0; i < precios.Count(); i++)
    52. {
    53. suma += precios[i];
    54. }
    56. //devolvemos el total productos y el total precio por viewbag
    57. ViewBag.PrecioTotal = suma + «€»;
    58. ViewBag.TotalProductos = idproductos.Count();
    59. }
    60. //devolvemos siempre la lista de productos
    61. return View(listaproductos);
    62. }
    65. public ActionResult TiendaProductosElegidos(int? borrarproducto, decimal? borrarprecio)
    66. {
    67. //recuperamos las listas de la sesión que se han creado en la página principal
    68. List idproductos = (List)Session[«PRODUCTOS»];
    69. List precios = (List)Session[«PRECIOS»];
    70. decimal suma = 0;
    71. if (borrarproducto != null)
    72. {
    73. //si el usuario ha deseado cancelar un producto de la lista entra aquí
    74. //y recuperamos el valor
    75. idproductos.Remove(borrarproducto.GetValueOrDefault());
    76. precios.Remove(borrarprecio.GetValueOrDefault());
    78. if (idproductos.Count() == 0)
    79. {
    80. //si ya no hay productos en la lista, ponemos todo a null
    81. Session[«PRODUCTOS»] = null;
    82. Session[«PRECIOS»] = null;
    83. ViewBag.PrecioTotal = null;
    84. ViewBag.TotalProductos = null;
    85. }
    86. else
    87. {
    88. //si la lista aún no está vacía, recuperamos el resto
    89. Session[«PRODUCTOS»] = idproductos;
    90. Session[«PRECIOS»] = precios;
    91. }
    92. }
    93. if (Session[«PRODUCTOS»] != null)
    94. {
    95. //si existe contenido en la sesión lo recuperamos
    96. //recuperamos los productos y su precio a partir de la colección
    97. List listaproductos = this.modelo.GetProductosSesion(idproductos);
    99. //volvemos a hacer una suma total de precios de los
    100. //productos que estén en la colección
    101. for (int i = 0; i < precios.Count(); i++)
    102. {
    103. suma += precios[i];
    104. }
    105. //volvemos a enviar los ViewBag
    106. ViewBag.PrecioTotal = suma + «€»;
    107. ViewBag.TotalProductos = idproductos.Count();
    108. return View(listaproductos);
    109. }
    110. return View();
    111. }
    112. }
    113. }
16. Así sería como quedaría la página de la lista.