StudyGroup
/
RedisStudy
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

重写Hash操作

Browse Source
master
ruyu 7 years ago
parent 69a2426059
commit a5a582ce29
2 changed files with 127 additions and 134 deletions
Show Stats Download Patch File Download Diff File

60
RedisStudyTest/RedisHashStudyTest.cs
Unescape Escape View File

@ -70,19 +70,19 @@ namespace RedisStudyTest
}, },
}; };
hashStudy.AddStudents(students); //hashStudy.AddStudents(students);
} }
[Fact] [Fact]
public void AddStudentTest() public void AddStudentTest()
{ {
hashStudy.AddStudent(student); //hashStudy.AddStudent(student);
var newStudent = hashStudy.QueryOneStudent(student.Id); //var newStudent = hashStudy.QueryOneStudent(student.Id);
Assert.NotNull(newStudent); //Assert.NotNull(newStudent);
Assert.Equal(1, newStudent.Id); //Assert.Equal(1, newStudent.Id);
Assert.Equal("王高峰", newStudent.Name); //Assert.Equal("王高峰", newStudent.Name);
Assert.Equal(18, actual: newStudent.Age); //Assert.Equal(18, actual: newStudent.Age);
} }
[Theory] [Theory]
@ -91,40 +91,40 @@ namespace RedisStudyTest
[InlineData(-3)] [InlineData(-3)]
public void DelStudentTest(int studentId) public void DelStudentTest(int studentId)
{ {
Assert.False(hashStudy.DelStudentById(studentId)); //Assert.False(hashStudy.DelStudentById(studentId));
} }
[Theory] [Theory]
[InlineData(-100)] [InlineData(-100)]
public void DelStudentTest2(int studentId) public void DelStudentTest2(int studentId)
{ {
Assert.False(hashStudy.DelStudentById(studentId)); //Assert.False(hashStudy.DelStudentById(studentId));
} }
[Fact] [Fact]
public void QueryOneStudentTest() 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.NotNull(queryStudent);
Assert.True(this.student.Id==queryStudent.Id); //Assert.True(this.student.Id==queryStudent.Id);
Assert.True(this.student.Name == queryStudent.Name); //Assert.True(this.student.Name == queryStudent.Name);
Assert.True(this.student.Age == queryStudent.Age); //Assert.True(this.student.Age == queryStudent.Age);
} }
[Fact] [Fact]
public void ExistStudentTest() public void ExistStudentTest()
{ {
Assert.True(hashStudy.ExistStudent(students[0].Id)); //Assert.True(hashStudy.ExistStudent(students[0].Id));
Assert.True(hashStudy.ExistStudent(students[1].Id)); //Assert.True(hashStudy.ExistStudent(students[1].Id));
Assert.True(hashStudy.ExistStudent(students[2].Id)); //Assert.True(hashStudy.ExistStudent(students[2].Id));
Assert.True(hashStudy.ExistStudent(students[3].Id)); //Assert.True(hashStudy.ExistStudent(students[3].Id));
Assert.True(hashStudy.ExistStudent(students[4].Id)); //Assert.True(hashStudy.ExistStudent(students[4].Id));
Assert.False(hashStudy.ExistStudent(-1000)); //Assert.False(hashStudy.ExistStudent(-1000));
Assert.False(hashStudy.ExistStudent(-2000)); //Assert.False(hashStudy.ExistStudent(-2000));
} }
/// <summary> /// <summary>
@ -133,10 +133,10 @@ namespace RedisStudyTest
[Fact] [Fact]
public void QueryAllStudent() public void QueryAllStudent()
{ {
List<Student> students = hashStudy.QueryAllStudents(); //List<Student> students = hashStudy.QueryAllStudents();
Assert.NotNull(students); //Assert.NotNull(students);
Assert.Equal(students.Count(), students.Count); //Assert.Equal(students.Count(), students.Count);
} }
/// <summary> /// <summary>
@ -144,11 +144,11 @@ namespace RedisStudyTest
/// </summary> /// </summary>
public void Dispose() public void Dispose()
{ {
hashStudy.DelStudentById(student.Id); //hashStudy.DelStudentById(student.Id);
foreach (var temp in students) //foreach (var temp in students)
{ //{
hashStudy.DelStudentById(temp.Id); // hashStudy.DelStudentById(temp.Id);
} //}
} }
} }
} }

187
RedisStuy/RedisHashStudy.cs
Unescape Escape View File

@ -16,163 +16,156 @@ namespace RedisStuy
public class RedisHashStudy public class RedisHashStudy
{ {
#region 初始化 #region 初始化
private string studentHashKey = "student:hask:";
private IDatabase redisDatabase = RedisHelper.GetRedisDatabase(); private IDatabase redisDatabase = RedisHelper.GetRedisDatabase();
#endregion #endregion
/// <summary> /// <summary>
/// 添加一个学生 /// 整数减少hash中，指定列的值
/// key不存在，则创建一个持有哈希的新密钥。
/// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
/// </summary> /// </summary>
public bool AddStudent(Student student) public long HashDecrement(RedisKey key, RedisValue hashField, long value=1, CommandFlags flags=CommandFlags.None)
{
try
{ {
HashEntry[] hashEntries = new HashEntry[] return redisDatabase.HashDecrement(key, hashField, value, flags);
{
new HashEntry("Id",student.Id),
new HashEntry("Name",student.Name),
new HashEntry("Age",student.Age),
};
redisDatabase.HashSet(studentHashKey + student.Id, hashEntries, CommandFlags.None);
return true;
} }
catch
/// <summary>
/// 浮点数减少hash中，指定列的值
/// key不存在，则创建一个持有哈希的新密钥。
/// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
/// </summary>
public double HashDecrement(RedisKey key, RedisValue hashField, double value = 1, CommandFlags flags = CommandFlags.None)
{ {
return false; return redisDatabase.HashDecrement(key, hashField, value, flags);
}
} }
/// <summary> /// <summary>
/// 添加多个学生 /// 删除哈希表中指定字段，不存在的字段将被忽略
/// </summary> /// </summary>
public bool AddStudents(List<Student> students) public bool HashDelete(RedisKey key, RedisValue hashField, CommandFlags flags=CommandFlags.None)
{
try
{
foreach (var student in students)
{ {
AddStudent(student); return redisDatabase.HashDelete(key, hashField, flags);
} }
return true;
} /// <summary>
catch /// 删除哈希表中多个指定字段，不存在的字段将被忽略
/// </summary>
public long HashDelete(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None)
{ {
return false; return redisDatabase.HashDelete(key, hashFields, flags);
}
} }
/// <summary> /// <summary>
/// 删除一个学生 /// 哈希表中指定字段是否存在
/// </summary> /// </summary>
public bool DelStudentById(int studentId) public bool HashExists(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None)
{ {
return redisDatabase.KeyDelete(studentHashKey + studentId); return redisDatabase.HashExists(key, hashField, flags);
} }
/// <summary> /// <summary>
/// 查询一个学生 /// 获取哈希表中指定字段的值
/// </summary> /// </summary>
public Student QueryOneStudent(int studentId) public RedisValue HashGet(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None)
{ {
Student student = null; return redisDatabase.HashGet(key, hashField, flags);
}
var studentHashEntryList = redisDatabase.HashGetAll(studentHashKey + studentId); /// <summary>
if (studentHashEntryList.Length > 0) /// 获取哈希表中一组字段的一组值
{ /// </summary>
student = new Student(); public RedisValue[] HashGet(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None)
foreach (var temp in studentHashEntryList)
{
switch (temp.Name)
{ {
case "Id": return redisDatabase.HashGet(key, hashFields, flags);
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>
/// 查询一个学生 /// 获取哈希表所有字段
/// </summary> /// </summary>
public Student QueryOneStudent(string redisKey) public HashEntry[] HashGetAll(RedisKey key, CommandFlags flags = CommandFlags.None)
{ {
Student student = null; return redisDatabase.HashGetAll(key, flags);
}
var studentHashEntryList = redisDatabase.HashGetAll(redisKey); /// <summary>
if (studentHashEntryList.Length > 0) /// 整数增加hash中，指定列的值
{ /// key不存在，则创建一个持有哈希的新密钥。
student = new Student(); /// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
foreach (var temp in studentHashEntryList) /// </summary>
{ public long HashIncrement(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None)
switch (temp.Name)
{ {
case "Id": return redisDatabase.HashIncrement(key, hashField, value, flags);
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;
}
} }
/// <summary>
/// 浮点数增加hash中，指定列的值
/// key不存在，则创建一个持有哈希的新密钥。
/// hashField字段不存在或持有不能被解释为整数的字符串，则在执行前将该值设置为0
/// </summary>
public double HashIncrement(RedisKey key, RedisValue hashField, double value = 1, CommandFlags flags = CommandFlags.None)
{
return redisDatabase.HashIncrement(key, hashField, value, flags);
} }
return student;
/// <summary>
/// 获取哈希表中所有的字段
/// </summary>
public RedisValue[] HashKeys(RedisKey key, CommandFlags flags=CommandFlags.None)
{
return redisDatabase.HashKeys(key, flags);
} }
/// <summary> /// <summary>
/// 查询 所有学生 /// 获取哈希表中字段的数量
/// </summary> /// </summary>
/// <returns></returns> public long HashLength(RedisKey key, CommandFlags flags = CommandFlags.None)
public List<Student> QueryAllStudents()
{ {
List<Student> students = new List<Student>(); return redisDatabase.HashLength(key, flags);
}
var studdentKeys = RedisHelper.GetDefaultRedisServer().Keys(1, studentHashKey + "*", 200); /// <summary>
foreach (var key in studdentKeys) /// 获取哈希表中所有字段的值
/// </summary>
public RedisValue[] HashValues(RedisKey key, CommandFlags flags = CommandFlags.None)
{ {
students.Add(QueryOneStudent(key)); 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> /// <summary>
/// 查询某项的值 /// 同时将多个 field-value (字段-值)对设置到哈希表中。
/// 此命令会覆盖哈希表中已存在的字段。
/// 如果哈希表不存在，会创建一个空哈希表，并执行 HMSET 操作。
/// </summary> /// </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> /// <summary>
/// 更新一列的值 /// HSCAN命令用于对哈希进行增量迭代
/// </summary> /// </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> /// <summary>
/// 学生是否存在 /// HSCAN命令用于对哈希进行增量迭代；
/// 注意：通过光标恢复迭代，将原始枚举或枚举器转换为ISCANIN光标。
/// </summary> /// </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 redisDatabase.HashScan(key, pattern, pageSize,cursor,pageOffset, flags);
return exists;
} }
} }
} }

Write Preview
Loading…
Cancel
Save