diff --git a/RedisStudyTest/RedisHashStudyTest.cs b/RedisStudyTest/RedisHashStudyTest.cs
index 89f7cda..744f02b 100644
--- a/RedisStudyTest/RedisHashStudyTest.cs
+++ b/RedisStudyTest/RedisHashStudyTest.cs
@@ -70,19 +70,19 @@ namespace RedisStudyTest
                 },
             };
 
-            hashStudy.AddStudents(students);
+            //hashStudy.AddStudents(students);
         }
 
         [Fact]
         public void AddStudentTest()
         {
-            hashStudy.AddStudent(student);
+            //hashStudy.AddStudent(student);
 
-            var newStudent = hashStudy.QueryOneStudent(student.Id);
-            Assert.NotNull(newStudent);
-            Assert.Equal(1, newStudent.Id);
-            Assert.Equal("王高峰", newStudent.Name);
-            Assert.Equal(18, actual: newStudent.Age);
+            //var newStudent = hashStudy.QueryOneStudent(student.Id);
+            //Assert.NotNull(newStudent);
+            //Assert.Equal(1, newStudent.Id);
+            //Assert.Equal("王高峰", newStudent.Name);
+            //Assert.Equal(18, actual: newStudent.Age);
         }
 
         [Theory]
@@ -91,40 +91,40 @@ namespace RedisStudyTest
         [InlineData(-3)]
         public void DelStudentTest(int studentId)
         {
-            Assert.False(hashStudy.DelStudentById(studentId));
+            //Assert.False(hashStudy.DelStudentById(studentId));
         }
 
         [Theory]
         [InlineData(-100)]
         public void DelStudentTest2(int studentId)
         {
-            Assert.False(hashStudy.DelStudentById(studentId));
+            //Assert.False(hashStudy.DelStudentById(studentId));
         }
 
         [Fact]
         public void QueryOneStudentTest()
         {
-            hashStudy.AddStudent(this.student);
+            //hashStudy.AddStudent(this.student);
 
-            var queryStudent = hashStudy.QueryOneStudent(this.student.Id);
+            //var queryStudent = hashStudy.QueryOneStudent(this.student.Id);
 
-            Assert.NotNull(queryStudent);
-            Assert.True(this.student.Id==queryStudent.Id);
-            Assert.True(this.student.Name == queryStudent.Name);
-            Assert.True(this.student.Age == queryStudent.Age);
+            //Assert.NotNull(queryStudent);
+            //Assert.True(this.student.Id==queryStudent.Id);
+            //Assert.True(this.student.Name == queryStudent.Name);
+            //Assert.True(this.student.Age == queryStudent.Age);
         }
 
         [Fact]
         public void ExistStudentTest()
         {
-            Assert.True(hashStudy.ExistStudent(students[0].Id));
-            Assert.True(hashStudy.ExistStudent(students[1].Id));
-            Assert.True(hashStudy.ExistStudent(students[2].Id));
-            Assert.True(hashStudy.ExistStudent(students[3].Id));
-            Assert.True(hashStudy.ExistStudent(students[4].Id));
-
-            Assert.False(hashStudy.ExistStudent(-1000));
-            Assert.False(hashStudy.ExistStudent(-2000));
+            //Assert.True(hashStudy.ExistStudent(students[0].Id));
+            //Assert.True(hashStudy.ExistStudent(students[1].Id));
+            //Assert.True(hashStudy.ExistStudent(students[2].Id));
+            //Assert.True(hashStudy.ExistStudent(students[3].Id));
+            //Assert.True(hashStudy.ExistStudent(students[4].Id));
+
+            //Assert.False(hashStudy.ExistStudent(-1000));
+            //Assert.False(hashStudy.ExistStudent(-2000));
         }
 
         /// <summary>
@@ -133,10 +133,10 @@ namespace RedisStudyTest
         [Fact]
         public void QueryAllStudent()
         {
-            List<Student> students = hashStudy.QueryAllStudents();
+            //List<Student> students = hashStudy.QueryAllStudents();
 
-            Assert.NotNull(students);
-            Assert.Equal(students.Count(), students.Count);
+            //Assert.NotNull(students);
+            //Assert.Equal(students.Count(), students.Count);
         }
 
         /// <summary>
@@ -144,11 +144,11 @@ namespace RedisStudyTest
         /// </summary>
         public void Dispose()
         {
-            hashStudy.DelStudentById(student.Id);
-            foreach (var temp in students)
-            {
-                hashStudy.DelStudentById(temp.Id);
-            }
+            //hashStudy.DelStudentById(student.Id);
+            //foreach (var temp in students)
+            //{
+            //    hashStudy.DelStudentById(temp.Id);
+            //}
         }
     }
 }
diff --git a/RedisStuy/RedisHashStudy.cs b/RedisStuy/RedisHashStudy.cs
index 7514b3c..3887f70 100644
--- a/RedisStuy/RedisHashStudy.cs
+++ b/RedisStuy/RedisHashStudy.cs
@@ -16,163 +16,156 @@ namespace RedisStuy
     public class RedisHashStudy
     {
         #region 初始化
-        private string studentHashKey = "student:hask:";
         private IDatabase redisDatabase = RedisHelper.GetRedisDatabase();
         #endregion
 
+        /// <summary>
+        /// 整数减少hash中，指定列的值
+        /// key不存在，则创建一个持有哈希的新密钥。
+        /// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
+        /// </summary>
+        public long HashDecrement(RedisKey key, RedisValue hashField, long value=1, CommandFlags flags=CommandFlags.None)
+        {
+            return redisDatabase.HashDecrement(key, hashField, value, flags);
+        }
 
+        /// <summary>
+        /// 浮点数减少hash中，指定列的值
+        /// key不存在，则创建一个持有哈希的新密钥。
+        /// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
+        /// </summary>
+        public double HashDecrement(RedisKey key, RedisValue hashField, double value = 1, CommandFlags flags = CommandFlags.None)
+        {
+            return redisDatabase.HashDecrement(key, hashField, value, flags);
+        }
 
         /// <summary>
-        /// 添加一个学生
+        /// 删除哈希表中指定字段，不存在的字段将被忽略
         /// </summary>
-        public bool AddStudent(Student student)
+        public bool HashDelete(RedisKey key, RedisValue hashField, CommandFlags flags=CommandFlags.None)
         {
-            try
-            {
-                HashEntry[] hashEntries = new HashEntry[]
-                {
-                    new HashEntry("Id",student.Id),
-                    new HashEntry("Name",student.Name),
-                    new HashEntry("Age",student.Age),
-                };
+            return redisDatabase.HashDelete(key, hashField, flags);
+        }
 
-                redisDatabase.HashSet(studentHashKey + student.Id, hashEntries, CommandFlags.None);
+        /// <summary>
+        /// 删除哈希表中多个指定字段，不存在的字段将被忽略
+        /// </summary>
+        public long HashDelete(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None)
+        {
+            return redisDatabase.HashDelete(key, hashFields, flags);
+        }
 
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
+        /// <summary>
+        /// 哈希表中指定字段是否存在
+        /// </summary>
+        public bool HashExists(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None)
+        {
+            return redisDatabase.HashExists(key, hashField, flags);
         }
 
         /// <summary>
-        /// 添加多个学生
+        /// 获取哈希表中指定字段的值
         /// </summary>
-        public bool AddStudents(List<Student> students)
+        public RedisValue HashGet(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None)
         {
-            try
-            {
-                foreach (var student in students)
-                {
-                    AddStudent(student);
-                }
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
+            return redisDatabase.HashGet(key, hashField, flags);
         }
 
         /// <summary>
-        /// 删除一个学生
+        /// 获取哈希表中一组字段的一组值
         /// </summary>
-        public bool DelStudentById(int studentId)
+        public RedisValue[] HashGet(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None)
         {
-            return redisDatabase.KeyDelete(studentHashKey + studentId);
+            return redisDatabase.HashGet(key, hashFields, flags);
         }
 
         /// <summary>
-        /// 查询一个学生
+        /// 获取哈希表所有字段
         /// </summary>
-        public Student QueryOneStudent(int studentId)
+        public HashEntry[] HashGetAll(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            Student student = null;
+            return redisDatabase.HashGetAll(key, flags);
+        }
 
-            var studentHashEntryList = redisDatabase.HashGetAll(studentHashKey + studentId);
-            if (studentHashEntryList.Length > 0)
-            {
-                student = new Student();
-                foreach (var temp in studentHashEntryList)
-                {
-                    switch (temp.Name)
-                    {
-                        case "Id":
-                            student.Id = (int)temp.Value;
-                            break;
-                        case "Name":
-                            student.Name = temp.Value.HasValue ? temp.Value.ToString() : string.Empty;
-                            break;
-                        case "Age":
-                            student.Age = (int)temp.Value;
-                            break;
-                    }
-                }
-            }
-            return student;
+        /// <summary>
+        /// 整数增加hash中，指定列的值
+        /// key不存在，则创建一个持有哈希的新密钥。
+        /// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
+        /// </summary>
+        public long HashIncrement(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None)
+        {
+            return redisDatabase.HashIncrement(key, hashField, value, flags);
         }
 
         /// <summary>
-        /// 查询一个学生
+        /// 浮点数增加hash中，指定列的值
+        /// key不存在，则创建一个持有哈希的新密钥。
+        /// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
         /// </summary>
-        public Student QueryOneStudent(string redisKey)
+        public double HashIncrement(RedisKey key, RedisValue hashField, double value = 1, CommandFlags flags = CommandFlags.None)
         {
-            Student student = null;
+            return redisDatabase.HashIncrement(key, hashField, value, flags);
+        }
 
-            var studentHashEntryList = redisDatabase.HashGetAll(redisKey);
-            if (studentHashEntryList.Length > 0)
-            {
-                student = new Student();
-                foreach (var temp in studentHashEntryList)
-                {
-                    switch (temp.Name)
-                    {
-                        case "Id":
-                            student.Id = (int)temp.Value;
-                            break;
-                        case "Name":
-                            student.Name = temp.Value.HasValue ? temp.Value.ToString() : string.Empty;
-                            break;
-                        case "Age":
-                            student.Age = (int)temp.Value;
-                            break;
-                    }
-                }
-            }
-            return student;
+        /// <summary>
+        /// 获取哈希表中所有的字段
+        /// </summary>
+        public RedisValue[] HashKeys(RedisKey key, CommandFlags flags=CommandFlags.None)
+        {
+            return redisDatabase.HashKeys(key, flags);
         }
 
         /// <summary>
-        /// 查询 所有学生
+        /// 获取哈希表中字段的数量
         /// </summary>
-        /// <returns></returns>
-        public List<Student> QueryAllStudents()
+        public long HashLength(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            List<Student> students = new List<Student>();
+            return redisDatabase.HashLength(key, flags);
+        }
 
-            var studdentKeys = RedisHelper.GetDefaultRedisServer().Keys(1, studentHashKey + "*", 200);
-            foreach (var key in studdentKeys)
-            {
-                students.Add(QueryOneStudent(key));
-            }
+        /// <summary>
+        /// 获取哈希表中所有字段的值
+        /// </summary>
+        public RedisValue[] HashValues(RedisKey key, CommandFlags flags = CommandFlags.None)
+        {
+            return redisDatabase.HashValues(key, flags);
+        }
 
-            return students;
+        /// <summary>
+        /// 为哈希表中的字段赋值
+        /// 如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。
+        /// 如果字段已经存在于哈希表中，旧值将被覆盖。
+        /// </summary>
+        public bool HashSet(RedisKey key, RedisValue hashField, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None)
+        {
+            return redisDatabase.HashSet(key, hashField, value, when, flags);
         }
 
         /// <summary>
-        /// 查询某项的值
+        /// 同时将多个 field-value (字段-值)对设置到哈希表中。
+        /// 此命令会覆盖哈希表中已存在的字段。
+        /// 如果哈希表不存在，会创建一个空哈希表，并执行 HMSET 操作。
         /// </summary>
-        public void GetValue(int studentId, string haskFiledName)
+        public void HashSet(RedisKey key, HashEntry[] hashFields, CommandFlags flags = CommandFlags.None)
         {
-            var redisValue = redisDatabase.HashGet(studentHashKey + studentId, haskFiledName);
+            redisDatabase.HashSet(key, hashFields, flags);
         }
 
         /// <summary>
-        /// 更新一列的值
+        /// HSCAN命令用于对哈希进行增量迭代
         /// </summary>
-        public void UpdateHashFile<T>(int studentId, string haskFiledName, RedisValue redisValue)
+        public IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            redisDatabase.HashSet(studentHashKey + studentId, haskFiledName, redisValue);
+            return redisDatabase.HashScan(key, pattern, pageSize, flags);
         }
 
         /// <summary>
-        /// 学生是否存在
+        /// HSCAN命令用于对哈希进行增量迭代；
+        /// 注意：通过光标恢复迭代，将原始枚举或枚举器转换为ISCANIN光标。
         /// </summary>
-        public bool ExistStudent(int studentId)
+        public IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = 10, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None)
         {
-            bool exists = redisDatabase.KeyExists(studentHashKey + studentId);
-            return exists;
+            return redisDatabase.HashScan(key, pattern, pageSize,cursor,pageOffset, flags);
         }
     }
 }