解读ASP.NET 5 & MVC6系列教程（8）：Session与Caching
在之前的版本中，Session存在于System.Web中，新版ASP.NET5中由于不在依赖于System.Web.dll库了，所以相应的，Session也就成了ASP.NET5中一个可配置的模块（middleware）了。
配置启用Session
ASP.NET5中的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(newRedisCache(newRedisCacheOptions(){Configuration="localhost"}));
对于UseInMemorySession方法，接收2个可选参数，分别是：IMemoryCache可用于修改Session数据的默认保存地址；Action<SessionOptions>委托则可以让你修改默认选项，比如Sessioncookie的路径、默认的过期时间等。本例中，我们修改默认过期时间为30分钟。
注意：该方法必须在app.UseMvc之前调用，否则在Mvc里获取不到Session，而且会出错。
获取和设置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类型，代码如下：
publicstaticbyte[]Get(thisISessionCollectionsession,stringkey); publicstaticint?GetInt(thisISessionCollectionsession,stringkey); publicstaticstringGetString(thisISessionCollectionsession,stringkey); publicstaticvoidSet(thisISessionCollectionsession,stringkey,byte[]value); publicstaticvoidSetInt(thisISessionCollectionsession,stringkey,intvalue); publicstaticvoidSetString(thisISessionCollectionsession,stringkey,stringvalue);
所以，在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数据进行设置和获取的代码，示例如下：
publicstaticclassSessionExtensions
{
publicstaticbool?GetBoolean(thisISessionCollectionsession,stringkey)
{
vardata=session.Get(key);
if(data==null)
{
returnnull;
}
returnBitConverter.ToBoolean(data,0);
}
publicstaticvoidSetBoolean(thisISessionCollectionsession,stringkey,boolvalue)
{
session.Set(key,BitConverter.GetBytes(value));
}
}
定义bool类型的扩展方法以后，我们就可以像SetInt/GetInt那样进行使用了，示例如下：
Context.Session.SetBoolean("Liar",true);
ViewBag.Liar=Context.Session.GetBoolean("Liar");
另外，ISessionCollection接口上还提供了Remove(stringkey)和Clear()两个方法分别用于删除某个Session值和清空所有的Session值的功能。但同时也需要注意，该接口并没提供之前版本中的Abandon方法功能。
基于Redis的Session管理
使用分布式Session，其主要工作就是将Session保存的地方从原来的内存换到分布式存储上，本节，我们以Redis存储为例来讲解分布式Session的处理。
先查看使用分布式Session的扩展方法，示例如下，我们可以看到，其Session容器需要是一个支持IDistributedCache的接口示例。
publicstaticIApplicationBuilderUseDistributedSession([NotNullAttribute]thisIApplicationBuilderapp,IDistributedCachecache,Action<SessionOptions>configure=null);
该接口是缓存Caching的通用接口，也就是说，只要我们实现了缓存接口，就可以将其用于Session的管理。进一步查看该接口发现，该接口中定义的Set方法还需要实现一个ICacheContext类型的缓存上下文（以便在调用的时候让其它程序进行委托调用），接口定义分别如下：
publicinterfaceIDistributedCache
{
voidConnect();
voidRefresh(stringkey);
voidRemove(stringkey);
StreamSet(stringkey,objectstate,Action<ICacheContext>create);
boolTryGetValue(stringkey,outStreamvalue);
}
publicinterfaceICacheContext
{
StreamData{get;}
stringKey{get;}
objectState{get;}
voidSetAbsoluteExpiration(TimeSpanrelative);
voidSetAbsoluteExpiration(DateTimeOffsetabsolute);
voidSetSlidingExpiration(TimeSpanoffset);
}
接下来，我们基于Redis来实现上述功能，创建RedisCache类，并继承IDistributedCache，引用StackExchange.Redis程序集，然后实现IDistributedCache接口的所有方法和属性，代码如下：
usingMicrosoft.Framework.Cache.Distributed;
usingMicrosoft.Framework.OptionsModel;
usingStackExchange.Redis;
usingSystem;
usingSystem.IO;
namespaceMicrosoft.Framework.Caching.Redis
{
publicclassRedisCache:IDistributedCache
{
//KEYS[1]==key
//ARGV[1]=absolute-expiration-ticksaslong(-1fornone)
//ARGV[2]=sliding-expiration-ticksaslong(-1fornone)
//ARGV[3]=relative-expiration(long,inseconds,-1fornone)-Min(absolute-expiration-Now,sliding-expiration)
//ARGV[4]=data-byte[]
//thisordershouldnotchangeLUAscriptdependsonit
privateconststringSetScript=(@"
redis.call('HMSET',KEYS[1],'absexp',ARGV[1],'sldexp',ARGV[2],'data',ARGV[4])
ifARGV[3]~='-1'then
redis.call('EXPIRE',KEYS[1],ARGV[3])
end
return1");
privateconststringAbsoluteExpirationKey="absexp";
privateconststringSlidingExpirationKey="sldexp";
privateconststringDataKey="data";
privateconstlongNotPresent=-1;
privateConnectionMultiplexer_connection;
privateIDatabase_cache;
privatereadonlyRedisCacheOptions_options;
privatereadonlystring_instance;
publicRedisCache(IOptions<RedisCacheOptions>optionsAccessor)
{
_options=optionsAccessor.Options;
//Thisallowspartitioningasinglebackendcacheforusewithmultipleapps/services.
_instance=_options.InstanceName??string.Empty;
}
publicvoidConnect()
{
if(_connection==null)
{
_connection=ConnectionMultiplexer.Connect(_options.Configuration);
_cache=_connection.GetDatabase();
}
}
publicStreamSet(stringkey,objectstate,Action<ICacheContext>create)
{
Connect();
varcontext=newCacheContext(key){State=state};
create(context);
varvalue=context.GetBytes();
varresult=_cache.ScriptEvaluate(SetScript,newRedisKey[]{_instance+key},
newRedisValue[]
{
context.AbsoluteExpiration?.Ticks??NotPresent,
context.SlidingExpiration?.Ticks??NotPresent,
context.GetExpirationInSeconds()??NotPresent,
value
});
//TODO:Errorhandling
returnnewMemoryStream(value,writable:false);
}
publicboolTryGetValue(stringkey,outStreamvalue)
{
value=GetAndRefresh(key,getData:true);
returnvalue!=null;
}
publicvoidRefresh(stringkey)
{
varignored=GetAndRefresh(key,getData:false);
}
privateStreamGetAndRefresh(stringkey,boolgetData)
{
Connect();
//ThisalsoresetstheLRUstatusasdesired.
//TODO:Canthisbedoneinoneoperationontheserverside?Probably,thetrickwouldjustbetheDateTimeOffsetmath.
RedisValue[]results;
if(getData)
{
results=_cache.HashMemberGet(_instance+key,AbsoluteExpirationKey,SlidingExpirationKey,DataKey);
}
else
{
results=_cache.HashMemberGet(_instance+key,AbsoluteExpirationKey,SlidingExpirationKey);
}
//TODO:Errorhandling
if(results.Length>=2)
{
//Notewealwaysgetbacktworesults,eveniftheyareallnull.
//Theseoperationswillno-opinthenullscenario.
DateTimeOffset?absExpr;
TimeSpan?sldExpr;
MapMetadata(results,outabsExpr,outsldExpr);
Refresh(key,absExpr,sldExpr);
}
if(results.Length>=3&&results[2].HasValue)
{
returnnewMemoryStream(results[2],writable:false);
}
returnnull;
}
privatevoidMapMetadata(RedisValue[]results,outDateTimeOffset?absoluteExpiration,outTimeSpan?slidingExpiration)
{
absoluteExpiration=null;
slidingExpiration=null;
varabsoluteExpirationTicks=(long?)results[0];
if(absoluteExpirationTicks.HasValue&&absoluteExpirationTicks.Value!=NotPresent)
{
absoluteExpiration=newDateTimeOffset(absoluteExpirationTicks.Value,TimeSpan.Zero);
}
varslidingExpirationTicks=(long?)results[1];
if(slidingExpirationTicks.HasValue&&slidingExpirationTicks.Value!=NotPresent)
{
slidingExpiration=newTimeSpan(slidingExpirationTicks.Value);
}
}
privatevoidRefresh(stringkey,DateTimeOffset?absExpr,TimeSpan?sldExpr)
{
//NoteRefreshhasnoeffectifthereisjustanabsoluteexpiration(orneither).
TimeSpan?expr=null;
if(sldExpr.HasValue)
{
if(absExpr.HasValue)
{
varrelExpr=absExpr.Value-DateTimeOffset.Now;
expr=relExpr<=sldExpr.Value?relExpr:sldExpr;
}
else
{
expr=sldExpr;
}
_cache.KeyExpire(_instance+key,expr);
//TODO:Errorhandling
}
}
publicvoidRemove(stringkey)
{
Connect();
_cache.KeyDelete(_instance+key);
//TODO:Errorhandling
}
}
}
在上述代码中，我们使用了自定义类RedisCacheOptions作为Redis的配置信息类，为了实现基于POCO的配置定义，我们还继承了IOptions接口，该类的定义如下：
publicclassRedisCacheOptions:IOptions<RedisCacheOptions>
{
publicstringConfiguration{get;set;}
publicstringInstanceName{get;set;}
RedisCacheOptionsIOptions<RedisCacheOptions>.Options
{
get{returnthis;}
}
RedisCacheOptionsIOptions<RedisCacheOptions>.GetNamedOptions(stringname)
{
returnthis;
}
}
第三部，定义委托调用时使用的缓存上下文类CacheContext，具体代码如下：
usingMicrosoft.Framework.Cache.Distributed;
usingSystem;
usingSystem.IO;
namespaceMicrosoft.Framework.Caching.Redis
{
internalclassCacheContext:ICacheContext
{
privatereadonlyMemoryStream_data=newMemoryStream();
internalCacheContext(stringkey)
{
Key=key;
CreationTime=DateTimeOffset.UtcNow;
}
///<summary>
///Thekeyidentifyingthisentry.
///</summary>
publicstringKey{get;internalset;}
///<summary>
///ThestatepassedintoSet.Thiscanbeusedtoavoidclosures.
///</summary>
publicobjectState{get;internalset;}
publicStreamData{get{return_data;}}
internalDateTimeOffsetCreationTime{get;set;}//可以让委托设置创建时间
internalDateTimeOffset?AbsoluteExpiration{get;privateset;}
internalTimeSpan?SlidingExpiration{get;privateset;}
publicvoidSetAbsoluteExpiration(TimeSpanrelative)//可以让委托设置相对过期时间
{
if(relative<=TimeSpan.Zero)
{
thrownewArgumentOutOfRangeException("relative",relative,"Therelativeexpirationvaluemustbepositive.");
}
AbsoluteExpiration=CreationTime+relative;
}
publicvoidSetAbsoluteExpiration(DateTimeOffsetabsolute)//可以让委托设置绝对过期时间
{
if(absolute<=CreationTime)
{
thrownewArgumentOutOfRangeException("absolute",absolute,"Theabsoluteexpirationvaluemustbeinthefuture.");
}
AbsoluteExpiration=absolute.ToUniversalTime();
}
publicvoidSetSlidingExpiration(TimeSpanoffset)//可以让委托设置offset过期时间
{
if(offset<=TimeSpan.Zero)
{
thrownewArgumentOutOfRangeException("offset",offset,"Theslidingexpirationvaluemustbepositive.");
}
SlidingExpiration=offset;
}
internallong?GetExpirationInSeconds()
{
if(AbsoluteExpiration.HasValue&&SlidingExpiration.HasValue)
{
return(long)Math.Min((AbsoluteExpiration.Value-CreationTime).TotalSeconds,SlidingExpiration.Value.TotalSeconds);
}
elseif(AbsoluteExpiration.HasValue)
{
return(long)(AbsoluteExpiration.Value-CreationTime).TotalSeconds;
}
elseif(SlidingExpiration.HasValue)
{
return(long)SlidingExpiration.Value.TotalSeconds;
}
returnnull;
}
internalbyte[]GetBytes()
{
return_data.ToArray();
}
}
}
最后一步定义，RedisCache中需要的根据key键获取缓存值的快捷方法，代码如下：
usingStackExchange.Redis;
usingSystem;
namespaceMicrosoft.Framework.Caching.Redis
{
internalstaticclassRedisExtensions
{
privateconststringHmGetScript=(@"returnredis.call('HMGET',KEYS[1],unpack(ARGV))");
internalstaticRedisValue[]HashMemberGet(thisIDatabasecache,stringkey,paramsstring[]members)
{
varredisMembers=newRedisValue[members.Length];
for(inti=0;i<members.Length;i++)
{
redisMembers[i]=(RedisValue)members[i];
}
varresult=cache.ScriptEvaluate(HmGetScript,newRedisKey[]{key},redisMembers);
//TODO:Errorchecking?
return(RedisValue[])result;
}
}
}
至此，所有的工作就完成了，将该缓存实现注册为Session的provider的代码方法如下：
app.UseDistributedSession(newRedisCache(newRedisCacheOptions()
{
Configuration="此处填写redis的地址",
InstanceName="此处填写自定义实例名"
}),options=>
{
options.CookieHttpOnly=true;
});
参考：http://www.mikesdotnetting.com/article/270/sessions-in-asp-net-5
关于Caching
默认情况下，本地缓存使用的是IMemoryCache接口的示例，可以通过获取该接口的示例来对本地缓存进行操作，示例代码如下：
varcache=app.ApplicationServices.GetRequiredService<IMemoryCache>();
varobj1=cache.Get("key1");
boolobj2=cache.Get<bool>("key2");
对于，分布式缓存，由于AddCaching，默认将IMemoryCache实例作为分布式缓存的provider了，代码如下：
publicstaticclassCachingServicesExtensions
{
publicstaticIServiceCollectionAddCaching(thisIServiceCollectioncollection)
{
collection.AddOptions();
returncollection.AddTransient<IDistributedCache,LocalCache>()
.AddSingleton<IMemoryCache,MemoryCache>();
}
}
所以，要使用新的分布式Caching实现，我们需要注册自己的实现，代码如下：
services.AddTransient<IDistributedCache,RedisCache>();
services.Configure<RedisCacheOptions>(opt=>
{
opt.Configuration="此处填写redis的地址";
opt.InstanceName="此处填写自定义实例名";
});
基本的使用方法如下：
varcache=app.ApplicationServices.GetRequiredService<IDistributedCache>();
cache.Connect();
varobj1=cache.Get("key1");//该对象是流，需要将其转换为强类型，或自己再编写扩展方法
varbytes=obj1.ReadAllBytes();