private RedisTaskRuntimeInfo GetById(Guid taskId, bool fromArchive)
        {
            string taskIdAsString = RedisConverter.ToString(taskId);

            string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskIdAsString);

            if (fromArchive)
            {
                byte[] content = this.provider.GetHashBinaryValue(RedisTaskRuntimeInfoRepository.ArchiveTasksHash, taskIdAsString);

                if (content == null)
                {
                    return(null);
                }

                return((RedisTaskRuntimeInfo)this.serializer.Deserialize(content, typeof(RedisTaskRuntimeInfo)));
            }
            else
            {
                IReadOnlyDictionary <string, string> values = this.provider.GetHashAsText(entityKey);

                if (values.Count == 0)
                {
                    return(null);
                }

                return(RedisTaskRuntimeInfoRepository.Convert(values));
            }
        }
        private Dictionary <TaskStatus, IEnumerable <ITaskRuntimeInfo> > GetAllByType(params string[] listKeys)
        {
            List <string> entityIds = new List <string>();

            using (IRedisPipeline pipeline = this.provider.CreatePipeline())
            {
                foreach (string listKey in listKeys)
                {
                    pipeline.GetList(listKey, values => entityIds.AddRange(values));
                }

                pipeline.Flush();
            }

            Dictionary <TaskStatus, IEnumerable <ITaskRuntimeInfo> > result = new Dictionary <TaskStatus, IEnumerable <ITaskRuntimeInfo> >();

            using (IRedisPipeline pipeline = this.provider.CreatePipeline())
            {
                foreach (string entityId in entityIds)
                {
                    string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(entityId);

                    pipeline.GetHash(entityKey, values =>
                    {
                        if (values.Count > 0)
                        {
                            ITaskRuntimeInfo taskInfo = RedisTaskRuntimeInfoRepository.Convert(values);

                            IEnumerable <ITaskRuntimeInfo> collection;

                            if (!result.TryGetValue(taskInfo.Status, out collection))
                            {
                                collection = new List <ITaskRuntimeInfo>();

                                result.Add(taskInfo.Status, collection);
                            }

                            ((ICollection <ITaskRuntimeInfo>)collection).Add(taskInfo);
                        }
                    });
                }

                pipeline.Flush();
            }

            return(result);
        }
        private List <ITaskRuntimeInfo> GetAll(IEnumerable <string> entityIds)
        {
            List <ITaskRuntimeInfo> result = new List <ITaskRuntimeInfo>();

            using (IRedisPipeline pipeline = this.provider.CreatePipeline())
            {
                foreach (string entityId in entityIds)
                {
                    string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(entityId);

                    pipeline.GetHash(entityKey, values =>
                    {
                        if (values.Count > 0)
                        {
                            result.Add(RedisTaskRuntimeInfoRepository.Convert(values));
                        }
                    });
                }

                pipeline.Flush();
            }

            return(result);
        }