Keep in Touch!

Contenuti

C# 9 and .NET 5

NetCore: HttpContext Session (String, Int32, Byte[])

Contenuti

Durante la creazione di un sito MVC sviluppato con tecnologia NETCore utlizzare le sessioni all’interno dei controller è davvero semplice. Per farlo ti basterà utilizzare la proprietà Session (ISession) presente all’interno di HttpContext. Sarà il controller stesso a fornirci al suo interno il contesto corrente senza complicarci la vita. Prima di fornire la classe “SessionHelper” che ho scritto per voi, vi segnalo due modifiche da fare all’interno dei file Startup.cs:

1
2
3
4
5
6
7
8

       // This method gets called by the runtime. Use this method to add services to the container.
       public void ConfigureServices(IServiceCollection services)
       {
           services.AddControllersWithViews();
           services.AddSession();
       }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

       // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
       {
       [...]
           app.UseSession();
 
       [...]
       }

Dopo avere dichiarato di volere utilizzare le session, siamo pronti ad importare la classe SessionHelper per semplificarci la vita scrivendo il codice di accesso al nostro HttpContext / Session una volta per tutte.

Nel codice a seguire troverete una serie di Set (string Key, value)  e Get (string key) in quanto accedendo alla sessione vi è la possibilità di memomorizzare all’interno

  • string

  • int32

  • Byte []

Alla fine di tutto il codice ho inserito anche un esempio di come memorizzare (e leggere) un valore di tipo string usando .Get/Set Byte sfruttando Encoding.UTF8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Text;
 
namespace DevAndreaCarratta.WebDemo
{
    public class SessionHelper
    {
 
        private Controller _controller;
 
        public SessionHelper(Controller controller)
        {
            _controller = controller;
        }
 
        public string GetStringValue(string key)
        {
            return _controller.HttpContext.Session.GetString(key);
        }
 
        public void SetStringValue(string key, string value)
        {
 
            _controller.HttpContext.Session.SetString(key, value);
        }
 
        public int? GetInt32Value(string key)
        {
            return _controller.HttpContext.Session.GetInt32(key);
        }
 
        public void SetInt32Value(string key, int value)
        {
 
            _controller.HttpContext.Session.SetInt32(key, value);
        }
 
        public Byte[] GetBytesValue(string key)
        {
            return _controller.HttpContext.Session.Get(key);
        }
 
        public void SetBytesValue(string key, Byte[] value)
        {
 
            _controller.HttpContext.Session.Set(key, value);
        }
 
        public void SetStringAsBytesValue(string key, string value)
        {
            var bytes = Encoding.UTF8.GetBytes(value);
            _controller.HttpContext.Session.Set(key, bytes);
        }
 
        public string GetStringFromBytesValue(string key)
        {
            var bytes = _controller.HttpContext.Session.Get(key);
            return Encoding.UTF8.GetString(bytes);
        }
 
 
    }
}

Per verificare il tutto vi basterà riportare il seguente esempio all’interno di un controller della vostra WebApplication e modificare i valori in base alle vostre esigenze. (Personalmente ho utilizzato il controller HomeController ripulendolo da altro codice)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using DevAndreaCarratta.WebDemo.Models;
 
namespace DevAndreaCarratta.WebDemo
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;
 
        private string _textValue = "NetCore - Session Test";
        private int _intValue = 12345;
        private const string STRING_KEY = "STRING_KEY";
        private const string INT_KEY = "INT_KEY";
        private const string BYTE_KEY = "BYTE_KEY";
        private const string STRING_BYTE_KEY = "STRING_BYTE_KEY";
 
        public HomeController(ILogger<HomeController> logger)
        {
            _logger = logger;
        }
 
        public IActionResult Index()
        {
            Byte[] bytes = System.Text.Encoding.UTF8.GetBytes(_textValue);
 
            SessionHelper helper = new SessionHelper(this);
 
            helper.SetStringValue(STRING_KEY, _textValue);
            helper.SetInt32Value(INT_KEY, _intValue);
            helper.SetBytesValue(BYTE_KEY, bytes);
            helper.SetStringAsBytesValue(STRING_BYTE_KEY, _textValue);
 
            var stringResult =helper.GetStringValue(STRING_KEY);
            var intResult =helper.GetInt32Value(INT_KEY);
            var bytesResult = helper.GetBytesValue(BYTE_KEY);
            var byteTextResult = helper.GetStringFromBytesValue(STRING_BYTE_KEY);
 
            return View();
        }
 
        public IActionResult Privacy()
        {
            return View();
        }
 
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}

Come potete notare è davvero semplice utilizzare le sessioni all’interno di una WebApplication NETCore. Quello che apprezzo in particolare è la suddivisione tra string, int32 e Byte [] in modo da evitare una serie di cast inutili almeno sui primi due.

Happy Session Coding!