Example #1
0
        public virtual async Task <bool> ExistsWithRedisAsync(string id)
        {
            RedisHitStatistics?.AddTotal();
            var exists = RedisClient.HashFieldExists(RedisKey, id, SerializeType) > 0;

            if (!exists)
            {
                exists = await ExistsAsync(id);
            }
            else
            {
                RedisHitStatistics?.AddHit();
            }
            return(exists);
        }
Example #2
0
        public override async Task <IEnumerable <SysAreaDto> > GetAllAsync()
        {
            RedisHitStatistics?.AddTotal();
            var list = RedisClient.HashGetAll <SysAreaDto>(RedisKey, SerializeType).Select(e => e.Value as SysAreaDto);

            if (list.Any())
            {
                RedisHitStatistics?.AddHit();
            }
            else
            {
                list = await base.GetAllAsync();
            }
            return(list);
        }
Example #3
0
        public virtual async Task <long> CountWidthRedisAsync()
        {
            RedisHitStatistics?.AddTotal();
            var list = RedisClient.HashGetAll <TDto>(RedisKey, DataType.Protobuf).Select(e => e.Value as TDto);

            if (!list.Any())
            {
                list = await GetAllAsync();

                list.AsParallel().ToList().ForEach(e => RedisClient.HashSetFieldValue(RedisKey, e.Serialnum, e, SerializeType));
            }
            else
            {
                RedisHitStatistics?.AddHit();
            }
            return(list.Count());
        }
Example #4
0
        /// <summary>
        ///     根据编码获取设备
        /// </summary>
        /// <param name="id">设备编码</param>
        /// <returns></returns>
        public async Task <DeviceDto> GetDeviceByIdAsny(string id)
        {
            //RedisHitStatistics?.AddTotal();
            try
            {
                RedisClient.Delete(RedisKey);
                var device = RedisClient.HashGet <DeviceDto>(RedisKey, id, DataType.Protobuf);
                if (device == null)
                {
                    var dev = await Repository.GetByIdAsync(id);

                    if (dev != null)
                    {
                        var dto = Mapper.Map <DeviceDto>(dev);
                        RedisClient.HashSetFieldValue(RedisKey, dto.Serialnum, dto, DataType.Protobuf);
                        return(dto);
                    }
                    else
                    {
                        return(null);
                    }
                }
                else
                {
                    RedisHitStatistics?.AddHit();
                    return(device);
                }
            }
            //catch (AggregateException ex)
            //{
            //    ex.InnerExceptions.ForEach(iex =>
            //    {
            //         LogHelper.Info(iex);
            //    });
            //}
            catch (Exception ex)
            {
                throw;
            }
        }
Example #5
0
        public virtual async Task <TDto> GetByIdWithRedisAsync(string id)
        {
            if (id.IsNullOrWhiteSpace())
            {
                return(null);
            }
            RedisHitStatistics?.AddTotal();

            var model = RedisClient.HashGet <TDto>(RedisKey, id, SerializeType);

            if (model == null)
            {
                model = await GetByIdAsync(id);

                RedisClient.HashSetFieldValue(RedisKey, id, model, SerializeType);
            }
            else
            {
                RedisHitStatistics?.AddHit();
            }
            return(model);
        }