本文转自:http://www.cnblogs.com/TomXu/p/4496445.html

在之前的版本中,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的实例。该接口可以通过索引、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设置和获取

前面我们说了,要保存自定义类型的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();

同步与推荐

本文已同步至目录索引:解读ASP.NET 5 & MVC6系列

[转]解读ASP.NET 5 & MVC6系列(8):Session与Caching的更多相关文章

  1. 解读ASP.NET 5 & MVC6系列(17):MVC中的其他新特性

    (GlobalImport全局导入功能) 默认新建立的MVC程序中,在Views目录下,新增加了一个_GlobalImport.cshtml文件和_ViewStart.cshtml平级,该文件的功能类 ...

  2. 解读ASP.NET 5 & MVC6系列(16):自定义View视图文件查找逻辑

    之前MVC5和之前的版本中,我们要想对View文件的路径进行控制的话,则必须要对IViewEngine接口的FindPartialView或FindView方法进行重写,所有的视图引擎都继承于该IVi ...

  3. 解读ASP.NET 5 & MVC6系列(15):MvcOptions配置

    程序模型处理 IApplicationModelConvention 在MvcOptions的实例对象上,有一个ApplicationModelConventions属性(类型是:List<IA ...

  4. 解读ASP.NET 5 & MVC6系列(14):View Component

    在之前的MVC中,我们经常需要类似一种小部件的功能,通常我们都是使用Partial View来实现,因为MVC中没有类似Web Forms中的WebControl的功能.但在MVC6中,这一功能得到了 ...

  5. 解读ASP.NET 5 & MVC6系列(13):TagHelper

    在新版的MVC6中,微软提供了强大的TagHelper功能,以便让我们摆脱如下的臃肿代码: @Html.LabelFor(model => model.FullName) @Html.EditF ...

  6. 解读ASP.NET 5 & MVC6系列(12):基于Lamda表达式的强类型Routing实现

    前面的深入理解Routing章节,我们讲到了在MVC中,除了使用默认的ASP.NET 5的路由注册方式,还可以使用基于Attribute的特性(Route和HttpXXX系列方法)来定义.本章,我们将 ...

  7. 解读ASP.NET 5 & MVC6系列(11):Routing路由

    新版Routing功能介绍 在ASP.NET 5和MVC6中,Routing功能被全部重写了,虽然用法有些类似,但和之前的Routing原理完全不太一样了,该Routing框架不仅可以支持MVC和We ...

  8. 解读ASP.NET 5 & MVC6系列(10):Controller与Action

    我们知道在MVC5和之前的版本,两个框架的生命周期是不一样的,在新版MVC6中,MVC Controller/Web API Controller已经合二为一了,本章我们主要讲解Controller和 ...

  9. 解读ASP.NET 5 & MVC6系列(9):日志框架

    框架介绍 在之前的.NET中,微软还没有提供过像样的日志框架,目前能用的一些框架比如Log4Net.NLog.CommonLogging使用起来多多少少都有些费劲,和java的SLF4J根本无法相比. ...

  10. 解读ASP.NET 5 & MVC6系列(8):Session与Caching

    在之前的版本中,Session存在于System.Web中,新版ASP.NET 5中由于不在依赖于System.Web.dll库了,所以相应的,Session也就成了ASP.NET 5中一个可配置的模 ...

随机推荐

  1. ecliplse集成SVN

    按照下图操作 : SVN不同版本下载链接在文章底部有提供 上图点击add之后稍等一会就会弹出下图: 上图点击next之后: 最后等待完成之后重启ecliplse即可 重启ecliplse之后显示SVN ...

  2. Kafka,Mq,Redis作为消息队列有何差异?

    Kafka作为新一代的消息系统,mq是比较成熟消息系统,而redis也可以发布订阅,那么这三者有何异同? RabbitMQ 是使用Erlang编写的一个开源的消息队列,本身支持很多的协议:AMQP,X ...

  3. shell-001:记录每天的磁盘情况

    # shell-100只是为了练习!!适合新手! #!/bin/bash # 此脚本是记录每天的磁盘情况,记录保存30天! # 当前的日期 current_time=$(date +%F) # 保存的 ...

  4. redis持久化以及集群

    redis提供了两种持久化策略:RDB与AOF RDB RDB的持久化策略: 按照规则定时将内存的数据同步到磁盘 snapshot(按照快照方式完成,当条件符合redis某一种规则,将内存数据写入磁盘 ...

  5. linux的目录和基本的操作命令

    目录相关操作:( ctrl+l   清空当前的屏幕中的命令  ) 一:目录说明: .   当前目录..   上一层目录-   前一个工作目录~   当前[用户]所在的家目录 蓝色的文件: 都是目录 白 ...

  6. [一首诗] Life and Death 生与死

    Life and Death 生与死 I strove with none, 我和谁都不争, for none was worth my strife, 和谁争我都不屑: Nature I loved ...

  7. ZOJ - 1108 输出DP方案

    DP方程太水不解释 熟悉一下输出的套路 #include<iostream> #include<algorithm> #include<cstdio> #inclu ...

  8. java语言的各种输入情况-ACM

    1.只输入一组数据: Scanner s=new Scanner(System.in);int a=s.nextInt();int b=s.nextInt(); 2.输入有多组数据,没有说明输入几组数 ...

  9. poj1318 Word Amalgamation 字符串排序(qsort)

    Word Amalgamation Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 9794   Accepted: 4701 ...

  10. B/S和C/S架构简单理解

    B/S和C/S架构简单理解 B/S结构.C/S结构 B(browser浏览器)-S(server服务器),说简单点就是通过浏览器来请求服务器,实现数据交互.那自然了,C(client客户端软件)-S( ...