C# IDatabase.KeyExists方法代码示例

 public static void UpdateExpire(IDatabase database, string id, TimeSpan timeout)
 {
     var keys = new[] { id, GetHashKey(id) };
     foreach (var key in keys.Where(key => database.KeyExists(key)))
     {
         database.KeyExpire(key, timeout);
     }
 }

        public override object Read(object obj, Type objType, IDatabase redisDatabase, string id, PropertyInfo basePropertyInfo,
            LimitObject limits = null)
        {
            var setKey = new RedisKeyObject(basePropertyInfo, id);

            // TODO Workon RedisBackup

            if (limits != null && limits.RestoreOnly)
            {
                return obj;
            }

            var targetType = GetTarget(obj).GetType();

            Type itemType = null;
            if (targetType.GetInterfaces().Any(interfaceType => interfaceType.IsGenericType &&
                      interfaceType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
            {
                if (targetType.GetGenericArguments().Any())
                {
                    itemType = targetType.GetGenericArguments()[0];
                }
            }

            //var method = objType.GetMethod("Add", BindingFlags.DeclaredOnly, null, new[] { itemType }, null);
            var method = objType.GetMethods()
                .SingleOrDefault(x => x.Name.Equals("Add") && x.ReturnType == typeof (bool));

            if (itemType != null && (itemType.GetInterfaces().Contains(typeof (IRedisObject)) || typeof (IRedisObject) == itemType))
            {
                List<RedisValue> retList;

                // TODO add limits to sets (for now we just grab everything)
                if (limits != null)
                {
                    retList = redisDatabase.SortedSetRangeByScore(setKey.RedisKey, limits.StartLimit, limits.EndLimit, Exclude.None, limits.Order, limits.SkipLimit, limits.TakeLimit).ToList();
                }
                else
                {
                    retList = redisDatabase.SortedSetRangeByRank(setKey.RedisKey).ToList();
                }

                foreach (var ret in retList)
                {
                    if (!redisDatabase.KeyExists((string) ret))
                    {
                        redisDatabase.SortedSetRemove(setKey.RedisKey, (string)ret);
                        continue;
                    }

                    var key = ret.ParseKey();

                    var newProxy = RedisObjectManager.GetRedisObjectWithType(redisDatabase, (string)ret, key);

                    var t = method.Invoke(obj, new[] { newProxy as IRedisObject });
                }
            }
            return obj;
        }

 /// <summary>
 /// Determines if the key exists.
 /// </summary>
 /// <param name="database">
 /// The database where the query will be performed. This is passed so that we can reuse the same database to
 /// perform multiple bitwise operations. Doing this with the same connection will guarantee that performance
 /// is good.
 /// </param>
 /// <param name="key">
 /// The key.
 /// </param>
 /// <returns>
 /// True if the key exists.
 /// </returns>
 public static bool Exists(IDatabase database, RedisKey key)
 {
     return database.KeyExists(key);
 }

        public override object Read(object obj, Type objType, IDatabase redisDatabase, string id, PropertyInfo basePropertyInfo, LimitObject limits = null)
        {
            var hashKey = new RedisKeyObject(basePropertyInfo, id);
            RedisObjectManager.RedisBackup?.RestoreHash(redisDatabase, hashKey);

            if (limits != null && limits.RestoreOnly)
            {
                return obj;
            }

            var targetType = GetTarget(obj).GetType();
            Type keyType = null;
            Type itemType = null;

            if (targetType.GetInterfaces().Any(interfaceType => interfaceType.IsGenericType &&
                      interfaceType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
            {
                if (targetType.GetGenericArguments().Any())
                {
                    keyType = targetType.GetGenericArguments()[0];
                    itemType = targetType.GetGenericArguments()[1];
                }
            }

            var method = objType.GetMethod("Add", new []{keyType, itemType});

            // TODO working on this...

            if (itemType != null && (itemType.GetInterfaces().Contains(typeof(IRedisObject)) || typeof(IRedisObject) == itemType))
            {
                // TODO this all needs to be changed to handle IRedisObjects in a Dictionary, shouldn't be to hard
                List<HashEntry> retlist;

                if (limits != null)
                {
                    if (limits.KeyLimit != null && !limits.KeyLimit.IsNullOrEmpty())
                    {
                        retlist = new List<HashEntry>();
                        foreach (var item in limits.KeyLimit)
                        {
                            var ret = redisDatabase.HashGet(hashKey.RedisKey, (string) item);
                            if (!ret.IsNullOrEmpty)
                            {
                                retlist.Add(new HashEntry((string) item, ret));
                            }
                        }
                    } else if (limits.StartLimit != 0 || limits.TakeLimit != 0)
                    {
                        retlist =
                            redisDatabase.HashScan(hashKey.RedisKey, default(RedisValue), (int)limits.TakeLimit,
                                limits.StartLimit).ToList();
                    }
                    else
                    {
                        retlist = new List<HashEntry>();
                    }
                }
                else
                {
                    retlist = redisDatabase.HashGetAll(hashKey.RedisKey).ToList();
                }

                foreach (var ret in retlist)
                {
                    // We need to check to make sure the object exists (Overhead... it happens)
                    if (!redisDatabase.KeyExists((string) ret.Value))
                    {
                        redisDatabase.HashDelete(hashKey.RedisKey, ret.Name);
                        continue;
                    }

                    var key = ret.Value.ParseKey();

                    var newProxy = RedisObjectManager.GetRedisObjectWithType(redisDatabase, (string)ret.Value, key);

                    method.Invoke(obj, new[] { Convert.ChangeType(ret.Name, keyType), newProxy });
                }
                return obj;
            }

            var retList = redisDatabase.HashGetAll(hashKey.RedisKey);
            foreach (var ret in retList)
            {
                object convertedKey;
                object convertedValue;

                if (!RedisObjectManager.TryConvertFromRedisValue(keyType, ret.Name, out convertedKey)
                    || !RedisObjectManager.TryConvertFromRedisValue(itemType, ret.Value, out convertedValue))
                {
                    throw new Exception("There was an error converting the objects to key/value");
                }

                method.Invoke(obj, new[] {convertedKey, convertedValue});
            }
            return obj;
        }