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

62
RedisStudyTest/RedisHashStudyTest.cs
Unescape Escape View File

@ -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);
//}
}
}
}

199
RedisStuy/RedisHashStudy.cs
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save