Example #1
0
        public async Task <ActionResult> Update([FromBody] RedisKeyValue item)
        {
            if (!ModelState.IsValid)
            {
                return(new BadRequestObjectResult(ModelState));
            }
            try
            {
                if (await DsRedis.ItemExistsAsync(item.key))
                {
                    int.TryParse(item.key_expire, out var ttl);
                    if (ttl > 0)
                    {
                        await DsRedis.ItemSetAsync(item.key, item.value, ttl);
                    }
                    else
                    {
                        await DsRedis.ItemSetAsync(item.key, item.value);
                    }

                    return(new OkResult());
                }

                return(new NotFoundResult());
            }
            catch (Exception e)
            {
                return(new StatusCodeResult(500));
            }
        }
Example #2
0
        public string Get(string cookie)
        {
            IDatabase db = redisCon.GetDatabase();

            RedisKeyValue pair = new RedisKeyValue();

            string val = db.StringGet(cookie);

            pair.Value = val;

            return(pair.Value);
        }
Example #3
0
        //public string Get(string key)
        //{
        //    IDatabase db = redisCon.GetDatabase();

        //    RedisKeyValue pair = new RedisKeyValue();

        //    string val = db.StringGet(key);
        //    pair.Key = key;
        //    pair.Value = val;

        //    return pair.Value;
        //}

        public string SetToken(int value)
        {
            RedisKeyValue pair = new RedisKeyValue();

            Guid token = Guid.NewGuid();

            pair.Key   = token.ToString();
            pair.Value = value.ToString();

            IDatabase db = redisCon.GetDatabase();

            db.StringSet(pair.Key, pair.Value);

            return(pair.Key);
        }
        private async Task StringSetAsync(RedisKeyValue redisKeyValue, AwaitOptions awaitOptions,
                                          CancellationToken cancellationToken)
        {
            await RunWithTimeout(async token =>
            {
                var command = RedisCommand.From(Commands.Set, redisKeyValue.Key.ToRedisEncoded(),
                                                redisKeyValue.Value.ToRedisEncoded());
                var task = SendOrQueueAsync(command, SuccessResultProcessor, token);

                if (awaitOptions == AwaitOptions.AwaitCompletion)
                {
                    await task;
                }
            }, cancellationToken).ConfigureAwait(false);
        }
Example #5
0
        private async Task StringSetAsync(RedisKeyValue redisKeyValue, AwaitOptions awaitOptions,
                                          CancellationToken cancellationToken)
        {
            //CollateMultipleRequestsForPipelining(new Tuple<string, string>(key, value), _stringSetQueue);

            await RunWithTimeout(async token =>
            {
                var command = RedisCommand.From(Commands.Set, redisKeyValue.Key.ToRedisEncoded(),
                                                redisKeyValue.Value.ToRedisEncoded());
                var task = SendAndReceiveAsync(command, SuccessResultProcessor, token);

                if (awaitOptions == AwaitOptions.AwaitCompletion)
                {
                    await task;
                }
            }, cancellationToken).ConfigureAwait(false);
        }
Example #6
0
 private Task StringSetAsync(RedisKeyValue redisKeyValue, AwaitOptions awaitOptions)
 {
     return(StringSetAsync(redisKeyValue, awaitOptions, CancellationToken.None));
 }
Example #7
0
 private Task StringSetAsync(RedisKeyValue redisKeyValue, int timeToLiveInSeconds, AwaitOptions awaitOptions)
 {
     return(StringSetAsync(redisKeyValue, timeToLiveInSeconds, awaitOptions, CancellationToken.None));
 }
Example #8
0
 internal Session()
 {
     redis = new RedisKeyValue();
 }