• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    解读ASP.NET 5 & MVC6系列教程(8):Session与Caching

    在之前的版本中,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数据的默认保存地址;ActionSessionOptions>委托则可以让你修改默认选项,比如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, ActionSessionOptions> 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, ActionICacheContext> 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(IOptionsRedisCacheOptions> 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, ActionICacheContext> 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 : IOptionsRedisCacheOptions>
    {
     public string Configuration { get; set; }
    
     public string InstanceName { get; set; }
    
     RedisCacheOptions IOptionsRedisCacheOptions>.Options
     {
      get { return this; }
     }
    
     RedisCacheOptions IOptionsRedisCacheOptions>.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.GetRequiredServiceIMemoryCache>();
    var obj1 = cache.Get("key1");
    bool obj2 = cache.Getbool>("key2");

    对于,分布式缓存,由于AddCaching,默认将IMemoryCache实例作为分布式缓存的provider了,代码如下:

    public static class CachingServicesExtensions
    {
     public static IServiceCollection AddCaching(this IServiceCollection collection)
     {
      collection.AddOptions();
      return collection.AddTransientIDistributedCache, LocalCache>()
       .AddSingletonIMemoryCache, MemoryCache>();
     }
    }

    所以,要使用新的分布式Caching实现,我们需要注册自己的实现,代码如下:

    services.AddTransientIDistributedCache, RedisCache>();
    services.ConfigureRedisCacheOptions>(opt =>
    {
     opt.Configuration = "此处填写 redis的地址";
     opt.InstanceName = "此处填写自定义实例名";
    });

    基本的使用方法如下:

    var cache = app.ApplicationServices.GetRequiredServiceIDistributedCache>();
    cache.Connect();
    var obj1 = cache.Get("key1"); //该对象是流,需要将其转换为强类型,或自己再编写扩展方法
    var bytes = obj1.ReadAllBytes();
    您可能感兴趣的文章:
    • 解读ASP.NET 5 & MVC6系列教程(7):依赖注入
    • 解读ASP.NET 5 & MVC6系列教程(9):日志框架
    • 解读ASP.NET 5 & MVC6系列教程(10):Controller与Action
    • 解读ASP.NET 5 & MVC6系列教程(11):Routing路由
    • 解读ASP.NET 5 & MVC6系列教程(12):基于Lamda表达式的强类型Routing实现
    • 解读ASP.NET 5 & MVC6系列教程(13):TagHelper
    • 解读ASP.NET 5 & MVC6系列教程(14):View Component
    • 解读ASP.NET 5 & MVC6系列教程(15):MvcOptions配置
    • 解读ASP.NET 5 & MVC6系列教程(16):自定义View视图文件查找逻辑
    • 解读ASP.NET 5 & MVC6系列教程(17):MVC中的其他新特性
    上一篇:解读ASP.NET 5 & MVC6系列教程(7):依赖注入
    下一篇:解读ASP.NET 5 & MVC6系列教程(9):日志框架
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    解读ASP.NET 5 & MVC6系列教程(8):Session与Caching 解读,ASP.NET,amp,MVC6,系列,