C# IRedisClient.SetEntryInHash方法代码示例

        protected void LoadDifferentKeyTypes(IRedisClient redis)
        {
            int A = 'A';
            int Z = 'Z';
            var letters = (Z - A + 1).Times(i => ((char)(i + A)).ToString());
            var numbers = new[] { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };

            redis.RemoveEntry("list:letters", "list:numbers"); //don't add duplicates to existing list
            letters.Each(x => redis.AddItemToList("list:letters", x));
            numbers.Each(x => redis.AddItemToList("list:numbers", x));

            letters.Each(x => redis.AddItemToSet("set:letters", x));
            numbers.Each(x => redis.AddItemToSet("set:numbers", x));

            var pos = 0;
            letters.Each(x => redis.AddItemToSortedSet("zset:letters", x, pos++));
            pos = 0;
            numbers.Each(x => redis.AddItemToSortedSet("zset:numbers", x, pos++));

            pos = 0;
            letters.Each(x => redis.SetEntryInHash("hash:letters", x, (pos++).ToString()));
            pos = 0;
            numbers.Each(x => redis.SetEntryInHash("hash:numbers", x, (pos++).ToString()));
        }

        private bool RequeueJobIfTimedOut(IRedisClient redis, string jobId, string queue)
        {
            var flags = redis.GetValuesFromHash(
                String.Format("hangfire:job:{0}", jobId),
                "Fetched",
                "Checked");

            var fetched = flags[0];
            var @checked = flags[1];

            if (String.IsNullOrEmpty(fetched) && String.IsNullOrEmpty(@checked))
            {
                // If the job does not have these flags set, then it is
                // in the implicit 'Fetched' state. This state has no 
                // information about the time it was fetched. So we
                // can not do anything with the job in this state, because
                // there are two options:

                // 1. It is going to move to the implicit 'Fetched' state
                //    in a short time.
                // 2. It will stay in the 'Fetched' state forever due to
                //    its processing server is dead.

                // To ensure its server is dead, we'll move the job to
                // the implicit 'Checked' state with the current timestamp
                // and will not do anything else at this pass of the watcher.
                // If job's state will still be 'Checked' on the later passes
                // and after the CheckedTimeout expired, then the server
                // is dead, and we'll re-queue the job.

                redis.SetEntryInHash(
                    String.Format("hangfire:job:{0}", jobId),
                    "Checked",
                    JobHelper.ToStringTimestamp(DateTime.UtcNow));

                // Checkpoint #1-2. The job is in the implicit 'Checked' state.
                // It will be re-queued after the CheckedTimeout will be expired.
            }
            else
            {
                if (TimedOutByFetchedTime(fetched) || TimedOutByCheckedTime(fetched, @checked))
                {
                    var stateMachine = new StateMachine(new RedisConnection(_storage, redis));
                    var state = new EnqueuedState{
                        Reason = "Re-queued due to time out"
                    };

                    stateMachine.TryToChangeState(
                        jobId, 
                        state, 
                        new [] { EnqueuedState.StateName, ProcessingState.StateName });

                    RedisConnection.RemoveFromFetchedList(redis, queue, jobId);

                    return true;
                }
            }

            return false;
        }