C# IDatabase.HashGetAll方法代码示例

 public static void Restore(AddProductToOrder c, IDatabase db, Guid key)
 {
     db.HashGetAll(key).Tap(hash =>
         {
             c.OrderId = hash.GetInt("OrderId");
             c.ProductId = hash.GetInt("ProductId");
         });
 }

 public static void Restore(AddProductCommand c,IDatabase db, Guid key)
 {
     db.HashGetAll(key).Tap(hash =>
         {
             c.Id = hash.GetInt("Id");
             c.Version = hash.GetInt("Version");
             c.Cost = hash.GetFloat("Cost");
             c.Name = hash.GetString("Name");
         });
 }

 public static void Restore(AddOrderCommand c,IDatabase db, Guid key)
 {
     db.HashGetAll(key).Tap(hash =>
         {
             c.Id = hash.GetInt("Id");
             c.Version = hash.GetInt("Version");
             c.Customer = hash.GetInt("Customer");
             c.OrderDate = new DateTime(hash.GetLong("OrderDate"));
         });
 }

 public static void Restore(AddCustomerCommand c, IDatabase db, Guid key)
 {
     db.HashGetAll(key).Tap(hash =>
         {
             c.Id = hash.GetInt("Id");
             c.Version = hash.GetInt("Version");
             c.Firstname = hash.GetString("Firstname");
             c.Lastname = hash.GetString("Lastname");
         });
 }

 public static Command Read(IDatabase db, Guid key)
 {
     var entries = db.HashGetAll(key);
     var type = entries.GetString("Type");
     var command = RedisExtensions.getCommand[type];
     var instance = (Command)Activator.CreateInstance(command);
     instance.SequenceNumber = entries.GetInt("SequenceNumber");
     Switch.On(instance)
         .Case((AddCustomerCommand c) => AddCustomerCommandMap.Restore(c, db, key))
         .Case((AddOrderCommand c) => AddOrderCommandMap.Restore(c, db, key))
         .Case((AddProductCommand c) => AddProductCommandMap.Restore(c, db, key))
         .Case((AddProductToOrder c) => AddProductToOrderMap.Restore(c, db, key))
         .ElseFail()
         ;
     return instance;
 }

            public static RedisSessionStateStore Create(IDatabase database, string id, int timeout)
            {
                var timeoutSpan = TimeSpan.FromMinutes(timeout);
                database.StringSet(id, JsonConvert.SerializeObject(new { Timeout = timeout }), timeoutSpan);

                var hashKey = GetHashKey(id);
                var entrys = database.HashGetAll(hashKey);
                foreach (var entry in entrys)
                    database.HashDelete(hashKey, entry.Name);

                return new RedisSessionStateStore(database, id, TimeSpan.FromMinutes(timeout), hashKey);
            }

        public override object Read(object obj, Type objType, IDatabase redisDatabase, string id, PropertyInfo basePropertyInfo, LimitObject limits = null)
        {
            if (id == null)
            {
                throw new Exception("Id can't be null");
            }
            var redisKey = new RedisKeyObject(objType, id);

            RedisObjectManager.RedisBackup?.RestoreHash(redisDatabase, redisKey);
            var ret = redisDatabase.HashGetAll(redisKey.RedisKey);

            // Attempt to set all given properties
            obj = RedisObjectManager.ConvertToObject(obj, ret);

            // Do we continue here if it is a base system class?
            if (!(obj is IRedisObject)) return obj;

            var props = obj.GetType().GetProperties();

            foreach (var prop in props)
            {
                // If value is virtual assume it is lazy
                if (!prop.GetMethod.IsVirtual) continue;
                // Create proxies here
                if (prop.PropertyType.IsSealed) continue;
                if (!prop.PropertyType.IsClass && !prop.PropertyType.IsInterface) continue;
                try
                {

                    // If the target is an IRedisObject we need to get the ID differently
                    string objectKey = null;
                    //RedisValue propKey = new RedisValue();
                    if (prop.PropertyType.GetInterfaces().Any(x => x == typeof(IRedisObject)))
                    {
                        // Try to get the property value from ret
                        RedisValue propKey;
                        if (ret.ToDictionary().TryGetValue(prop.Name, out propKey))
                        {
                            objectKey = propKey.ParseKey();
                            if (prop.GetValue(obj, null) == null)
                            {
                                var pr = RedisObjectManager.GetRedisObjectWithType(redisDatabase, (string)propKey, objectKey);
                                obj.GetType().GetProperty(prop.Name).SetValue(obj, pr);
                            }
                        }
                        else
                        {
                            if (prop.PropertyType.IsInterface)
                            {
                                throw new Exception("Properties of type Interface need to be populated first");
                            }
                            else
                            {
                                object baseObject = prop.GetValue(obj, null) ?? Activator.CreateInstance(prop.PropertyType);
                                var key = new RedisKeyObject(baseObject.GetType(), string.Empty);
                                redisDatabase.GenerateId(key, baseObject, null);
                                objectKey = key.Id;

                                if (!(baseObject is IProxyTargetAccessor))
                                {
                                    var pr = RedisObjectManager.RetrieveObjectProxy(prop.PropertyType, objectKey, redisDatabase,
                                        baseObject, obj);
                                    obj.GetType().GetProperty(prop.Name).SetValue(obj, pr);
                                }
                            }
                        }
                    }
                    else
                    {
                        // Here we try to handle NON redisObjects
                        object baseObject = prop.GetValue(obj, null) ?? Activator.CreateInstance(prop.PropertyType);

                        objectKey = id;

                        if (!(baseObject is IProxyTargetAccessor))
                        {
                            var pr = RedisObjectManager.RetrieveObjectProxy(prop.PropertyType, objectKey, redisDatabase,
                                baseObject, obj);
                            obj.GetType().GetProperty(prop.Name).SetValue(obj, pr);
                        }
                    }
                }
                catch (Exception e)
                {
                    Debug.WriteLine(e);
                }
            }

            return obj;
        }

        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;
        }