Redis Hash Test

RedisStudyTest/RedisHashStudyTest.cs

@@ -21,26 +21,34 @@ namespace RedisStudyTest
     public class RedisHashStudyTest : IDisposable
     {
         #region 初始化
+        private readonly ITestOutputHelper testOutput;
+
         private IDatabase redisDatabase = null;
         private RedisHashStudy hashStudy = null;
         private List<Student> students;
-        private Student student = null;
+        private Student defaultStudent = null;
         private string preHashKey = "RedisStudy:Student:";
+        private string defaultHashKey = "";
         private int keyExpireSeconds = 20;
 
         /// <summary>
         /// 构造
         /// </summary>
-        public RedisHashStudyTest()
+        public RedisHashStudyTest(ITestOutputHelper output)
         {
+            this.testOutput = output;
+
             redisDatabase = RedisHelper.GetRedisDatabase();
             hashStudy = new RedisHashStudy();
-            student = new Student()
+            defaultStudent = new Student()
             {
                 Id = 1,
                 Name = "王高峰",
-                Age = 2 * 9
+                Age = 18
             };
+
+            defaultHashKey = preHashKey + defaultStudent.Id;
+
             students = new List<Student>()
             {
                 new Student()
@@ -74,20 +82,28 @@ namespace RedisStudyTest
                     Age = 55
                 },
             };
-
             DeleteExitsStudents();
         }
         #endregion
 
-        #region 添加或更新学生
+        #region HashSet
+        /// <summary>
+        /// xUnit输出信息 测试
+        /// </summary>
+        [Fact(DisplayName = "HashSet 输出信息测试")]
+        public void HashSetOutputTest()
+        {
+            Assert.True(true);
+            testOutput.WriteLine("我是xUnit测试输出信息");
+        }
 
         /// <summary>
         /// 参数异常 测试
         /// </summary>
-        [Fact]
+        [Fact(DisplayName = "HashSet 异常测试")]
-        public void AddStudentExceptionTest()
+        public void HashSetExceptionTest()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
             //参数异常测试
             Assert.Throws<ArgumentNullException>(() => hashStudy.HashSet(string.Empty, null));
             Assert.Throws<ArgumentNullException>(() => hashStudy.HashSet("", null));
@@ -98,23 +114,24 @@ namespace RedisStudyTest
         /// <summary>
         /// 参数 When 测试
         /// </summary>
-        [Fact]
+        [Trait("HashSet", "When")]
-        public void AddStudentWhenTest()
+        [Fact(DisplayName = "HashSet When参数测试")]
+        public void HashSetWhenTest()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
 
             //当前上下文不能使用： When.Exists
 
-            var id_When_NotExists_No = hashStudy.HashSet(redisKey, "Id", student.Id + 1, When.NotExists);
+            var id_When_NotExists_No = hashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.NotExists);
             Assert.True(id_When_NotExists_No);
 
-            var id_When_NotExists_Yes = hashStudy.HashSet(redisKey, "Id", student.Id + 1, When.NotExists);
+            var id_When_NotExists_Yes = hashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.NotExists);
             Assert.False(id_When_NotExists_Yes);
 
-            var id_When_Always_Exists = hashStudy.HashSet(redisKey, "Id", student.Id + 1, When.Always);
+            var id_When_Always_Exists = hashStudy.HashSet(redisKey, "Id", defaultStudent.Id + 1, When.Always);
             Assert.False(id_When_Always_Exists);
 
-            var id_When_Always_NotExists = hashStudy.HashSet(redisKey, "Id4", student.Id + 1, When.Always);
+            var id_When_Always_NotExists = hashStudy.HashSet(redisKey, "Id4", defaultStudent.Id + 1, When.Always);
             Assert.True(id_When_Always_NotExists);
         }
 
@@ -122,14 +139,14 @@ namespace RedisStudyTest
         /// 添加一个默认学生 测试
         /// </summary>
         [Fact]
-        public void AddStudentTest()
+        public void HashSetAddStudentTest()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
             var studentEntries = new HashEntry[]
             {
                 new HashEntry("Id",1),
-                new HashEntry("Name",student.Name),
+                new HashEntry("Name",defaultStudent.Name),
-                new HashEntry("Age",student.Age),
+                new HashEntry("Age",defaultStudent.Age),
             };
 
             //插入Sudent
@@ -144,7 +161,7 @@ namespace RedisStudyTest
         /// 添加一组初始化设置的学生 测试
         /// </summary>
         [Fact]
-        public void AddStudentsTest()
+        public void HashSetAddGroupStudentTest()
         {
             foreach (var temp in students)
             {
@@ -163,118 +180,277 @@ namespace RedisStudyTest
                 //设置过期
                 redisDatabase.KeyExpire(redisKey, TimeSpan.FromSeconds(keyExpireSeconds));
             }
-        }
 
+            //清理删除
+            foreach (var temp in students)
+            {
+                redisDatabase.KeyDelete(preHashKey + temp.Id);
+            }
+        }
 
         /// <summary>
-        /// 添加或更新字段 测试
+        /// 设置一个哈希字段 测试
         /// </summary>
         [Fact]
-        public void SetStudentTest()
+        public void HashSetHashfieldTest()
         {
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, "Id", student.Id));
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id));
-            Assert.False(hashStudy.HashSet(preHashKey + student.Id, "Id", student.Id));
+            Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id));
 
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, "Name", student.Name));
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Name", defaultStudent.Name));
-            Assert.False(hashStudy.HashSet(preHashKey + student.Id, "Name", student.Name));
+            Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Name", defaultStudent.Name));
 
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, "Age", student.Age));
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Age", defaultStudent.Age));
-            Assert.False(hashStudy.HashSet(preHashKey + student.Id, "Age", student.Age));
+            Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Age", defaultStudent.Age));
         }
 
         /// <summary>
-        /// 添加或更新字段 测试
+        /// 设置一组哈希字段 测试
         /// </summary>
         [Fact]
-        public void SetStudentTest2()
+        public void HashSetGroupHashfieldTest()
         {
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, "Id", student.Id));
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id));
-            Assert.False(hashStudy.HashSet(preHashKey + student.Id, "Id", student.Id + 1));
+            Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "Id", defaultStudent.Id + 1));
 
-            var entrys=new HashEntry[]
+            var entrys = new HashEntry[]
             {
-                new HashEntry("Name", student.Name),
+                new HashEntry("Name", defaultStudent.Name),
-                new HashEntry("Age", student.Age),
+                new HashEntry("Age", defaultStudent.Age),
             };
 
             var entrys2 = new HashEntry[]
             {
-                new HashEntry("Name", student.Name+"2"),
+                new HashEntry("Name", defaultStudent.Name+"2"),
-                new HashEntry("Age", student.Age+1),
+                new HashEntry("Age", defaultStudent.Age+1),
             };
 
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, entrys));
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, entrys));
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, entrys2));
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, entrys2));
         }
 
         /// <summary>
-        /// 特例：Hash表键名为""（空字符串）
+        /// 特例测试：给key为空的哈希 设置字段
-        /// 结果：添加或更新操作能成功，但是字段值插入不进去。
+        /// 结    果：添加或更新操作能成功，但是字段值插入不进去。
         /// </summary>
         [Fact]
-        public void SetStudentEmptyKeyTest()
+        public void HashSetForEmptyKeyTest()
         {
             Assert.True(hashStudy.HashSet(string.Empty, "Name", "wanggaofeng"));
             redisDatabase.KeyDelete(string.Empty);
         }
 
         /// <summary>
-        /// 特例：Hash表,字段名为""（空字符串）
+        /// 特例测试：给字段名为空串的哈希 设置字段
-        /// 结果：添加或更新操作正常，只是字段键名为""
+        /// 结    果：添加或更新操作正常，只是字段键名为""
+        /// </summary>
+        [Fact]
+        public void HashSetForEmptyFieldTest()
+        {
+            Assert.True(hashStudy.HashSet(preHashKey + defaultStudent.Id, "", defaultStudent.Id));
+            Assert.False(hashStudy.HashSet(preHashKey + defaultStudent.Id, "", defaultStudent.Id + 1));
+
+            redisDatabase.KeyDelete(preHashKey + defaultStudent.Id);
+        }
+        #endregion
+
+        #region HashDecrement
+
+        /// <summary>
+        /// 字段值不是数字时，异常
+        /// 原注释：字段不为数据字，则改为数字
+        /// 实际执行：抛出异常，不知道是原注释错误，还是其它原因
         /// </summary>
         [Fact]
-        public void SetStudentEmptyFieldTest()
+        public void HashDecrementExceptionTest()
         {
-            Assert.True(hashStudy.HashSet(preHashKey + student.Id, "", student.Id));
+            string redisKey = preHashKey + defaultStudent.Id;
-            Assert.False(hashStudy.HashSet(preHashKey + student.Id, "", student.Id+1));
             
-            redisDatabase.KeyDelete(preHashKey + student.Id);
+            Assert.True(hashStudy.HashSet(redisKey, "Name", "wanggaofeng"));
+            Assert.Throws<RedisServerException>(() => hashStudy.HashDecrement(redisKey, "Name", 1));
         }
 
+        /// <summary>
+        /// 哈希表不存在
+        /// 则先创建哈希表，再添加值为0的字段，然后执行自减操作
+        /// </summary>
         [Fact]
-        public void HashDecrement()
+        public void HashDecrementHashKeyTest()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
 
-            //Key不存在，则新创建之
+            //Key不存在，先创建哈希表，再添加值为0的字段，然后执行自减操作
             Assert.Equal(-1, hashStudy.HashDecrement(redisKey, "Id", 1));
+
+            //存在，直接自减
             Assert.Equal(-1, hashStudy.HashGet(redisKey, "Id"));
+        }
+
+        /// <summary>
+        /// 自减字段不存在
+        /// 先添加字段，值设为0，然后执行自减操作
+        /// </summary>
+        [Fact]
+        public void HashDecrementHashFieldTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
 
             //字段不存在，则创建之
             Assert.Equal(-1, hashStudy.HashDecrement(redisKey, "Age", 1));
             Assert.Equal(-1, hashStudy.HashGet(redisKey, "Age"));
+        }
+
+        /// <summary>
+        /// 自减负数，则自增
+        /// </summary>
+        [Fact]
+        public void HashDecrementMinusTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
 
-            //字段不为数据字，则改为数字
+            //自减负数时，则自增
-            //注意：是否原注释错误？，因为实际执行抛出异常，而不是操作前改为0
+            Assert.Equal(2, hashStudy.HashDecrement(redisKey, "Age", -2));
-            Assert.True(hashStudy.HashSet(redisKey, "Name","wanggaofeng"));
+        }
-            Assert.Throws<RedisServerException>(()=>hashStudy.HashDecrement(redisKey, "Name", 1));
+
-            //Assert.Equal(-1, hashStudy.HashGet(redisKey, "Name"));
+        /// <summary>
+        /// 自减整数
+        /// </summary>
+        [Fact]
+        public void HashDecrementByIntTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
 
             //字段减少1
-            Assert.Equal(-2, hashStudy.HashDecrement(redisKey, "Age", 1));
+            Assert.Equal(-1, hashStudy.HashDecrement(redisKey, "Age", 1));
-            //字段减少
+            //字段减少2
-            Assert.Equal(-4, hashStudy.HashDecrement(redisKey, "Age", 2));
+            Assert.Equal(-3, hashStudy.HashDecrement(redisKey, "Age", 2));
+        }
 
-            //增加负数时，啥情况
+        /// <summary>
-            Assert.Equal(-2, hashStudy.HashDecrement(redisKey, "Age", -2));
+        /// 自减浮点数
+        /// 断言应该用精度值在一个小范围内
+        /// </summary>
+        [Fact]
+        public void HashDecrementByDoubleTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+
+            //新字段时，可以用相等比较
+            var dec = hashStudy.HashDecrement(redisKey, "Age", 2.1);
+            var absDec = Math.Abs(-2.1 - dec);
+            Assert.Equal(0, absDec);
+
+            //已经存在的，浮点数，不使用相等比较，而改用两值相差一定的小范围
+            dec = hashStudy.HashDecrement(redisKey, "Age", 2.5);
+            absDec = Math.Abs(-4.6 - dec);
+            Assert.True(absDec < 0.01);
         }
 
-        #endregion
+        #endregion HashIncrement
+
+        #region HashIncrement
+        /// <summary>
+        /// 字段值不是数字时，异常
+        /// 原注释：字段不为数据字，则改为数字
+        /// 实际执行：抛出异常，不知道是原注释错误，还是其它原因
+        /// </summary>
+        [Fact]
+        public void HashIncrementExceptionTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+
+            Assert.True(hashStudy.HashSet(redisKey, "Name", "wanggaofeng"));
+            Assert.Throws<RedisServerException>(() => hashStudy.HashIncrement(redisKey, "Name", 1));
+        }
+
+        /// <summary>
+        /// 哈希表不存在
+        /// 则先创建哈希表，再添加值为0的字段，然后执行自增操作
+        /// </summary>
+        [Fact]
+        public void HashIncrementHashKeyTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
 
-        #region 获取
+            //Key不存在，先创建哈希表，再添加值为0的字段，然后执行自减操作
+            Assert.Equal(1, hashStudy.HashIncrement(redisKey, "Id", 1));
+            Assert.Equal(1, hashStudy.HashGet(redisKey, "Id"));
+        }
+
+        /// <summary>
+        /// 自增字段不存在
+        /// 先添加字段，值设为0，然后执行自增操作
+        /// </summary>
+        [Fact]
+        public void HashIncrementHashFieldTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+
+            //字段不存在，则创建之
+            Assert.Equal(1, hashStudy.HashIncrement(redisKey, "Age", 1));
+            Assert.Equal(1, hashStudy.HashGet(redisKey, "Age"));
+        }
 
+        /// <summary>
+        /// 自增负数，则自减
+        /// </summary>
+        [Fact]
+        public void HashIncrementMinusTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+
+            //自增负数时，则自减
+            Assert.Equal(-2, hashStudy.HashIncrement(redisKey, "Age", -2));
+        }
+
+        /// <summary>
+        /// 自增整数
+        /// </summary>
+        [Fact]
+        public void HashIncrementByIntTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+
+            //字段减少1
+            Assert.Equal(1, hashStudy.HashIncrement(redisKey, "Age", 1));
+            //字段减少2
+            Assert.Equal(3, hashStudy.HashIncrement(redisKey, "Age", 2));
+        }
+
+        /// <summary>
+        /// 自增浮点数
+        /// 断言应该用精度值在一个小范围内
+        /// </summary>
+        [Fact]
+        public void HashIncrementByDoubleTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+
+            //新字段时，可以用相等比较
+            var dec = hashStudy.HashIncrement(redisKey, "Age", 2.1);
+            var absDec = Math.Abs(2.1 - dec);
+            Assert.Equal(0, absDec);
+
+            //已经存在的，浮点数，不使用相等比较，而改用两值相差一定的小范围
+            dec = hashStudy.HashIncrement(redisKey, "Age", 2.5);
+            absDec = Math.Abs(4.6 - dec);
+            Assert.True(absDec < 0.01);
+        }
+        #endregion
+
+        #region HashGetAll
         /// <summary>
         /// 获取一个学生
         /// </summary>
         [Fact]
-        public void GetOneSutdentTest()
+        public void HashGetAllTest()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
             var studentEntries = new HashEntry[]
             {
                 new HashEntry("Id",1),
-                new HashEntry("Name",student.Name),
+                new HashEntry("Name",defaultStudent.Name),
-                new HashEntry("Age",student.Age),
+                new HashEntry("Age",defaultStudent.Age),
             };
 
             //插入Sudent
@@ -287,59 +463,183 @@ namespace RedisStudyTest
 
             Student myStudent = new Student()
             {
-                Id = (int)entries.FirstOrDefault(e=>e.Name=="Id").Value,
+                Id = (int)entries.FirstOrDefault(e => e.Name == "Id").Value,
                 Name = entries.FirstOrDefault(e => e.Name == "Name").Value,
                 Age = (int)entries.FirstOrDefault(e => e.Name == "Age").Value,
             };
 
-            Assert.True(myStudent.Id==student.Id && myStudent.Name==student.Name && myStudent.Age==student.Age);
+            Assert.True(myStudent.Id == defaultStudent.Id && myStudent.Name == defaultStudent.Name && myStudent.Age == defaultStudent.Age);
+
+        }
+        #endregion
 
+        #region HashGet
+
+        /// <summary>
+        /// 哈希表不存在时，获取字段值
+        /// </summary>
+        [Fact]
+        public void HashGetNotKkeyTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+            var result = hashStudy.HashGet(redisKey, "Id");
+
+            Assert.False(result.HasValue);
         }
 
+        /// <summary>
+        /// 字段不存在时，获取字段值
+        /// </summary>
         [Fact]
-        public void GetId()
+        public void HashGetNotHashfieldTest()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
 
-            Assert.NotEqual(student.Id, hashStudy.HashGet(redisKey,"Id"));
+            hashStudy.HashIncrement(redisKey, "Id", 1);
+
+            var result = hashStudy.HashGet(redisKey, "Name");
+
+            Assert.False(result.HasValue);
+        }
 
+        [Fact]
+        public void HashGetTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
             AddDefaultStudent();
+
             Assert.Equal(1, hashStudy.HashGet(redisKey, "Id"));
+            Assert.Equal(defaultStudent.Name, hashStudy.HashGet(redisKey, "Name"));
+            Assert.Equal(defaultStudent.Age, hashStudy.HashGet(redisKey, "Age"));
         }
 
+        #endregion
+
+        #region HashKeys
+
+        /// <summary>
+        /// 哈希不存在时，获取所有字段的Key
+        /// </summary>
         [Fact]
-        public void GetName()
+        public void HashKeysNotKeyTest()
         {
-            string redisKey = preHashKey + student.Id;
+            RedisValue[] keys = hashStudy.HashKeys(defaultHashKey);
+
+            Assert.NotNull(keys);
+            Assert.Empty(keys);
+        }
 
-            Assert.NotEqual(student.Name, hashStudy.HashGet(redisKey, "Name").ToString());
+        /// <summary>
+        /// 获取哈希所有字段的Key
+        /// </summary>
 
+        [Fact]
+        public void HashKeys()
+        {
             AddDefaultStudent();
-            Assert.Equal(student.Name, hashStudy.HashGet(redisKey, "Name"));
+
+            RedisValue[] keys = hashStudy.HashKeys(defaultHashKey);
+            Assert.NotEmpty(keys);
+
+            Assert.Contains("Id", keys);
+            Assert.Contains("Name", keys);
+            Assert.Contains("Age", keys);
         }
+        #endregion
 
+        #region HashValues
+        /// <summary>
+        /// 哈希不存在时，获取所有字段的Key
+        /// </summary>
         [Fact]
-        public void GetAge()
+        public void HashValuesNotKeyTest()
         {
-            string redisKey = preHashKey + student.Id;
+            RedisValue[] keys = hashStudy.HashValues(defaultHashKey);
 
-            Assert.NotEqual(student.Age, hashStudy.HashGet(redisKey, "Age"));
+            Assert.NotNull(keys);
+            Assert.Empty(keys);
+        }
 
+        /// <summary>
+        /// 获取哈希所有字段的Key
+        /// </summary>
+
+        [Fact]
+        public void HashValues()
+        {
             AddDefaultStudent();
-            Assert.Equal(student.Age, hashStudy.HashGet(redisKey, "Age"));
+
+            RedisValue[] values = hashStudy.HashValues(defaultHashKey);
+            Assert.NotEmpty(values);
+
+            Assert.Contains(defaultStudent.Id, values);
+            Assert.Contains(defaultStudent.Name, values);
+            Assert.Contains(defaultStudent.Age, values);
         }
 
+        #endregion
+
+        #region HashLength
+
+        /// <summary>
+        /// 哈希不存在时，获取字段数
+        /// </summary>
+        [Fact]
+        public void HashLengthNotKeyTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+            var result = hashStudy.HashLength(redisKey);
+
+            Assert.Equal(0, result);
+        }
+
+        /// <summary>
+        /// 获取哈希字段数
+        /// </summary>
+        [Fact]
+        public void HashLengthTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+            AddDefaultStudent();
+
+            var result = hashStudy.HashLength(redisKey);
+
+            Assert.Equal(3, result);
+        }
+
+        #endregion
+
+        #region HashScan
+
+        /// <summary>
+        /// 哈希不存在时，HashScan
+        /// </summary>
+        [Fact]
+        public void HashScanNotKey()
+        {
+            var hashEntrys=  hashStudy.HashScan(defaultHashKey);
+
+            var num = hashEntrys.Count();
+            Assert.Equal(0, num);
+
+            var entryList = hashEntrys.ToList();
+
+            Assert.Empty(entryList);
+        }
+        #endregion
+
+        #region HashExists
         /// <summary>
         /// 指定字段是否存在
         /// </summary>
         [Fact]
-        public void ExistStudent()
+        public void HashExists()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
             var studentEntries = new HashEntry[]
             {
                 new HashEntry("Id",1),
-                new HashEntry("Name",student.Name),
+                new HashEntry("Name",defaultStudent.Name),
             };
 
             //插入Sudent
@@ -350,16 +650,62 @@ namespace RedisStudyTest
             Assert.True(hashStudy.HashExists(redisKey, "Name"));
             Assert.False(hashStudy.HashExists(redisKey, "Age"));
         }
+        #endregion
+
+        #region HashDelete
 
+        /// <summary>
+        /// 哈希不存在时，删除哈希字段
+        /// </summary>
+        [Fact]
+        public void HashDeleteNotKeyTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+            var hashDeleteResult = hashStudy.HashDelete(redisKey, "FieldFirst");
+
+            Assert.False(hashDeleteResult);
+        }
+
+        /// <summary>
+        /// 删除不存在的哈希字段
+        /// </summary>
+        [Fact]
+        public void HashDeleteNotFieldTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+            hashStudy.HashIncrement(redisKey, "Id",1);
+
+            var hashDeleteResult = hashStudy.HashDelete(redisKey, "Name");
+            Assert.False(hashDeleteResult);
+        }
+
+        /// <summary>
+        /// 删除哈希字段
+        /// </summary>
+        [Fact]
+        public void HashDeleteTest()
+        {
+            string redisKey = preHashKey + defaultStudent.Id;
+            AddDefaultStudent();
+
+            var hashDeleteResult = hashStudy.HashDelete(redisKey, "Id");
+            Assert.True(hashDeleteResult);
+
+            hashDeleteResult = hashStudy.HashDelete(redisKey, "Name");
+            Assert.True(hashDeleteResult);
+
+            hashDeleteResult = hashStudy.HashDelete(redisKey, "Age");
+            Assert.True(hashDeleteResult);
+        }
         #endregion
 
-        #region 删除学生
+        #region HashKeyDelete
 
         /// <summary>
         /// 删除学生
         /// </summary>
         [Fact]
-        public void DeleteStudent()
+        public void KeyDeleteTest()
         {
             Assert.False(redisDatabase.KeyDelete(preHashKey + "-2000"));
         }
@@ -374,34 +720,31 @@ namespace RedisStudyTest
             DeleteExitsStudents();
         }
 
+        #region 辅助方法
         /// <summary>
         /// 删除Redis中的测试学生
         /// </summary>
         private void DeleteExitsStudents()
         {
-            if (student != null)
+            if (defaultStudent != null)
             {
-                redisDatabase.KeyDelete(preHashKey + student.Id);
+                redisDatabase.KeyDelete(preHashKey + defaultStudent.Id);
-            }
-
-            foreach (var temp in students)
-            {
-                redisDatabase.KeyDelete(preHashKey + temp.Id);
             }
         }
 
         private void AddDefaultStudent()
         {
-            string redisKey = preHashKey + student.Id;
+            string redisKey = preHashKey + defaultStudent.Id;
             var studentEntries = new HashEntry[]
             {
                 new HashEntry("Id",1),
-                new HashEntry("Name",student.Name),
+                new HashEntry("Name",defaultStudent.Name),
-                new HashEntry("Age",student.Age),
+                new HashEntry("Age",defaultStudent.Age),
             };
 
             //插入Sudent
             var addHash = hashStudy.HashSet(redisKey, studentEntries);
         }
+        #endregion
     }
 }

RedisStuy/RedisHashStudy.cs

@@ -23,7 +23,7 @@ namespace RedisStuy
         #endregion
 
         /// <summary>
-        /// 整数减少hash中，指定列的值
+        /// 整数自减hash字段
         /// key不存在，则创建一个持有哈希的新密钥。
         /// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
         /// </summary>