public int?GetImitateID(int characterId) { var possibleId = _db?.StringGet(GetImitateKeyName(characterId)); if (possibleId != null && int.TryParse(possibleId.Value, out int id)) { return(id); } return(null); }
public static void RedisConnectionAndUpload(string connectionString) { var muxer = ConnectionMultiplexer.Connect(configuration: connectionString); conn = muxer.GetDatabase(); muxer.Wait(conn.PingAsync()); List<City> citys = CityDataSource.CityDataSource.GetCitys(); if (conn.StringGet("IsValue").IsNull) { int i = 0; citys.Take(1000).ToList().ForEach(c => { i++; conn.HashSetAsync("Citys:Data:" + c.Id.ToString(), c.ToHashEntries()); List<string> prefix = GetPrefix(c.Name); prefix.Concat(GetPrefix(c.Code)); if (!string.IsNullOrEmpty(c.Name)) conn.SortedSetAdd(key: "CityName", member: c.Name, score: 0); if (!string.IsNullOrEmpty(c.Code)) conn.SortedSetAdd(key: "CityCode", member: c.Code, score: 0); foreach (var p in prefix) { conn.SortedSetAdd("Citys:index:" + p, c.Id, 0); } }); conn.StringSet(key: "IsValue", value: true); } }
public static Dictionary<string,string> RedisConnectionAndUpload(string connectionString) { var dict = new Dictionary<string, string>() ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect(configuration: connectionString); conn = muxer.GetDatabase(); muxer.Wait(conn.PingAsync()); List<City> citys = CityDataSource.CityDataSource.GetCitys(); if (conn.StringGet(key: "IsValue").IsNull) { var oneByone = new Stopwatch(); oneByone.Start(); int i = 0; citys.ToList().ForEach(c => { i++; conn.HashSetAsync("Citys:Data:" + c.Id.ToString(), c.ToHashEntries()); List<string> prefix = GetPrefix(c.Name); prefix.Concat(GetPrefix(c.Code)); if (!string.IsNullOrEmpty(c.Name)) conn.SortedSetAdd(key: "CityName", member: c.Name, score: 0); if (!string.IsNullOrEmpty(c.Code)) conn.SortedSetAdd(key: "CityCode", member: c.Code, score: 0); foreach (var p in prefix) { conn.SortedSetAdd("Citys:index:" + p, c.Id, 0); } }); oneByone.Stop(); dict.Add(key: "OneByOne Elapsed Milliseconds: ", value: oneByone.ElapsedMilliseconds.ToString()); dict.Add(key: "OneByOne Elapsed Seconds: ", value: (oneByone.ElapsedMilliseconds/1000).ToString()); var whole = new Stopwatch(); whole.Start(); conn.StringSet(key: "cityslist", value: Serialize(citys)); whole.Stop(); dict.Add(key: "Whole Elapsed Milliseconds: ", value: whole.ElapsedMilliseconds.ToString()); dict.Add(key: "whole Elapsed Seconds: ", value: (whole.ElapsedMilliseconds / 1000).ToString()); conn.StringSet(key: "IsValue", value: true); } return dict; }
public static int CalculateFibonachiNumberRedisCache(int n, IDatabase cache) { var cacheKey = "fibo-cache" + n; string cachedValue = cache?.StringGet(cacheKey); if (!string.IsNullOrWhiteSpace(cachedValue) && int.TryParse(cachedValue, out int result)) { return(result); } var calculationResult = CalculateFibonachiNumber(n); cache?.StringSet(cacheKey, calculationResult); return(calculationResult); }
/// <summary> /// 获取key缓存String类型数据 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <returns></returns> public T Get <T>(string key) { var result = JsonConvert.DeserializeObject <T>(_database.StringGet(key)); return(result); }
/// <summary> /// 获取单个对象 /// </summary> /// <param name="Key"></param> /// <returns></returns> public string StringGet(string key) { key = AddSysCustomKey(key); return(Database.StringGet(key)); }
public string Select(string key) { return(_db.StringGet(key)); }
private static void _SetAndGetStringCacheValue(IDatabase database) { database.StringSet(StringCacheKey, StringCacheValue); var retrievedValue = database.StringGet(StringCacheKey); Console.WriteLine($"Expected value = {StringCacheValue}, Retrieved value = {retrievedValue}"); }
public string Get([FromQuery] string key) { var value = _database.StringGet(key); return(value); }
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e) { BackgroundWorker bgWorker = sender as BackgroundWorker; string stamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); if (redis.IsConnected) { } else { string content = " redis server is not connected"; this.AppendLog(content + stamp); return; } try { IDatabase db = this.redis.GetDatabase(redisDbIndex); List <RedisKey> keyCollection = new List <RedisKey>(); foreach (string key in list) { keyCollection.Add(key); } RedisKey[] keys = keyCollection.ToArray(); RedisValue[] vals = db.StringGet(keys); foreach (RedisValue rv in vals) { if (!rv.IsNull) { DataValue dv = JsonConvert.DeserializeObject <DataValue>((string)rv); string key = dv.SensorId + "-" + dv.ValueType; if (globalStamp[key] != dv.TimeStamp) { string str = dv.SensorId + " " + dv.TimeStamp + " " + dv.ValueType + " " + dv.Value; this.dataQueue.Enqueue(dv); this.AppendLog(stamp + " " + str); globalStamp[key] = dv.TimeStamp; } else { this.AppendLog(stamp + " " + key + " not updated"); } } } } catch (Exception ex) { using (StreamWriter sw = new StreamWriter(@"ErrLog.txt", true)) { sw.WriteLine(ex.Message + " \r\n" + ex.StackTrace.ToString()); sw.WriteLine("---------------------------------------------------------"); sw.Close(); } } }
public byte[] GetData(string filename) { return(RedisCache.StringGet(filename)); }
public T ReadCache <T>(string key, int dbName) { try { IDatabase db = _redisMultiplexer.GetDatabase(dbName); var data = db.KeyExists(key) == true?Newtonsoft.Json.JsonConvert.DeserializeObject <T>(db.StringGet(key).ToString()) : default(T); return(data); } catch (Exception ex) { LogHelper.Error("ReadCache", ex, key); Console.WriteLine(ex.ToString()); return(default(T)); } }
public string Get(string key) { IDatabase db = redis.GetDatabase(); return(db.StringGet(key)); }
/// <summary> /// 获取 一个简单的字符串键值 /// </summary> /// <param name="key">键</param> /// <returns>值</returns> public RedisValue StringGet(string key) { return(_base.StringGet(key)); }
/// <summary> /// 获取缓存用户票证信息 /// </summary> /// <param name="userid">用户id</param> /// <param name="versions">版本</param> /// <returns></returns> public static string GetSecretKeyCache(this IDatabase readis, string userid, string versions) { return(readis.StringGet("SecretKey_" + userid + versions.Replace(".", ""))); }
/// <summary> /// 获取缓存 /// </summary> public static string GetCache(this IDatabase readis, string key) { return(readis.StringGet(key)); }
//取值 private void button3_Click(object sender, EventArgs e) { this.textBox5.Text = _db.StringGet("test"); }
/// <summary> /// 获取单个key的值 /// </summary> /// <param name="redisKey"></param> /// <param name="expiry"></param> /// <returns></returns> public string StringGet(string redisKey, TimeSpan?expiry = null) { redisKey = AddKeyPrefix(redisKey); return(_db.StringGet(redisKey)); }
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e) { BackgroundWorker bgWorker = sender as BackgroundWorker; string stamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); string str = ""; str += stamp + " "; if (redis.IsConnected) { } else { str += "redis server is not connected"; //lthis.AppendLog(str); return; } Dictionary <RedisKey, RedisValue> pair = new Dictionary <RedisKey, RedisValue>(); //string stamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); try { IDatabase db_raw = this.redis.GetDatabase(0); IDatabase db_result = this.redis.GetDatabase(redisDbIndex); //RedisKey[] keys = list.Keys.Select(key => (RedisKey)key).ToArray(); List <RedisKey> keyCollection = new List <RedisKey>(); foreach (string k in list.Keys) { keyCollection.Add(k); //keyCollection.Add(k + "-005"); //keyCollection.Add(k + "-012"); } RedisKey[] keys = keyCollection.ToArray(); RedisValue[] vals = db_raw.StringGet(keys); Dictionary <string, DataValue> dvs = new Dictionary <string, DataValue>(); foreach (RedisValue rv in vals) { if (!rv.IsNull) { Bgk_Micro_40A_Data dv = JsonConvert.DeserializeObject <Bgk_Micro_40A_Data>((string)rv); string key = dv.SensorId; double temp = ResistanceToTemperature(dv.Value2); BgkStrainConfig ptv = list[key]; if (ptv.Stamp != dv.TimeStamp) { ptv.isUpdated = true; ptv.temperature = temp; ptv.frequency = dv.Value1; ptv.Stamp = dv.TimeStamp; } } } foreach (string key in list.Keys) { //string str = ""; BgkStrainConfig ptv = list[key]; if (ptv.isUpdated) { if (ptv.temperature == 0 || ptv.frequency == 0) { this.AppendLog(stamp + " " + ptv.SensorId + "This Channel is broken"); continue; } string strainNormalKey = ptv.SensorId + "-009"; double strain = CalculateStrain(ptv); DataValue strainDv = new DataValue(); strainDv.SensorId = ptv.SensorId; strainDv.TimeStamp = ptv.Stamp; strainDv.ValueType = "009"; strainDv.Value = strain; string result = JsonConvert.SerializeObject(strainDv); pair[strainNormalKey] = result; strainDv.ValueType = "005"; strainDv.Value = ptv.temperature; string tempKey = ptv.SensorId + "-005"; result = JsonConvert.SerializeObject(strainDv); pair[tempKey] = result; Strain_Data sd = new Strain_Data(); sd.SensorId = ptv.SensorId; sd.TimeStamp = ptv.Stamp; sd.Frequency = ptv.frequency; sd.Strain = strain; sd.Temperature = ptv.temperature; string mq_string = JsonConvert.SerializeObject(sd); RabbitMsg msg = new RabbitMsg(); msg.RouteKey = ptv.SensorId; msg.Body = mq_string; dataQueue.Enqueue(msg); ptv.isUpdated = false; str += ptv.SensorId + "\r\n"; str += "R0: " + ptv.R0.ToString() + " T0: " + ptv.T0 + " G: " + ptv.G + " K: " + ptv.K + "\r\n"; str += "frequency: " + ptv.frequency + " temperature: " + ptv.temperature + "\r\n"; str += "Strain: " + strain.ToString() + "\r\n"; ////lthis.AppendLog(str); if (bgWorker.CancellationPending == true) { if (pair.Count > 0) { db_result.StringSet(pair.ToArray()); pair.Clear(); } e.Cancel = true; break; } } else { //this.AppendLog(stamp + key + "is not updated"); continue; } } if (pair.Count > 0) { db_result.StringSet(pair.ToArray()); pair.Clear(); } //lthis.AppendLog(str); //foreach (string key in list.Keys) //{ // StaticStrainValue ptv = list[key]; // ptv.IsUpdated = false; //} } catch (Exception ex) { this.AppendLog(ex.Message); using (StreamWriter sw = new StreamWriter(@"ErrLog.txt", true)) { sw.WriteLine(stamp + " " + ex.Message + " \r\n" + ex.StackTrace.ToString()); sw.WriteLine("---------------------------------------------------------"); sw.Close(); } } }
public string GetStringValue(string key) { return(_database.StringGet(key)); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { FCnt serverFCnt; string devEUI = req.Query["DevEUI"]; string fCntDown = req.Query["FCntDown"]; string fCntUp = req.Query["FCntUp"]; string gatewayId = req.Query["GatewayId"]; string ABPFcntCacheReset = req.Query["ABPFcntCacheReset"]; int newFCntDown = 0; if (redisCache == null) { lock (typeof(FCntCacheChechk)) { if (redisCache == null) { var config = new ConfigurationBuilder() .SetBasePath(context.FunctionAppDirectory) .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables() .Build(); var redisConnectionString = config.GetConnectionString("RedisConnectionString"); if (string.IsNullOrEmpty(redisConnectionString)) { string errorMsg = "Missing RedisConnectionString in settings"; throw new Exception(errorMsg); } var redis = ConnectionMultiplexer.Connect(redisConnectionString); redisCache = redis.GetDatabase(); } } } if (!string.IsNullOrEmpty(ABPFcntCacheReset)) { redisCache.KeyDelete(devEUI); return((ActionResult) new OkObjectResult(null)); } if (!String.IsNullOrEmpty(devEUI) && !String.IsNullOrEmpty(fCntDown) && !String.IsNullOrEmpty(fCntUp) && !String.IsNullOrEmpty(gatewayId)) { int clientFCntDown = int.Parse(fCntDown); int clientFCntUp = int.Parse(fCntUp); string cacheKey = devEUI; try { if (redisCache.LockTake(cacheKey + "msglock", gatewayId, new TimeSpan(0, 0, 10))) { string cachedFCnt = redisCache.StringGet(cacheKey, CommandFlags.DemandMaster); //we have it cached if (!string.IsNullOrEmpty(cachedFCnt)) { serverFCnt = (FCnt)JsonConvert.DeserializeObject(cachedFCnt, typeof(FCnt)); //it is a new message coming up by the first gateway if (clientFCntUp > serverFCnt.FCntUp) { if (clientFCntDown >= serverFCnt.FCntDown) { newFCntDown = (int)(clientFCntDown + 1); } else { newFCntDown = (int)(serverFCnt.FCntDown + 1); } serverFCnt.FCntUp = clientFCntUp; serverFCnt.FCntDown = newFCntDown; serverFCnt.GatewayId = gatewayId; CacheFcnt(serverFCnt, redisCache, cacheKey); } //it is a retry message coming up by the same first gateway else if (clientFCntUp == serverFCnt.FCntUp && gatewayId == serverFCnt.GatewayId) { newFCntDown = serverFCnt.FCntDown + 1; serverFCnt.FCntDown = newFCntDown; CacheFcnt(serverFCnt, redisCache, cacheKey); } else { //we tell not to send any ack or downstream msg newFCntDown = 0; } } //it is the first message from this device else { newFCntDown = clientFCntDown + 1; serverFCnt = new FCnt(); serverFCnt.FCntDown = newFCntDown; serverFCnt.FCntUp = clientFCntUp; serverFCnt.GatewayId = gatewayId; CacheFcnt(serverFCnt, redisCache, cacheKey); } } } finally { redisCache.LockRelease(cacheKey + "msglock", gatewayId); } } else { string errorMsg = "Missing DevEUI or FCntDown or FCntUp or GatewayId"; throw new Exception(errorMsg); } return((ActionResult) new OkObjectResult(newFCntDown)); }
/// <summary> /// Get a value that is associated with a key from the Redis cache /// </summary> /// <param name="key">the key to attempt to get</param> /// <returns>null: if the key does not exist in the database, string if it does</returns> public string get(string key) { // get and return return(db.StringGet(key)); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { //ABP Case string devAddr = req.Query["DevAddr"]; //OTAA Case string devEUI = req.Query["DevEUI"]; string devNonce = req.Query["DevNonce"]; string gatewayId = req.Query["GatewayId"]; if (redisCache == null || registryManager == null) { lock (typeof(FCntCacheChechk)) { if (redisCache == null || registryManager == null) { var config = new ConfigurationBuilder() .SetBasePath(context.FunctionAppDirectory) .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables() .Build(); string connectionString = config.GetConnectionString("IoTHubConnectionString"); if (connectionString == null) { string errorMsg = "Missing IoTHubConnectionString in settings"; throw new Exception(errorMsg); } string redisConnectionString = config.GetConnectionString("RedisConnectionString"); if (redisConnectionString == null) { string errorMsg = "Missing RedisConnectionString in settings"; throw new Exception(errorMsg); } registryManager = RegistryManager.CreateFromConnectionString(connectionString); var redis = ConnectionMultiplexer.Connect(redisConnectionString); redisCache = redis.GetDatabase(); } } } List <IoTHubDeviceInfo> results = new List <IoTHubDeviceInfo>(); //OTAA join if (devEUI != null) { string cacheKey = devEUI + devNonce; try { if (redisCache.LockTake(cacheKey + "joinlock", gatewayId, new TimeSpan(0, 0, 10))) { //check if we already got the same devEUI and devNonce it can be a reaply attack or a multigateway setup recieving the same join.We are rfusing all other than the first one. string cachedDevNonce = redisCache.StringGet(cacheKey, CommandFlags.DemandMaster); if (!String.IsNullOrEmpty(cachedDevNonce)) { return((ActionResult) new BadRequestObjectResult("UsedDevNonce")); } redisCache.StringSet(cacheKey, devNonce, new TimeSpan(0, 1, 0), When.Always, CommandFlags.DemandMaster); IoTHubDeviceInfo iotHubDeviceInfo = new IoTHubDeviceInfo(); var device = await registryManager.GetDeviceAsync(devEUI); if (device != null) { iotHubDeviceInfo.DevEUI = devEUI; iotHubDeviceInfo.PrimaryKey = device.Authentication.SymmetricKey.PrimaryKey; results.Add(iotHubDeviceInfo); //clear device FCnt cache after join redisCache.KeyDelete(devEUI); } } } finally { redisCache.LockRelease(cacheKey + "joinlock", gatewayId); } } //ABP or normal message else if (devAddr != null) { //TODO check for sql injection devAddr = devAddr.Replace('\'', ' '); var query = registryManager.CreateQuery($"SELECT * FROM devices WHERE properties.desired.DevAddr = '{devAddr}' OR properties.reported.DevAddr ='{devAddr}'", 100); while (query.HasMoreResults) { var page = await query.GetNextAsTwinAsync(); foreach (var twin in page) { if (twin.DeviceId != null) { IoTHubDeviceInfo iotHubDeviceInfo = new IoTHubDeviceInfo(); iotHubDeviceInfo.DevAddr = devAddr; var device = await registryManager.GetDeviceAsync(twin.DeviceId); iotHubDeviceInfo.DevEUI = twin.DeviceId; iotHubDeviceInfo.PrimaryKey = device.Authentication.SymmetricKey.PrimaryKey; results.Add(iotHubDeviceInfo); break; } } } } else { string errorMsg = "Missing devEUI or devAddr"; throw new Exception(errorMsg); } string json = JsonConvert.SerializeObject(results); return((ActionResult) new OkObjectResult(json)); }
public virtual T GetValue <T>(string key) { return(JsonConvert.DeserializeObject <T>(_db.StringGet(key))); }
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 string GetCache(string key) { return(_cache.StringGet(key).ToString()); }
private string StringGetInternal(string key, CommandFlags flags = default) { var result = _database.StringGet(GetKeyName(key), flags); return(GetDecompressedString(result)); }
public static Action <RedisChannel, RedisValue> TransactionProcessHandler(ILogger logger, IDatabase redis) { return((channel, message) => { logger.Here().Information("BGN"); byte[] bytes = message; TransactionProcessed transaction = TransactionProcessed.Parser.ParseFrom(bytes); RedisValue transactionId = redis.StringGet(transaction.TransactionId); if (transactionId.HasValue) { return; } redis.StringSet(transaction.TransactionId, "1", TimeSpan.FromMinutes(EXPIRATION_MINUTES)); logger.Here().Information("Updating Quote"); CacheData data = Cache.Get(redis, transaction.Ticker); Quote quote = new Quote(); bool isNewer = (data == null || transaction.CreatedTimestamp > data.Timestamp); quote.Bid = isNewer ? transaction.Level2.Bids[0].Price : data.Quote.Bid; quote.Ask = isNewer ? transaction.Level2.Asks[0].Price : data.Quote.Ask; quote.Last = isNewer ? transaction.Last : data.Quote.Last; quote.Volume = (data == null ? 0 : data.Quote.Volume) + transaction.Volume; Cache.Set(redis, transaction.Ticker, new CacheData(isNewer ? transaction.CreatedTimestamp : data.Timestamp, quote, isNewer ? transaction.Level2 : data.Level2)); logger.Here().Information("Updating HistoricPrice 10 seconds"); String key = Constants.Redis.HISTORIC_PRICE + PriceType.TenSeconds + "_" + transaction.Ticker; RedisValue secondPrice = redis.StringGet(key); if (secondPrice.HasValue) { byte[] secondPriceBytes = (RedisValue)secondPrice; HistoricalPrice current = HistoricalPrice.Parser.ParseFrom(secondPriceBytes); if ((current.Timestamp + (10 * TimeSpan.TicksPerSecond)) > transaction.CreatedTimestamp) { current.Close = transaction.Last; if (transaction.Last > current.High) { current.High = transaction.Last; } if (transaction.Last < current.Low) { current.Low = transaction.Last; } current.Volume += transaction.Volume; redis.StringSet(key, current.ToByteArray()); } else { redis.StringSet(key, new HistoricalPrice() { Timestamp = ToTop10Second(transaction.CreatedTimestamp), Open = transaction.Last, Close = transaction.Last, High = transaction.Last, Low = transaction.Last, Volume = transaction.Volume }.ToByteArray()); } } else { redis.StringSet(key, new HistoricalPrice() { Timestamp = ToTop10Second(transaction.CreatedTimestamp), Open = transaction.Last, Close = transaction.Last, High = transaction.Last, Low = transaction.Last, Volume = transaction.Volume }.ToByteArray()); } logger.Here().Information("END"); }); }
public Data ReadFromCache(string id) { Data d = Newtonsoft.Json.JsonConvert.DeserializeObject <Data>(cachingDB.StringGet(id.ToString())); return(d); }
public string Get(string key) { return(database.StringGet(key)); }
/// <summary> /// Get /// </summary> /// <param name="key">key</param> /// <param name="dbIndex">(optional) index, default <c>RedisDefaultDb</c></param> /// <returns>value</returns> public string Get(string key, int dbIndex = RedisDefaultDb) { IDatabase db = this._redisConnectMultiplexer.GetDatabase(dbIndex); return(db.StringGet(key)); }
private void SyncGeneration(IDatabase db) { var generationKey = CacheNamespace.GetGenerationKey(); var serverGenerationValue = db.StringGet(generationKey); var serverGeneration = Convert.ToInt64(serverGenerationValue); var currentGeneration = CacheNamespace.GetGeneration(); // Generation was cleared by someone else (shouldn't happen). if (serverGenerationValue.IsNullOrEmpty) { db.StringSetAsync( key: generationKey, value: currentGeneration, // Only set if someone else doesn't jump in and set it first. when: When.NotExists, flags: CommandFlags.FireAndForget ); log.InfoFormat("setting server generation ({0}) because it is empty", currentGeneration); } // Generation was lowered by someone else (shouldn't happen). else if (serverGeneration < CacheNamespace.GetGeneration()) { var transaction = db.CreateTransaction(); // Only set if someone else doesn't jump in and set it first. transaction.AddCondition(Condition.StringEqual(generationKey, serverGeneration)); transaction.StringSetAsync( key: generationKey, value: CacheNamespace.GetGeneration(), flags: CommandFlags.FireAndForget ); // We don't need to worry about the result because we will // already retry if we can't sync the generation. transaction.ExecuteAsync(CommandFlags.FireAndForget); log.InfoFormat("syncing server generation (server={0}, current={1})", serverGeneration, currentGeneration); } else { CacheNamespace.SetHigherGeneration(serverGeneration); log.InfoFormat("syncing server generation (server={0}, current={1})", serverGeneration, currentGeneration); } }
private static void TestConcurrent(IDatabase db, RedisKey key, int SyncLoop, int Threads) { long value; db.KeyDelete(key, CommandFlags.FireAndForget); var time = RunConcurrent(delegate { for (int i = 0; i < SyncLoop; i++) { db.StringIncrement(key); } }, Threads, timeout: 45000); value = (long)db.StringGet(key); Assert.AreEqual(SyncLoop * Threads, value); Console.WriteLine("Sync: {0} INCR using {1} threads, {2:###,##0}ms, {3} ops/s; final value: {4}", SyncLoop * Threads, Threads, (long)time.TotalMilliseconds, (long)((SyncLoop * Threads) / time.TotalSeconds), value); }
public static RedisSessionStateStore Get(IDatabase database, string id) { var json = database.StringGet(id); int timeout; try { var jobject = JObject.Parse(json); timeout = jobject.Value<int>("Timeout"); } catch (Exception) { timeout = 20; } return new RedisSessionStateStore(database, id, TimeSpan.FromMinutes(timeout), GetHashKey(id)); }
public string GetString([FromQuery] string key) { return(_database.StringGet(key)); }
/// <summary> /// Gets the game state from the database based on the gameID. /// </summary> /// <param name="gameID">The game's ID.</param> /// <returns>The current state of the game.</returns> public string GetGameState(string gameID) { return(db.StringGet(gameID)); }
private void LoopTask(IDatabase db) { int idx = 1; while (true) { string loopMsg = string.Format("GET#{0} for key '{1}'...", idx, testKey); WriteConnectionMsg(loopMsg); bool callSuccess = false; try { fileStreamWriter.WriteLine(DateTime.Now.ToString("HH:mm:ss.ffff") + " " + loopMsg + "..."); RedisValue redisValue = db.StringGet(testKey); callSuccess = !redisValue.IsNullOrEmpty && redisValue == testValue; } catch (Exception e) { fileStreamWriter.WriteLine(DateTime.Now.ToString("HH:mm:ss.ffff") + " " + loopMsg + " failed on error: " + e.Message); } WriteConnectionMsg(loopMsg + " " + GetResultString(callSuccess)); if (stopEvent.WaitOne(1)) { WriteConnectionMsg(string.Format("LoopTask was cancelled on {0} loop (before delay).", idx)); break; } Thread.Sleep(1000); if (stopEvent.WaitOne(1)) { WriteConnectionMsg(string.Format("LoopTask was cancelled on {0} loop (after delay).", idx)); break; } idx++; } }
private void ensureRedis(IDatabase db) { db.StringSet("testkey", "testvalue"); byte[] value = db.StringGet("testkey"); Console.WriteLine("got from redis: %s", value); }
private void GradeButton_Click(object sender, EventArgs e) { _redis = ConnectionMultiplexer.Connect(_redisHost); if (_redis == null) return; _db = _redis.GetDatabase(); if (_db == null) return; RedisValue capturedRv= _db.StringGet(Constants.REDIS_KEY_CAPTURED_DATA); RedisValue origRv = _db.StringGet(Constants.REDIS_KEY_OIRG_DATA); string[] capturedDataArr = capturedRv.ToString() .Split(Constants.REDIS_SEPERATE_SYMBOL.ToCharArray(), StringSplitOptions.RemoveEmptyEntries); string[] origDataArr = origRv.ToString() .Split(Constants.REDIS_SEPERATE_SYMBOL.ToCharArray(), StringSplitOptions.RemoveEmptyEntries); /* using (FileStream fs = new FileStream("d:\\temp\\Orig.data", FileMode.OpenOrCreate)) { byte[] data = new UTF8Encoding().GetBytes(origRv); fs.Write(data, 0, data.Length); fs.Flush(); fs.Close(); } using (FileStream fs = new FileStream("d:\\temp\\Capt.data", FileMode.OpenOrCreate)) { byte[] data = new UTF8Encoding().GetBytes(capturedRv); fs.Write(data, 0, data.Length); fs.Flush(); fs.Close(); } */ var settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }; MotionData[] capturedData = new MotionData[capturedDataArr.Length]; int capturedCounter = 0; foreach (var str in capturedDataArr) { capturedData[capturedCounter] = JsonConvert.DeserializeObject<MotionData>(str, settings); capturedCounter++; } MotionData[] origData = new MotionData[origDataArr.Length]; int origCounter = 0; foreach (var str in origDataArr) { origData[origCounter] = JsonConvert.DeserializeObject<MotionData>(str, settings); origCounter++; } double score = Constants.MAX_SCORE - ProcessVideo.CalculateScore(capturedData, origData); ScoreLabel.Text = "得分: " + score.ToString(); //Clear db _db.StringSet(Constants.REDIS_KEY_CAPTURED_DATA, ""); _db.StringSet(Constants.REDIS_KEY_OIRG_DATA, ""); }
private static void _AppendToCacheValue(IDatabase database) { const string appendString = " appended"; database.StringAppend(StringCacheValue, appendString); var retrievedValue = database.StringGet(StringCacheKey); var expected = $"{StringCacheKey}{appendString}"; Console.WriteLine($"AppendToCacheValue: Expected = {expected}, Actual = {retrievedValue}"); }