private T DoAction <T>(Func <IDatabase, T> func)
{
if (!ConnectRedis())
{
return(default(T));
}
var db = _redis?.GetDatabase();
return(func(db));
}
/// <summary>
/// 清除
/// </summary>
public void Clear()
{
foreach (var endPoint in this.GetRedisConnection().GetEndPoints())
{
var server = this.GetRedisConnection().GetServer(endPoint);
foreach (var key in server.Keys())
{
redisConnection?.GetDatabase().KeyDelete(key);
}
}
}
//[Test]
//public void TestOpCountByVersionLocal_DownLevel()
//{
// using (var conn = Config.GetUnsecuredConnection(open: false))
// {
// conn.SetServerVersion(new Version(2, 6, 0), ServerType.Master);
// TestLockOpCountByVersion(conn, 5, false);
// TestLockOpCountByVersion(conn, 3, true);
// //TestManualLockOpCountByVersion(conn, 5, false);
// //TestManualLockOpCountByVersion(conn, 3, true);
// }
//}
//[Test]
//public void TestOpCountByVersionRemote()
//{
// using (var conn = Config.GetRemoteConnection(open: false))
// {
// TestLockOpCountByVersion(conn, 1, false);
// TestLockOpCountByVersion(conn, 1, true);
// //TestManualLockOpCountByVersion(conn, 1, false);
// //TestManualLockOpCountByVersion(conn, 1, true);
// }
//}
public void TestLockOpCountByVersion(ConnectionMultiplexer conn, int expected, bool existFirst)
{
const int DB = 0, LockDuration = 30;
RedisKey Key = Me();
var db = conn.GetDatabase(DB);
db.KeyDelete(Key);
RedisValue newVal = "us:" + Guid.NewGuid().ToString();
RedisValue expectedVal = newVal;
if (existFirst)
{
expectedVal = "other:" + Guid.NewGuid().ToString();
db.StringSet(Key, expectedVal, TimeSpan.FromSeconds(LockDuration));
}
long countBefore = GetServer(conn).GetCounters().Interactive.OperationCount;
var taken = db.LockTake(Key, newVal, TimeSpan.FromSeconds(LockDuration));
long countAfter = GetServer(conn).GetCounters().Interactive.OperationCount;
var valAfter = db.StringGet(Key);
Assert.AreEqual(!existFirst, taken, "lock taken");
Assert.AreEqual(expectedVal, valAfter, "taker");
Assert.AreEqual(expected, countAfter - countBefore, "expected ops");
// note we get a ping from GetCounters
}
private void Start()
{
_subject.AsObservable()
.Buffer(TimeSpan.FromMilliseconds(1000), 10).Where(l => l.Any())
.ObserveOn(ThreadPoolScheduler.Instance)
.Subscribe(async lst =>
{
if (_client == null)
{
return;
}
try
{
var db = _client?.GetDatabase();
foreach (var data in lst)
{
if (_tokenSource.IsCancellationRequested)
{
break;
}
await db?.PublishAsync(data.Topic, data.Message, CommandFlags.FireAndForget);
}
} catch (Exception)
{
}
}, _tokenSource.Token);
}
/// <summary>
/// 获取 DataBase 对象
/// </summary>
/// <param name="db_num">db_num为-1时，使用UnifiedPayKey.Redis_DB_Num</param>
/// <returns></returns>
private static IDatabase GetDatabase(int db_num)
{
IDatabase db = null;
if (db_num < 0)
{
db_num = SystemKey.Redis_DB_Num;
}
try
{
//db = _client?.GetDatabase(UnifiedPayKey.Redis_DB_Num);
db = _client?.GetDatabase(db_num);
#if DEBUG && RedisError
db = null;
throw new Exception("模拟Redis连接错误，手动抛出异常");
#endif
}
catch (Exception ex)
{
LogHelper.RuntimeLog(new {
ReqId = string.Empty,
flag_type = 4,
target = string.Format("/{0}/{1}", System.Reflection.MethodBase.GetCurrentMethod().ReflectedType.FullName, new System.Diagnostics.StackTrace().GetFrame(0).GetMethod().Name),
LogContent = $"【异常】：【{JSON.Serialize(ex)}】"
});
}
return(db);
}
public static IDatabase GetDatabase(RedisServer srvCfg, int dbIndex = 0)
{
int error = 0;
gotoHere:
ConnectionMultiplexer conn = null;
try
{
conn = GetConnection(srvCfg);
IDatabase db = conn?.GetDatabase();
return(db);
}
catch (Exception ex)
{
if (error < 2)//出错可以重试两次
{
if (conn != null)
{
RedisConnectionManager.Dispose(srvCfg, conn); // conn = null;//把这个链接设置为空，防止第二次还是被取出来
}
error += 1;
System.Threading.Thread.Sleep(1000);
goto gotoHere;
}
Logger?.Log(LogLevel.Error, new Exception("RedisNode.GetDatabase.Error", ex), "", null);
return(null);
}
}
public Controller()
{
var provider = ServiceGet.GetProvider();
_mapper = provider?.GetService <IMapper>();
_conn = provider?.GetService <ConnectionMultiplexer>();
_cache = _conn?.GetDatabase();
}
private void PrepareRedisRestme()
{
try
{
redisConnection = new Lazy <ConnectionMultiplexer>(() =>
{
ConnectionMultiplexer result = null;
var redisConfig =
ConfigurationOptions.Parse(this.ConnectionString);
try
{
result = ConnectionMultiplexer.Connect(redisConfig);
}
catch (Exception ex)
{
LogError(ex.Message, ex);
var endPoints = redisConfig.EndPoints;
foreach (DnsEndPoint endpoint in endPoints)
{
try
{
var port = endpoint.Port;
if (!IsIpAddress(endpoint.Host))
{
IPHostEntry ip = Dns.GetHostEntryAsync(endpoint.Host).WaitAndGetResult(Configuration.DefaultTimeout);
redisConfig.EndPoints.Remove(endpoint);
redisConfig.EndPoints.Add(ip.AddressList.First(), port);
}
result = ConnectionMultiplexer.Connect(redisConfig);
}
catch (Exception innerEx)
{
LogError(innerEx.Message, innerEx);
continue;
}
if (result != null)
{
break;
}
}
}
return(result);
}).Value;
redisDatabase = redisConnection?.GetDatabase();
}
catch (Exception ex)
{
LogError(ex.Message, ex);
throw new PranamDbException("failed to initialize Redis connection:\n" + ex.Message, ex);
}
if (redisConnection?.IsConnected == true)
{
Initialized = true;
}
}
public ShortenUrlCommandHandler(IUrlRepository urlRepository, ILoggerFactory loggerFactory, IMediator mediator, IMapper mapper,
IShortUrlService shortUrlService, ConnectionMultiplexer redis = null)
{
_urlRepository = urlRepository;
_mediator = mediator;
_mapper = mapper;
_shortUrlService = shortUrlService;
_database = redis?.GetDatabase();
_logger = loggerFactory.CreateLogger <ShortenUrlCommandHandler>();
}
public IDatabase GetDatabase(int id = -1)
{
var database = _connectionMultiplexer?.GetDatabase(id) ?? new EmptyRedisDatabase();
return(database);
}
public RedisCache()
{
_connection = ConnectionMultiplexer.Connect(RedisCacheConfiguration.Config.ConnectionString);
_database = _connection.GetDatabase();
}
/// <summary>
/// Redis 缓存策略
/// </summary>
public RedisObjectCacheStrategy()
{
_client = RedisManager.Manager;
_cache = _client.GetDatabase();
}
public void Connect() => _ConnectionMultiplexer = ConnectionMultiplexer.Connect($"{_host}:{_port}"); //Redis ile bağlantı kurulur
public IDatabase GetDb(int db = 1) => _ConnectionMultiplexer.GetDatabase(db); //Database bağlantısını sağlar
public RedisCache(IConfiguration config)
{
_redis = ConnectionMultiplexer.Connect(config.GetSection("Azure:Redis").Value);
_db = _redis.GetDatabase();
}
// This is a separate method for target=DEBUG purposes.
// In release builds, the runtime is smart enough to figure out
// that the contexts are unreachable and should be collected but in
// debug builds... well, it's not very smart.
object LeaksCollectedAndRePooled_Initialize(ConnectionMultiplexer conn, int threadCount)
{
var profiler = new TestProfiler3();
conn.RegisterProfiler(profiler);
var perThreadContexts = new List<object>();
for (var i = 0; i < threadCount; i++)
{
perThreadContexts.Add(new object());
}
var threads = new List<Thread>();
var results = new IEnumerable<IProfiledCommand>[threadCount];
for (var i = 0; i < threadCount; i++)
{
var ix = i;
var thread =
new Thread(
delegate()
{
var ctx = perThreadContexts[ix];
profiler.RegisterContext(ctx);
conn.BeginProfiling(ctx);
var db = conn.GetDatabase(ix);
var allTasks = new List<Task>();
for (var j = 0; j < 1000; j++)
{
allTasks.Add(db.StringGetAsync("hello" + ix));
allTasks.Add(db.StringSetAsync("hello" + ix, "world" + ix));
}
Task.WaitAll(allTasks.ToArray());
// intentionally leaking!
}
);
threads.Add(thread);
}
threads.ForEach(t => t.Start());
threads.ForEach(t => t.Join());
var anyContext = profiler.AnyContext();
profiler.Reset();
return anyContext;
}
public IMemoryStoreClient GetClient()
{
return(new RedisClient(_connectionMultiplexer.GetDatabase(), _loadedZpopminScript));
}
public RedisCartRepository(ConnectionMultiplexer redis)
{
_redis = redis;
_database = _redis.GetDatabase();
}
/// <summary>
/// 获取数据库
/// </summary>
/// <returns></returns>
public IDatabase GetDatabase()
{
return(multiplexer.GetDatabase(DbIndex));
}
private IDatabase GetDatabase()
{
CheckConnectionAndRetryIfDisconnected();
return(_conn?.GetDatabase());
}
protected void Page_Load(object sender, EventArgs e)
{
UserClient user = new UserClient();
string result = user.ShowName("wcf");
Thread.Sleep(20);
Response.Write(result + "</br>");
//mysql数据库查询
MySqlConnection MySqlconn = new MySqlConnection(ConfigurationManager.ConnectionStrings["MySqlConStr"].ConnectionString.ToString());
try
{
MySqlconn.Open();
string MySqlcommand = "select T_Flowers.name as fname, T_Flowers.price as fprice, T_House.hname as hnames from T_Flowers left join T_House on T_Flowers.id = T_House.flowerid where T_House.hname = 'house1'";
MySqlCommand cmd = new MySqlCommand(MySqlcommand, MySqlconn);
Thread.Sleep(20);
MySqlDataReader myreader = cmd.ExecuteReader();
if (myreader.Read())
{
for (int i = 0; i <= 2; i++)
{
Response.Write(myreader[i].ToString() + " ");
}
myreader.Close();
}
}
catch (Exception ex)
{
Response.Write(ex.Message);
}
finally
{
if (MySqlconn != null)
{
MySqlconn.Close();
}
Response.Write("Mysql" + "</br>");
}
//连接数据库 StackExchange.Redis
string conn = ConfigurationManager.AppSettings["redis"].ToString();
Thread.Sleep(20);
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(conn);
//访问数据库 给db赋值
IDatabase db = redis.GetDatabase();
db.StringSet("rr", "StackExchange redisTest");
string value = db.StringGet("rr");
Response.Write(value + "</br>");
db.KeyDelete("rr");
//ServiceStack.Redis
//连接数据库
string conn2 = ConfigurationManager.AppSettings["redis2"].ToString();
RedisClient dbclient = new RedisClient(conn2);
Thread.Sleep(20);
dbclient.Set <string>("ee", "ServiceStack.Redis test");
string ee = dbclient.Get <string>("ee");
Response.Write(ee + "</br>");
dbclient.Set <int>("w22", 23);
dbclient.Get <int>("w22");
dbclient.Del("ee");
dbclient.Del("w22");
}
public Issue898()
{
mux = ConnectionMultiplexer.Connect("127.0.0.1:6379");
db = mux.GetDatabase();
}
//private readonly IConfiguration _configuration;
//public RedisHandler(IConfiguration configuration)
//{
// _configuration = configuration;
// Connection = ConnectionMultiplexer.Connect(_configuration.GetSection("Redis:Url").Value);
// db = Connection.GetDatabase(int.Parse(_configuration.GetSection("Redis:Database").Value));
//}
public RedisHandler()
{
Connection = ConnectionMultiplexer.Connect("localhost:6379");
db = Connection.GetDatabase(1);
}
protected virtual Tuple <IDatabase, RedisKey> GetCacheEntryStorageDetails(string entryKey)
{
return(new Tuple <IDatabase, RedisKey>(
ConnectionMultiplexer.GetDatabase(DbNumber),
KeyPrefix + entryKey));
}
public Maybe <RedisDatabase> GetDatabase(int id = -1)
{
var database = _connectionMultiplexer?.GetDatabase(id);
return(database == null ? null : new RedisDatabase(database));
}
//Below we are injecting the connection for Redis, like we did for Dbcontext(We injected connection strings)
public RedisCartRepository(ConnectionMultiplexer redis) //Injecting connection to the redisserver and storing that
//in private variable _redis
{
_redis = redis;
_database = redis.GetDatabase();//we are asking redis to give a database
}
public CacheService(IDistributedCache distributedCache)
{
_connectionMultiplexer = ConnectionMultiplexer.Connect(AppConfig.GetRedisConnectionString());
_cache = _connectionMultiplexer.GetDatabase();
_distributedCache = distributedCache;
}
public IDatabase GetDatabase()
{
return(_conn.GetDatabase(DbNum));
}
static void Main(string[] args)
{
//[nuget StackExchange.Redis.StrongName]
//ConnectionMultiplexer是线程安全的，且是昂贵的。所以我们应该尽量重用。
ConnectionMultiplexer connectionMultiplexer = ConnectionMultiplexer.Connect(RedisConnection);
for (int i = 0; i < 1000; i++)
{
try
{
var db1 = connectionMultiplexer.GetDatabase();
}
catch (Exception wx)
{
throw;
}
}
var db = connectionMultiplexer.GetDatabase();
//Redis会很快速，所有的东西都在存储器里。但，让Redis闪耀的真正原因是其不同于其它解决方案的特殊数据结构。
//如果key已经拥有一个值，则被覆盖
//http://www.cnblogs.com/yanghua1012/p/5679183.html
//字符串（Strings)
var key = "keystring";
db.StringSet(key, "你好", TimeSpan.FromSeconds(5)); //写入字符串，并指定过期时间。对应reids的setex key 5或者(set key和expire key 5)命令 。
db.StringAppend(key, " world"); //追加值
db.StringIncrement("benny:click"); //储存的数字值增一，对应 incr key 命令
db.StringIncrement("benny:click");
db.StringSet("test", "你好");
db.StringSet("test", "农码一生");//可以覆盖相同key的值
//db.SetAdd("test", "农码一生");//但是不能覆盖不同类型的key的值（这里报错 WRONGTYPE Operation against a key holding the wrong kind of value）
//散列（Hashes）
db.HashSet("users:benny", "name", "农码一生"); // 对应 hset key 命令
db.HashSet("users:benny", "age", "27");
db.HashSet("users:joy", new HashEntry[] { new HashEntry("name", "妹子啊"), new HashEntry("age", "18"), }); //对应于 hmset key
db.HashSet("users:joy", "sex", "女");
//列表（Lists）
db.ListLeftPush("list4", "list41"); //对应 lpush 命令
db.ListLeftPush("list4", "list42");
var ranges = db.ListRange("list4", 0); //获取列表所有值
ranges = db.ListRange("list4", 0, 2); // 获取列表 0 到2 的值，对应 lrange list4 0 2命令
ranges = db.Sort("list4", sortType: SortType.Alphabetic); //排序。对应 sort list4 limit 0 10 desc alpha命令
//集合（Sets）
db.SetAdd("list-a", "张三");//对应 sadd 命令
db.SetAdd("list-a", "李四");
db.SetAdd("list-b", "张三");
db.SetAdd("list-b", new RedisValue[] { "王五", "郑六" });
var hasValue = db.SetContains("list-a", "张三"); //true，对应 sismember 命令
hasValue = db.SetContains("list-a", "王五"); //false
var newSets = db.SetCombine(SetOperation.Union, new RedisKey[] { "list-a", "list-b" }); //并集
newSets = db.SetCombine(SetOperation.Intersect, new RedisKey[] { "list-a", "list-b" }); //交集
newSets = db.SetCombine(SetOperation.Difference, new RedisKey[] { "list-a", "list-b" }); //存在于集合list-a 却不存在于集合list-b中的值
//分类集合（Sorted Sets）
db.SortedSetAdd("list3", "list31", 1);
db.SortedSetAdd("list3", "list33", 3);
db.SortedSetAdd("list3", "list331", 4);
db.SortedSetAdd("list3", "list33.1", 2);
db.SortedSetAdd("list3", "list32", 2);
var redisValues = db.SortedSetRangeByRank("list3", 0, 2, Order.Ascending, CommandFlags.None); //范围
var length = db.SortedSetLength("list3"); //获取长度
var tempLength = db.SortedSetLengthByValue("list3", "list31", "list32"); //获取RedisValue之间的长度
var index = db.SortedSetRank("list3", "list331"); //下标
//db.SortedSetCombineAndStore(SetOperation.Union, "new...", "...", "...");//并集
//db.SortedSetCombineAndStore(SetOperation.Intersect, "new...", "...", "...");//交集
//db.SortedSetCombineAndStore(SetOperation.Difference, "new...", "...", "...");//差异 not in
//bit
db.StringSetBit("bitkey", 0, true);
db.StringSetBit("bitkey", 1, false);
db.StringGetBit("bitkey", 0);
var position = db.StringBitPosition("bitkey", false, 0, 1);
//事务
var tran = db.CreateTransaction(); //创建一个事务
if (db.KeyExists(key)) //判断是否存在key
{
//db.KeyDelete(key, CommandFlags.HighPriority); //删除key
}
Console.WriteLine(db.KeyExists(key));
//....
bool committed = tran.Execute();// 提交执行事务
//Lock(分布式锁)
RedisValue token = Environment.MachineName;
// 秒杀
if (db.LockTake("id", token, TimeSpan.FromSeconds(10)))//10秒自动解锁 【和C#lock最大的区别是，lock会阻塞等待下一个并发。而LockTake不会阻塞，直接运行else】
{
try
{
//Thread.Sleep(5000);
}
finally
{
db.LockRelease("id", token);
}
}
#region 测试
////测试
//for (int i = 1000000; i < 2000000; i++)
//{
// db.StringSet("JsonConvert"+ i, "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）" +
// "ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）ASP.NET Core 快速入门（实战篇）");
//}
#endregion
#region 序列化后存储
Blog blog = new Blog {
Id = 1, Title = "ASP.NET Core 快速入门（实战篇）", Content = "~~~~~~~~~~~~~"
};
//1、JsonConvert[nuget Newtonsoft.Json] 的方式序列化存储
db.StringSet("JsonConvert", JsonConvert.SerializeObject(blog));
blog = JsonConvert.DeserializeObject <Blog>(db.StringGet("JsonConvert"));
//2、BinaryFormatter 的方式序列化存储【注意：被序列化的类要标记特性 [Serializable]】
using (var memoryStream = new MemoryStream())
{
new BinaryFormatter().Serialize(memoryStream, blog);
db.StringSet("BinaryFormatter", memoryStream.ToArray());
}
using (var stream = new MemoryStream(db.StringGet("BinaryFormatter")))
{
blog = (Blog) new BinaryFormatter().Deserialize(stream);
}
//3、[nuget protobuf-net] 的方式序列化存储【注意：被序列化的类要标记特性 [ProtoContract]，字段要标记特性[ProtoMember(1)]】
using (var memoryStream = new MemoryStream())
{
ProtoBuf.Serializer.Serialize(memoryStream, blog);
byte[] byteArray = memoryStream.ToArray();
db.StringSet("ProtoBuf", byteArray);
}
using (var memoryStream = new MemoryStream(db.StringGet("ProtoBuf")))
{
var obj = ProtoBuf.Serializer.Deserialize <Blog>(memoryStream);
}
#endregion
#region 序列化 性能测试
var count = 0;// 80000;
Stopwatch stopwatch = new Stopwatch();
//1、JsonConvert[nuget Newtonsoft.Json] 的方式序列化
stopwatch.Restart();//开始监视代码运行时间
for (int i = 0; i < count; i++)
{
blog.Id = i;
blog.Content = i.ToString();
blog = JsonConvert.DeserializeObject <Blog>(JsonConvert.SerializeObject(blog));
}
stopwatch.Stop(); // 停止监视
Console.WriteLine("Newtonsoft.Json:" + stopwatch.Elapsed.TotalMilliseconds + "毫秒"); //总毫秒数
//2、BinaryFormatter 的方式序列化
stopwatch.Restart();
for (int i = 0; i < count; i++)
{
blog.Id = i;
blog.Content = i.ToString();
using (var stream = new MemoryStream())
{
new BinaryFormatter().Serialize(stream, blog);
blog = (Blog) new BinaryFormatter().Deserialize(new MemoryStream(stream.ToArray()));
}
}
stopwatch.Stop();
Console.WriteLine("BinaryFormatter:" + stopwatch.Elapsed.TotalMilliseconds + "毫秒");//总毫秒数
//3、[nuget protobuf-net] 的方式序列化
stopwatch.Restart();
for (int i = 0; i < count; i++)
{
blog.Id = i;
blog.Content = i.ToString();
using (var memoryStream = new MemoryStream())
{
ProtoBuf.Serializer.Serialize(memoryStream, blog);
byte[] byteArray = memoryStream.ToArray();
var obj = ProtoBuf.Serializer.Deserialize <Blog>(new MemoryStream(byteArray));
}
}
stopwatch.Stop();
Console.WriteLine("ProtoBuf:" + stopwatch.Elapsed.TotalMilliseconds + "毫秒");//总毫秒数
#endregion
Console.ReadKey();
}
public BasketContext(ConnectionMultiplexer redisConnection)
{
_redisConnection = redisConnection;
Redis = redisConnection.GetDatabase();
}
/// <summary>
/// 获取数据库
/// </summary>
/// <returns>数据库</returns>
public static IDatabase GetDatabase(int db = -1, object asyncState = null)
{
return(_Instance.GetDatabase(db, asyncState));
}
public IDatabase GetDb(int db = -1)
{
return(_redis.GetDatabase(db));
}
/// <summary>
/// 根据索引获取 redis database (0-15)
/// </summary>
/// <param name="dbIndex">db 索引</param>
/// <returns>db 对象</returns>
public static RedisDB DB(int dbIndex)
{
return(new RedisDB(_redis.GetDatabase(dbIndex)));
}
private async Task<string> DoStuff(ConnectionMultiplexer conn)
{
var db = conn.GetDatabase();
var timeout = Task.Delay(5000);
var len = db.ListLengthAsync("list");
if (await Task.WhenAny(timeout, len) != len)
{
return "Timeout getting length";
}
if ((await len) == 0)
{
db.ListRightPush("list", "foo", flags: CommandFlags.FireAndForget);
}
var tran = db.CreateTransaction();
var x = tran.ListRightPopLeftPushAsync("list", "list2");
var y = tran.SetAddAsync("set", "bar");
var z = tran.KeyExpireAsync("list2", TimeSpan.FromSeconds(60));
timeout = Task.Delay(5000);
var exec = tran.ExecuteAsync();
// SWAP THESE TWO
bool ok = await Task.WhenAny(exec, timeout) == exec;
//bool ok = true;
if (ok)
{
if (await exec)
{
await Task.WhenAll(x, y, z);
var db2 = conn.GetDatabase();
db2.HashGet("hash", "whatever");
return "ok";
}
else
{
return "Transaction aborted";
}
}
else
{
return "Timeout during exec";
}
}
