.NET Core中使用Redis與Memcached的序列化問題詳析

public class Product
{
 public int Id { get; set; }
 public string Name { get; set; }
}

using (var ms = new MemoryStream())
{
 formatter.Serialize(ms, product); 
 db.StringSet("binaryformatter", ms.ToArray(), TimeSpan.FromMinutes(1));
}

var value = db.StringGet("binaryformatter");
using (var ms = new MemoryStream(value))
{
 var desValue = (Product)(new BinaryFormatter().Deserialize(ms));
 Console.WriteLine($"{desValue.Id}-{desValue.Name}");
}

using (var ms = new MemoryStream())
{
 using (var sr = new StreamWriter(ms, Encoding.UTF8))
 using (var jtr = new JsonTextWriter(sr))
 {
 jsonSerializer.Serialize(jtr, product);
 } 
 db.StringSet("json", ms.ToArray(), TimeSpan.FromMinutes(1));
}

var bytes = db.StringGet("json");
using (var ms = new MemoryStream(bytes))
using (var sr = new StreamReader(ms, Encoding.UTF8))
using (var jtr = new JsonTextReader(sr))
{
 var desValue = jsonSerializer.Deserialize<Product>(jtr);
 Console.WriteLine($"{desValue.Id}-{desValue.Name}");
}

var objStr = JsonConvert.SerializeObject(product);
db.StringSet("json", Encoding.UTF8.GetBytes(objStr), TimeSpan.FromMinutes(1));
var resStr = Encoding.UTF8.GetString(db.StringGet("json"));
var res = JsonConvert.DeserializeObject<Product>(resStr);

using (var ms = new MemoryStream())
{
 Serializer.Serialize(ms, product);
 db.StringSet("protobuf", ms.ToArray(), TimeSpan.FromMinutes(1));
}

var value = db.StringGet("protobuf");
using (var ms = new MemoryStream(value))
{
 var desValue = Serializer.Deserialize<Product>(ms); 
 Console.WriteLine($"{desValue.Id}-{desValue.Name}");
}

var serValue = MessagePackSerializer.Serialize(product, ContractlessStandardResolver.Instance);
db.StringSet("messagepack", serValue, TimeSpan.FromMinutes(1));

var value = db.StringGet("messagepack");
var desValue = MessagePackSerializer.Deserialize<Product>(value, ContractlessStandardResolver.Instance);

private static void InitMemcached(string transcoder = "")
{
 IServiceCollection services = new ServiceCollection();
 services.AddEnyimMemcached(options =>
 {
 options.AddServer("127.0.0.1", 11211);
 options.Transcoder = transcoder;
 });
 services.AddLogging();
 IServiceProvider serviceProvider = services.BuildServiceProvider();
 _client = serviceProvider.GetService<IMemcachedClient>() as MemcachedClient;
}

private static void MemcachedTrancode(Product product)
{
 _client.Store(Enyim.Caching.Memcached.StoreMode.Set, "defalut", product, DateTime.Now.AddMinutes(1));

 Console.WriteLine("serialize succeed!");

 var desValue = _client.ExecuteGet<Product>("defalut").Value;

 Console.WriteLine($"{desValue.Id}-{desValue.Name}");
 Console.WriteLine("deserialize succeed!");
}

static void Main(string[] args)
{
 Product product = new Product
 {
 Id = 999,
 Name = "Product999"
 };
 //Bson
 string transcoder = "";
 //BinaryFormatter
 //string transcoder = "BinaryFormatterTranscoder"; 
 InitMemcached(transcoder);
 MemcachedTrancode(product);
 Console.ReadKey();
}

public class MessagePackTranscoder : DefaultTranscoder
{
 protected override ArraySegment<byte> SerializeObject(object value)
 {
 return MessagePackSerializer.SerializeUnsafe(value, TypelessContractlessStandardResolver.Instance);
 }

 public override T Deserialize<T>(CacheItem item)
 {
 return (T)base.Deserialize(item);
 }

 protected override object DeserializeObject(ArraySegment<byte> value)
 {
 return MessagePackSerializer.Deserialize<object>(value, TypelessContractlessStandardResolver.Instance);
 }
}

string transcoder = "CachingSerializer.MessagePackTranscoder,CachingSerializer";

private static void InitMemcached(string transcoder = "")
{
 IServiceCollection services = new ServiceCollection();
 services.AddEnyimMemcached(options =>
 {
 options.AddServer("127.0.0.1", 11211);
 //這里保持空字符串或不賦值，就會走下面的AddSingleton
 //如果這里賦了正確的值，后面的AddSingleton就不會起作用了
 options.Transcoder = transcoder;
 });
 //使用新定義的MessagePackTranscoder
 services.AddSingleton<ITranscoder, MessagePackTranscoder>();
 //others...
}

Install-Package EasyCaching.Redis

public class Startup
{
 //...
 public void ConfigureServices(IServiceCollection services)
 {
 //other services.
 //Important step for Redis Caching 
 services.AddDefaultRedisCache(option=>
 { 
 option.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6379));
 option.Password = "";
 });
 }
}

[Route("api/[controller]")]
public class ValuesController : Controller
{
 private readonly IEasyCachingProvider _provider;
 public ValuesController(IEasyCachingProvider provider)
 {
 this._provider = provider;
 }

 [HttpGet]
 public string Get()
 {
 //Set
 _provider.Set("demo", "123", TimeSpan.FromMinutes(1));
 //Get without data retriever
 var res = _provider.Get<string>("demo");
 _provider.Set("product:1", new Product { Id = 1, Name = "name"}, TimeSpan.FromMinutes(1))

 var product = _provider.Get<Product>("product:1");
 return $"{res.Value}-{product.Value.Id}-{product.Value.Name}"; 
 }
}

public void ConfigureServices(IServiceCollection services)
{
 //others..
 services.AddDefaultMessagePackSerializer();
}

Install-Package EasyCaching.Memcached

public class Startup
{
 //...
 public void ConfigureServices(IServiceCollection services)
 {
 services.AddMvc();
 //Important step for Memcached Cache
 services.AddDefaultMemcached(option=>
 { 
 option.AddServer("127.0.0.1",11211); 
 }); 
 }

 public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 {
 //Important step for Memcache Cache
 app.UseDefaultMemcached(); 
 }
}

public void ConfigureServices(IServiceCollection services)
{
 //others..
 services.AddDefaultMemcached(op=>
 { 
 op.AddServer("127.0.0.1",11211);
 });
 //specify the Transcoder use messagepack serializer.
 services.AddDefaultMessagePackSerializer();
}