解讀ASP.NET 5 & MVC6系列（8）：Session與Caching
阿新 • • 發佈：2018-12-27
在之前的版本中，Session存在於System.Web中，新版ASP.NET 5中由於不在依賴於System.Web.dll庫了，所以相應的，Session也就成了ASP.NET 5中一個可配置的模組（middleware）了。
配置啟用Session
ASP.NET 5中的Session模組存在於Microsoft.AspNet.Session類庫中，要啟用Session，首先需要在project.json中的dependencies節點中新增如下內容：
"Microsoft.AspNet.Session": "1.0.0-beta3"然後在ConfigureServices中新增Session的引用（並進行配置）：
services.AddCaching(); // 這兩個必須同時新增，因為Session依賴於Caching
services.AddSession();
//services.ConfigureSession(null); 可以在這裡配置，也可以再後面進行配置最後在Configure方法中，開啟使用Session的模式，如果在上面已經配置過了，則可以不再傳入配置資訊，否則還是要像上面的配置資訊一樣，傳入Session的配置資訊，程式碼如下：
app.UseInMemorySession(configure:s => { s.IdleTimeout = TimeSpan.FromMinutes(30); }); //app.UseSession(o => { o.IdleTimeout = TimeSpan.FromSeconds(30); }); //app.UseInMemorySession(null, null); //開啟記憶體Session //app.UseDistributedSession(null, null);//開啟分散式Session，也即持久化Session //app.UseDistributedSession(new RedisCache(new RedisCacheOptions() { Configuration = "localhost" }));
對於UseInMemorySession方法，接收2個可選引數，分別是：IMemoryCache可用於修改Session資料的預設儲存地址；Action<SessionOptions>委託則可以讓你修改預設選項，比如Session cookie的路徑、預設的過期時間等。本例中，我們修改預設過期時間為30分鐘。
注意：該方法必須在app.UseMvc之前呼叫，否則在Mvc裡獲取不到Session，而且會出錯。
獲取和設定Session
獲取和設定Session物件，一般是在Controller的action裡通過this.Context.Session來獲取的，其獲取的是一個基於介面ISessionCollection
byte[]型別。所以我們在儲存Session的時候，需要將其轉換為byte[]才能進行儲存，並且獲取以後要再次將byte[]轉換為自己的原有的型別才行。這種形式太麻煩了，好在微軟在Microsoft.AspNet.Http名稱空間（所屬Microsoft.AspNet.Http.Extensions.dll中）下，為我們添加了幾個擴充套件方法，分別用於設定和儲存byte[]型別、int型別、以及string型別，程式碼如下：
public static byte[] Get(this ISessionCollection session, string key);
public static int? GetInt(this ISessionCollection session, string key);
public static string GetString(this ISessionCollection session, string key);
public static void Set(this ISessionCollection session, string key, byte[] value);
public static void SetInt(this ISessionCollection session, string key, int value);
public static void SetString(this ISessionCollection session, string key, string value);所以，在Controller裡引用Microsoft.AspNet.Http名稱空間以後，我們就可以通過如下程式碼進行Session的設定和獲取了：
Context.Session.SetString("Name", "Mike");
Context.Session.SetInt("Age", 21);
ViewBag.Name = Context.Session.GetString("Name");
ViewBag.Age = Context.Session.GetInt("Age");自定義型別的Session設定和獲取
前面我們說了，要儲存自定義型別的Session，需要將其型別轉換成byte[]陣列才行，在本例中，我們對bool型別的Session資料進行設定和獲取的程式碼，示例如下：
public static class SessionExtensions
{
public static bool? GetBoolean(this ISessionCollection session, string key)
{
var data = session.Get(key);
if (data == null)
{
return null;
}
return BitConverter.ToBoolean(data, 0);
}
public static void SetBoolean(this ISessionCollection session, string key, bool value)
{
session.Set(key, BitConverter.GetBytes(value));
}
}定義bool型別的擴充套件方法以後，我們就可以像SetInt/GetInt那樣進行使用了，示例如下：
Context.Session.SetBoolean("Liar", true);
ViewBag.Liar = Context.Session.GetBoolean("Liar");另外，ISessionCollection介面上還提供了Remove(string key)和Clear()兩個方法分別用於刪除某個Session值和清空所有的Session值的功能。但同時也需要注意，該介面並沒提供之前版本中的Abandon方法功能。
基於Redis的Session管理
使用分散式Session，其主要工作就是將Session儲存的地方從原來的記憶體換到分散式儲存上，本節，我們以Redis儲存為例來講解分散式Session的處理。
先檢視使用分散式Session的擴充套件方法，示例如下，我們可以看到，其Session容器需要是一個支援IDistributedCache的介面示例。
public static IApplicationBuilder UseDistributedSession([NotNullAttribute]this IApplicationBuilder app, IDistributedCache cache, Action<SessionOptions> configure = null);該介面是快取Caching的通用介面，也就是說，只要我們實現了快取介面，就可以將其用於Session的管理。進一步檢視該介面發現，該介面中定義的Set方法還需要實現一個ICacheContext型別的快取上下文（以便在呼叫的時候讓其它程式進行委託呼叫），介面定義分別如下：
public interface IDistributedCache
{
void Connect();
void Refresh(string key);
void Remove(string key);
Stream Set(string key, object state, Action<ICacheContext> create);
bool TryGetValue(string key, out Stream value);
}
public interface ICacheContext
{
Stream Data { get; }
string Key { get; }
object State { get; }
void SetAbsoluteExpiration(TimeSpan relative);
void SetAbsoluteExpiration(DateTimeOffset absolute);
void SetSlidingExpiration(TimeSpan offset);
}接下來，我們基於Redis來實現上述功能，建立RedisCache類，並繼承IDistributedCache，引用StackExchange.Redis程式集，然後實現IDistributedCache介面的所有方法和屬性，程式碼如下：
using Microsoft.Framework.Cache.Distributed;
using Microsoft.Framework.OptionsModel;
using StackExchange.Redis;
using System;
using System.IO;
namespace Microsoft.Framework.Caching.Redis
{
public class RedisCache : IDistributedCache
{
// KEYS[1] = = key
// ARGV[1] = absolute-expiration - ticks as long (-1 for none)
// ARGV[2] = sliding-expiration - ticks as long (-1 for none)
// ARGV[3] = relative-expiration (long, in seconds, -1 for none) - Min(absolute-expiration - Now, sliding-expiration)
// ARGV[4] = data - byte[]
// this order should not change LUA script depends on it
private const string SetScript = (@"
redis.call('HMSET', KEYS[1], 'absexp', ARGV[1], 'sldexp', ARGV[2], 'data', ARGV[4])
if ARGV[3] ~= '-1' then
redis.call('EXPIRE', KEYS[1], ARGV[3])
end
return 1");
private const string AbsoluteExpirationKey = "absexp";
private const string SlidingExpirationKey = "sldexp";
private const string DataKey = "data";
private const long NotPresent = -1;
private ConnectionMultiplexer _connection;
private IDatabase _cache;
private readonly RedisCacheOptions _options;
private readonly string _instance;
public RedisCache(IOptions<RedisCacheOptions> optionsAccessor)
{
_options = optionsAccessor.Options;
// This allows partitioning a single backend cache for use with multiple apps/services.
_instance = _options.InstanceName ?? string.Empty;
}
public void Connect()
{
if (_connection == null)
{
_connection = ConnectionMultiplexer.Connect(_options.Configuration);
_cache = _connection.GetDatabase();
}
}
public Stream Set(string key, object state, Action<ICacheContext> create)
{
Connect();
var context = new CacheContext(key) { State = state };
create(context);
var value = context.GetBytes();
var result = _cache.ScriptEvaluate(SetScript, new RedisKey[] { _instance + key },
new RedisValue[]
{
context.AbsoluteExpiration?.Ticks ?? NotPresent,
context.SlidingExpiration?.Ticks ?? NotPresent,
context.GetExpirationInSeconds() ?? NotPresent,
value
});
// TODO: Error handling
return new MemoryStream(value, writable: false);
}
public bool TryGetValue(string key, out Stream value)
{
value = GetAndRefresh(key, getData: true);
return value != null;
}
public void Refresh(string key)
{
var ignored = GetAndRefresh(key, getData: false);
}
private Stream GetAndRefresh(string key, bool getData)
{
Connect();
// This also resets the LRU status as desired.
// TODO: Can this be done in one operation on the server side? Probably, the trick would just be the DateTimeOffset math.
RedisValue[] results;
if (getData)
{
results = _cache.HashMemberGet(_instance + key, AbsoluteExpirationKey, SlidingExpirationKey, DataKey);
}
else
{
results = _cache.HashMemberGet(_instance + key, AbsoluteExpirationKey, SlidingExpirationKey);
}
// TODO: Error handling
if (results.Length >= 2)
{
// Note we always get back two results, even if they are all null.
// These operations will no-op in the null scenario.
DateTimeOffset? absExpr;
TimeSpan? sldExpr;
MapMetadata(results, out absExpr, out sldExpr);
Refresh(key, absExpr, sldExpr);
}
if (results.Length >= 3 && results[2].HasValue)
{
return new MemoryStream(results[2], writable: false);
}
return null;
}
private void MapMetadata(RedisValue[] results, out DateTimeOffset? absoluteExpiration, out TimeSpan? slidingExpiration)
{
absoluteExpiration = null;
slidingExpiration = null;
var absoluteExpirationTicks = (long?)results[0];
if (absoluteExpirationTicks.HasValue && absoluteExpirationTicks.Value != NotPresent)
{
absoluteExpiration = new DateTimeOffset(absoluteExpirationTicks.Value, TimeSpan.Zero);
}
var slidingExpirationTicks = (long?)results[1];
if (slidingExpirationTicks.HasValue && slidingExpirationTicks.Value != NotPresent)
{
slidingExpiration = new TimeSpan(slidingExpirationTicks.Value);
}
}
private void Refresh(string key, DateTimeOffset? absExpr, TimeSpan? sldExpr)
{
// Note Refresh has no effect if there is just an absolute expiration (or neither).
TimeSpan? expr = null;
if (sldExpr.HasValue)
{
if (absExpr.HasValue)
{
var relExpr = absExpr.Value - DateTimeOffset.Now;
expr = relExpr <= sldExpr.Value ? relExpr : sldExpr;
}
else
{
expr = sldExpr;
}
_cache.KeyExpire(_instance + key, expr);
// TODO: Error handling
}
}
public void Remove(string key)
{
Connect();
_cache.KeyDelete(_instance + key);
// TODO: Error handling
}
}
}在上述程式碼中，我們使用了自定義類RedisCacheOptions作為Redis的配置資訊類，為了實現基於POCO的配置定義，我們還繼承了IOptions介面，該類的定義如下：
public class RedisCacheOptions : IOptions<RedisCacheOptions>
{
public string Configuration { get; set; }
public string InstanceName { get; set; }
RedisCacheOptions IOptions<RedisCacheOptions>.Options
{
get { return this; }
}
RedisCacheOptions IOptions<RedisCacheOptions>.GetNamedOptions(string name)
{
return this;
}
}第三部，定義委託呼叫時使用的快取上下文類CacheContext，具體程式碼如下：
using Microsoft.Framework.Cache.Distributed;
using System;
using System.IO;
namespace Microsoft.Framework.Caching.Redis
{
internal class CacheContext : ICacheContext
{
private readonly MemoryStream _data = new MemoryStream();
internal CacheContext(string key)
{
Key = key;
CreationTime = DateTimeOffset.UtcNow;
}
/// <summary>
/// The key identifying this entry.
/// </summary>
public string Key { get; internal set; }
/// <summary>
/// The state passed into Set. This can be used to avoid closures.
/// </summary>
public object State { get; internal set; }
public Stream Data { get { return _data; } }
internal DateTimeOffset CreationTime { get; set; } // 可以讓委託設定建立時間
internal DateTimeOffset? AbsoluteExpiration { get; private set; }
internal TimeSpan? SlidingExpiration { get; private set; }
public void SetAbsoluteExpiration(TimeSpan relative) // 可以讓委託設定相對過期時間
{
if (relative <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException("relative", relative, "The relative expiration value must be positive.");
}
AbsoluteExpiration = CreationTime + relative;
}
public void SetAbsoluteExpiration(DateTimeOffset absolute) // 可以讓委託設定絕對過期時間
{
if (absolute <= CreationTime)
{
throw new ArgumentOutOfRangeException("absolute", absolute, "The absolute expiration value must be in the future.");
}
AbsoluteExpiration = absolute.ToUniversalTime();
}
public void SetSlidingExpiration(TimeSpan offset) // 可以讓委託設定offset過期時間
{
if (offset <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException("offset", offset, "The sliding expiration value must be positive.");
}
SlidingExpiration = offset;
}
internal long? GetExpirationInSeconds()
{
if (AbsoluteExpiration.HasValue && SlidingExpiration.HasValue)
{
return (long)Math.Min((AbsoluteExpiration.Value - CreationTime).TotalSeconds, SlidingExpiration.Value.TotalSeconds);
}
else if (AbsoluteExpiration.HasValue)
{
return (long)(AbsoluteExpiration.Value - CreationTime).TotalSeconds;
}
else if (SlidingExpiration.HasValue)
{
return (long)SlidingExpiration.Value.TotalSeconds;
}
return null;
}
internal byte[] GetBytes()
{
return _data.ToArray();
}
}
}最後一步定義，RedisCache中需要的根據key鍵獲取快取值的快捷方法，程式碼如下：
using StackExchange.Redis;
using System;
namespace Microsoft.Framework.Caching.Redis
{
internal static class RedisExtensions
{
private const string HmGetScript = (@"return redis.call('HMGET', KEYS[1], unpack(ARGV))");
internal static RedisValue[] HashMemberGet(this IDatabase cache, string key, params string[] members)
{
var redisMembers = new RedisValue[members.Length];
for (int i = 0; i < members.Length; i++)
{
redisMembers[i] = (RedisValue)members[i];
}
var result = cache.ScriptEvaluate(HmGetScript, new RedisKey[] { key }, redisMembers);
// TODO: Error checking?
return (RedisValue[])result;
}
}
}至此，所有的工作就完成了，將該快取實現註冊為Session的provider的程式碼方法如下：
app.UseDistributedSession(new RedisCache(new RedisCacheOptions()
{
Configuration = "此處填寫 redis的地址",
InstanceName = "此處填寫自定義例項名"
}), options =>
{
options.CookieHttpOnly = true;
});參考：http://www.mikesdotnetting.com/article/270/sessions-in-asp-net-5
關於Caching
預設情況下，本地快取使用的是IMemoryCache介面的示例，可以通過獲取該介面的示例來對本地快取進行操作，示例程式碼如下：
var cache = app.ApplicationServices.GetRequiredService<IMemoryCache>();
var obj1 = cache.Get("key1");
bool obj2 = cache.Get<bool>("key2");對於，分散式快取，由於AddCaching，預設將IMemoryCache例項作為分散式快取的provider了，程式碼如下：
public static class CachingServicesExtensions
{
public static IServiceCollection AddCaching(this IServiceCollection collection)
{
collection.AddOptions();
return collection.AddTransient<IDistributedCache, LocalCache>()
.AddSingleton<IMemoryCache, MemoryCache>();
}
}所以，要使用新的分散式Caching實現，我們需要註冊自己的實現，程式碼如下：
services.AddTransient<IDistributedCache, RedisCache>();
services.Configure<RedisCacheOptions>(opt =>
{
opt.Configuration = "此處填寫 redis的地址";
opt.InstanceName = "此處填寫自定義例項名";
});基本的使用方法如下：
var cache = app.ApplicationServices.GetRequiredService<IDistributedCache>();
cache.Connect();
var obj1 = cache.Get("key1"); //該物件是流，需要將其轉換為強型別，或自己再編寫擴充套件方法
var bytes = obj1.ReadAllBytes();