ASPを解読する.NET 5&MVC 6シリーズチュートリアル(8):SessionとCaching

以前のバージョンでは、SessionはSystemに存在する.Webでは、新版ASP.NET 5ではSystemに依存することはない.Web.dllライブラリになったので、SessionもASPになりました.NET 5の構成可能なモジュール(middleware)です.
セッションの有効化の設定
ASP.NET 5のSessionモジュールはMicrosoftに存在する.AspNet.SessionクラスライブラリでSessionを有効にするには、まずproject.jsonのdependenciesノードには、次の内容が追加されます.

"Microsoft.AspNet.Session": "1.0.0-beta3"

次に、コンフィギュレーションサービスにセッションの参照を追加します(構成します):

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メソッドでは、IMemoryCacheがSessionデータのデフォルト保存アドレスを変更するために使用できる2つのオプションパラメータが受信される.Action依頼では、セッションクッキーのパス、デフォルトの有効期限など、デフォルトのオプションを変更できます.この例では、デフォルトの有効期限を30分に変更します.
注意:この方法はappでなければならない.UseMvcの前に呼び出されます.そうしないと、MvcでSessionが取得されず、エラーが発生します.
セッションの取得と設定
Sessionオブジェクトの取得および設定は、一般にControllerのactionでthis.Context.Sessionによって取得され、インタフェースISessionCollectionに基づくインスタンスが取得される.このインタフェースはインデックス、Set、TryGetValueなどの方法でSession値の取得と設定を行うことができますが、Sessionの取得と設定ではbyte[]タイプしか使用できず、以前のバージョンのSessionのように任意のタイプのデータを設定することはできません.なぜなら、新しいバージョンのSessionがリモート・サーバへのストレージをサポートするには、シーケンス化をサポートする必要があるため、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を保存するには、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インタフェースには、あるSession値を削除し、すべてのSession値をクリアするためのRemove(string key)とClear()の2つの方法が用意されています.しかし、このインタフェースは、以前のバージョンのAbandonメソッド機能を提供していないことにも注意してください.
Redisベースのセッション管理
分散型セッションを使用して、主な作業はセッションが保存している場所を元のメモリから分散型ストレージに置き換えることです.この節では、Redisストレージを例に分散型セッションの処理について説明します.
分散型Sessionを使用する拡張方法を先に確認します.例は以下のとおりです.SessionコンテナはIDistributedCacheをサポートするインタフェースの例である必要があります.

public static IApplicationBuilder UseDistributedSession([NotNullAttribute]this IApplicationBuilder app, IDistributedCache cache, Action 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 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 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 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
  }
 }
}

上記のコードでは、Redisの構成情報クラスとしてカスタムクラスRedisCacheOptionsを使用しており、POCOベースの構成定義を実現するために、IOptionsインタフェースも継承している.

public class RedisCacheOptions : IOptions
{
 public string Configuration { get; set; }

 public string InstanceName { get; set; }

 RedisCacheOptions IOptions.Options
 {
  get { return this; }
 }

 RedisCacheOptions IOptions.GetNamedOptions(string name)
 {
  return this;
 }
}

第3部では、依頼呼び出し時に使用するキャッシュコンテキストクラス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;
  }

  /// 

  /// The key identifying this entry.
  /// 
  public string Key { get; internal set; }

  /// 

  /// The state passed into Set. This can be used to avoid closures.
  /// 
  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();
var obj1 = cache.Get("key1");
bool obj2 = cache.Get("key2");

分散キャッシュの場合、AddCachingのため、IMemoryCacheインスタンスが分散キャッシュのproviderとしてデフォルトで使用されます.コードは次のとおりです.

public static class CachingServicesExtensions
{
 public static IServiceCollection AddCaching(this IServiceCollection collection)
 {
  collection.AddOptions();
  return collection.AddTransient()
   .AddSingleton();
 }
}

したがって、新しい分散Caching実装を使用するには、以下のコードで独自の実装を登録する必要があります.

services.AddTransient();
services.Configure(opt =>
{
 opt.Configuration = "     redis   ";
 opt.InstanceName = "          ";
});

基本的な使い方は以下の通りです.

var cache = app.ApplicationServices.GetRequiredService();
cache.Connect();
var obj1 = cache.Get("key1"); //     ，          ，          
var bytes = obj1.ReadAllBytes();