|
|
using HslCommunication.Core;
|
|
|
using HslCommunication.Core.IMessage;
|
|
|
using HslCommunication.Core.Net;
|
|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Net.Sockets;
|
|
|
using System.Text;
|
|
|
using System.IO;
|
|
|
|
|
|
namespace HslCommunication.Enthernet.Redis
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// 这是一个redis的客户端类，支持读取，写入，发布订阅，但是不支持订阅，如果需要订阅，请使用另一个类
|
|
|
/// </summary>
|
|
|
public class RedisClient : NetworkDoubleBase<HslMessage, RegularByteTransform>
|
|
|
{
|
|
|
#region Constructor
|
|
|
|
|
|
/// <summary>
|
|
|
/// 实例化一个客户端的对象，用于和服务器通信
|
|
|
/// </summary>
|
|
|
/// <param name="ipAddress">服务器的ip地址</param>
|
|
|
/// <param name="port">服务器的端口号</param>
|
|
|
/// <param name="password">密码，如果服务器没有设置，密码设置为null</param>
|
|
|
public RedisClient( string ipAddress, int port, string password )
|
|
|
{
|
|
|
IpAddress = ipAddress;
|
|
|
Port = port;
|
|
|
ReceiveTimeOut = 30000;
|
|
|
this.password = password;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 实例化一个客户端对象，需要手动指定Ip地址和端口
|
|
|
/// </summary>
|
|
|
/// <param name="password">密码，如果服务器没有设置，密码设置为null</param>
|
|
|
public RedisClient( string password )
|
|
|
{
|
|
|
ReceiveTimeOut = 30000;
|
|
|
this.password = password;
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Override
|
|
|
|
|
|
/// <summary>
|
|
|
/// 如果设置了密码，对密码进行验证
|
|
|
/// </summary>
|
|
|
/// <param name="socket">网络的套接字服务</param>
|
|
|
/// <returns>是否成功的对象</returns>
|
|
|
protected override OperateResult InitializationOnConnect( Socket socket )
|
|
|
{
|
|
|
if (!string.IsNullOrEmpty( this.password ))
|
|
|
{
|
|
|
byte[] command = RedisHelper.PackStringCommand( new string[] { "AUTH", this.password } );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer(socket, command );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<string>( read );
|
|
|
|
|
|
string msg = Encoding.UTF8.GetString( read.Content );
|
|
|
if (!msg.StartsWith( "+" )) return new OperateResult<string>( msg );
|
|
|
|
|
|
return OperateResult.CreateSuccessResult( msg.Substring( 1 ).TrimEnd( '\r', '\n' ) );
|
|
|
}
|
|
|
return base.InitializationOnConnect( socket );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 在其他指定的套接字上，使用报文来通讯，传入需要发送的消息，返回一条完整的数据指令
|
|
|
/// </summary>
|
|
|
/// <param name="socket">指定的套接字</param>
|
|
|
/// <param name="send">发送的完整的报文信息</param>
|
|
|
/// <remarks>
|
|
|
/// 无锁的基于套接字直接进行叠加协议的操作。
|
|
|
/// </remarks>
|
|
|
/// <example>
|
|
|
/// 假设你有一个自己的socket连接了设备，本组件可以直接基于该socket实现modbus读取，三菱读取，西门子读取等等操作，前提是该服务器支持多协议，虽然这个需求听上去比较变态，但本组件支持这样的操作。
|
|
|
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDoubleBase.cs" region="ReadFromCoreServerExample1" title="ReadFromCoreServer示例" />
|
|
|
/// </example>
|
|
|
/// <returns>接收的完整的报文信息</returns>
|
|
|
public override OperateResult<byte[]> ReadFromCoreServer( Socket socket, byte[] send )
|
|
|
{
|
|
|
OperateResult sendResult = Send( socket, send );
|
|
|
if (!sendResult.IsSuccess) return OperateResult.CreateFailedResult<byte[]>( sendResult );
|
|
|
|
|
|
string tmp = BasicFramework.SoftBasic.ByteToHexString( send, ' ' );
|
|
|
// 接收超时时间大于0时才允许接收远程的数据
|
|
|
if (ReceiveTimeOut < 0) return OperateResult.CreateSuccessResult( new byte[0] );
|
|
|
|
|
|
// 接收数据信息
|
|
|
return RedisHelper.ReceiveCommand( socket );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Customer
|
|
|
|
|
|
/// <summary>
|
|
|
/// 自定义的指令交互方法，该指令用空格分割，举例：LTRIM AAAAA 0 999 就是收缩列表，GET AAA 就是获取键值，需要对返回的数据进行二次分析
|
|
|
/// </summary>
|
|
|
/// <param name="command">举例：LTRIM AAAAA 0 999 就是收缩列表，GET AAA 就是获取键值</param>
|
|
|
/// <returns>从服务器返回的结果数据对象</returns>
|
|
|
public OperateResult<string> ReadCustomer( string command )
|
|
|
{
|
|
|
byte[] byteCommand = RedisHelper.PackStringCommand( command.Split( ' ' ) );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer( byteCommand );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<string>( read );
|
|
|
|
|
|
return OperateResult.CreateSuccessResult( Encoding.UTF8.GetString( read.Content ) );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Base Operate
|
|
|
|
|
|
/// <summary>
|
|
|
/// 向服务器请求指定，并返回数字的结果对象
|
|
|
/// </summary>
|
|
|
/// <param name="commands">命令数组</param>
|
|
|
/// <returns>数字的结果对象</returns>
|
|
|
public OperateResult<int> OperateNumberFromServer(string[] commands)
|
|
|
{
|
|
|
byte[] command = RedisHelper.PackStringCommand( commands );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer( command );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<int>( read );
|
|
|
|
|
|
string msg = Encoding.UTF8.GetString( read.Content );
|
|
|
if (!msg.StartsWith( ":" )) return new OperateResult<int>( msg );
|
|
|
|
|
|
return RedisHelper.GetNumberFromCommandLine( read.Content );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 向服务器请求指令，并返回long数字的结果对象
|
|
|
/// </summary>
|
|
|
/// <param name="commands">命令数组</param>
|
|
|
/// <returns>long数字的结果对象</returns>
|
|
|
public OperateResult<long> OperateLongNumberFromServer(string[] commands)
|
|
|
{
|
|
|
byte[] command = RedisHelper.PackStringCommand( commands );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer( command );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<long>( read );
|
|
|
|
|
|
string msg = Encoding.UTF8.GetString( read.Content );
|
|
|
if (!msg.StartsWith( ":" )) return new OperateResult<long>( msg );
|
|
|
|
|
|
return RedisHelper.GetLongNumberFromCommandLine( read.Content );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 向服务器请求指令，并返回字符串的结果对象
|
|
|
/// </summary>
|
|
|
/// <param name="commands">命令数组</param>
|
|
|
/// <returns>字符串的结果对象</returns>
|
|
|
public OperateResult<string> OperateStringFromServer(string[] commands)
|
|
|
{
|
|
|
byte[] command = RedisHelper.PackStringCommand( commands );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer( command );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<string>( read );
|
|
|
|
|
|
return RedisHelper.GetStringFromCommandLine( read.Content );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 向服务器请求指令，并返回字符串数组的结果对象
|
|
|
/// </summary>
|
|
|
/// <param name="commands">命令数组</param>
|
|
|
/// <returns>字符串数组的结果对象</returns>
|
|
|
public OperateResult<string[]> OperateStringsFromServer(string[] commands)
|
|
|
{
|
|
|
byte[] command = RedisHelper.PackStringCommand( commands );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer( command );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<string[]>( read );
|
|
|
|
|
|
return RedisHelper.GetStringsFromCommandLine( read.Content );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 向服务器请求指令，并返回状态的结果对象，通常用于写入的判断，或是请求类型的判断
|
|
|
/// </summary>
|
|
|
/// <param name="commands">命令数组</param>
|
|
|
/// <returns>是否成功的结果对象</returns>
|
|
|
public OperateResult<string> OperateStatusFromServer(string[] commands)
|
|
|
{
|
|
|
byte[] command = RedisHelper.PackStringCommand( commands );
|
|
|
|
|
|
OperateResult<byte[]> read = ReadFromCoreServer( command );
|
|
|
if (!read.IsSuccess) return OperateResult.CreateFailedResult<string>( read );
|
|
|
|
|
|
string msg = Encoding.UTF8.GetString( read.Content );
|
|
|
if (!msg.StartsWith( "+" )) return new OperateResult<string>( msg );
|
|
|
|
|
|
return OperateResult.CreateSuccessResult( msg.Substring( 1 ).TrimEnd( '\r', '\n' ) );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Key Operate
|
|
|
|
|
|
/// <summary>
|
|
|
/// 删除给定的一个或多个 key 。不存在的 key 会被忽略。
|
|
|
/// </summary>
|
|
|
/// <param name="keys">关键字</param>
|
|
|
/// <returns>被删除 key 的数量。</returns>
|
|
|
public OperateResult<int> DeleteKey( string[] keys )
|
|
|
{
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "DEL" );
|
|
|
list.AddRange( keys );
|
|
|
|
|
|
return OperateNumberFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 删除给定的一个或多个 key 。不存在的 key 会被忽略。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>被删除 key 的数量。</returns>
|
|
|
public OperateResult<int> DeleteKey( string key )
|
|
|
{
|
|
|
return DeleteKey( new string[] { key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 检查给定 key 是否存在。若 key 存在，返回 1 ，否则返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>若 key 存在，返回 1 ，否则返回 0 。</returns>
|
|
|
public OperateResult<int> ExistsKey( string key )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "EXISTS", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。设置成功返回 1 。当 key 不存在或者不能为 key 设置生存时间时，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>
|
|
|
/// 设置成功返回 1 。当 key 不存在或者不能为 key 设置生存时间时，返回 0 。
|
|
|
/// </returns>
|
|
|
public OperateResult<int> ExpireKey( string key )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "EXPIRE", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 查找所有符合给定模式 pattern 的 key 。
|
|
|
/// * 匹配数据库中所有 key。
|
|
|
/// h?llo 匹配 hello ， hallo 和 hxllo 等。
|
|
|
/// h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
|
|
|
/// </summary>
|
|
|
/// <param name="pattern">给定模式</param>
|
|
|
/// <returns>符合给定模式的 key 列表。</returns>
|
|
|
public OperateResult<string[]> ReadAllKeys( string pattern )
|
|
|
{
|
|
|
return OperateStringsFromServer( new string[] { "KEYS", pattern } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将当前数据库的 key 移动到给定的数据库 db 当中。
|
|
|
/// 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
|
|
|
/// 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="db">数据块</param>
|
|
|
/// <returns>是否移动成功</returns>
|
|
|
public OperateResult MoveKey( string key, int db )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "MOVE", key, db.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
|
|
|
/// 当生存时间移除成功时，返回 1 .
|
|
|
/// 如果 key 不存在或 key 没有设置生存时间，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>
|
|
|
/// 当生存时间移除成功时，返回 1 .
|
|
|
/// 如果 key 不存在或 key 没有设置生存时间，返回 0 。
|
|
|
/// </returns>
|
|
|
public OperateResult<int> PersistKey( string key )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "PERSIST", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 从当前数据库中随机返回(不删除)一个 key 。
|
|
|
/// 当数据库不为空时，返回一个 key 。
|
|
|
/// 当数据库为空时，返回 nil 。
|
|
|
/// </summary>
|
|
|
/// <returns>
|
|
|
/// 当数据库不为空时，返回一个 key 。
|
|
|
/// 当数据库为空时，返回 nil 。
|
|
|
/// </returns>
|
|
|
public OperateResult<string> ReadRandomKey( )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "RANDOMKEY" } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 改名为 newkey 。
|
|
|
/// 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
|
|
|
/// 当 newkey 已经存在时， RENAME 命令将覆盖旧值。
|
|
|
/// </summary>
|
|
|
/// <param name="key1">旧的key</param>
|
|
|
/// <param name="key2">新的key</param>
|
|
|
/// <returns>
|
|
|
/// 改名成功时提示 OK ，失败时候返回一个错误。
|
|
|
/// </returns>
|
|
|
public OperateResult RenameKey( string key1, string key2 )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "RENAME", key1, key2 } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回 key 所储存的值的类型。none (key不存在)，string (字符串)，list (列表)，set (集合)，zset (有序集)，hash (哈希表)
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>类型</returns>
|
|
|
public OperateResult<string> ReadKeyType( string key )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "TYPE", key } );
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region String Operate
|
|
|
|
|
|
/// <summary>
|
|
|
/// 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
|
|
|
/// 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
|
|
|
/// 返回追加 value 之后， key 中字符串的长度。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数值</param>
|
|
|
/// <returns>
|
|
|
/// 追加 value 之后， key 中字符串的长度。
|
|
|
/// </returns>
|
|
|
public OperateResult<int> AppendKey( string key, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "APPEND", key, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 中储存的数字值减一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
|
|
|
/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
|
|
|
/// 本操作的值限制在 64 位(bit)有符号数字表示之内。
|
|
|
/// 返回执行 DECR 命令之后 key 的值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>执行 DECR 命令之后 key 的值。</returns>
|
|
|
public OperateResult<long> DecrementKey( string key )
|
|
|
{
|
|
|
return OperateLongNumberFromServer( new string[] { "DECR", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 所储存的值减去减量 decrement 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
|
|
|
/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
|
|
|
/// 本操作的值限制在 64 位(bit)有符号数字表示之内。
|
|
|
/// 返回减去 decrement 之后， key 的值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">操作的值</param>
|
|
|
/// <returns>返回减去 decrement 之后， key 的值。</returns>
|
|
|
public OperateResult<long> DecrementKey( string key, long value )
|
|
|
{
|
|
|
return OperateLongNumberFromServer( new string[] { "DECRBY", key, value.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回 key 所关联的字符串值。如果 key 不存在那么返回特殊值 nil 。
|
|
|
/// 假如 key 储存的值不是字符串类型，返回一个错误，因为 GET 只能用于处理字符串值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>当 key 不存在时，返回 nil ，否则，返回 key 的值。</returns>
|
|
|
public OperateResult<string> ReadKey( string key )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "GET", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。
|
|
|
/// 负数偏移量表示从字符串最后开始计数， -1 表示最后一个字符， -2 表示倒数第二个，以此类推。
|
|
|
/// 返回截取得出的子字符串。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="start">截取开始的位置</param>
|
|
|
/// <param name="end">截取结束的位置</param>
|
|
|
/// <returns>返回截取得出的子字符串。</returns>
|
|
|
public OperateResult<string> ReadKeyRange( string key, int start, int end )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "GETRANGE", key, start.ToString( ), end.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。当 key 存在但不是字符串类型时，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">新的值</param>
|
|
|
/// <returns>返回给定 key 的旧值。当 key 没有旧值时，也即是， key 不存在时，返回 nil 。</returns>
|
|
|
public OperateResult<string> ReadAndWriteKey( string key, string value )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "GETSET", key, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 中储存的数字值增一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
|
|
|
/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
|
|
|
/// 返回执行 INCR 命令之后 key 的值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>返回执行 INCR 命令之后 key 的值。</returns>
|
|
|
public OperateResult<long> IncrementKey( string key )
|
|
|
{
|
|
|
return OperateLongNumberFromServer( new string[] { "INCR", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 所储存的值加上增量 increment 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
|
|
|
/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">增量数据</param>
|
|
|
/// <returns>加上 increment 之后， key 的值。</returns>
|
|
|
public OperateResult<long> IncrementKey( string key, long value )
|
|
|
{
|
|
|
return OperateLongNumberFromServer( new string[] { "INCRBY", key, value.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 所储存的值加上增量 increment 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBYFLOAT 操作。
|
|
|
/// 如果命令执行成功，那么 key 的值会被更新为（执行加法之后的）新值，并且新值会以字符串的形式返回给调用者
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">增量数据</param>
|
|
|
/// <returns>执行命令之后 key 的值。</returns>
|
|
|
public OperateResult<string> IncrementKey( string key, float value )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "INCRBYFLOAT", key, value.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回所有(一个或多个)给定 key 的值。
|
|
|
/// 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 null 。因此，该命令永不失败。
|
|
|
/// </summary>
|
|
|
/// <param name="keys">关键字数组</param>
|
|
|
/// <returns>一个包含所有给定 key 的值的列表。</returns>
|
|
|
public OperateResult<string[]> ReadKey( string[] keys )
|
|
|
{
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "MGET" );
|
|
|
list.AddRange( keys );
|
|
|
|
|
|
return OperateStringsFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 同时设置一个或多个 key-value 对。
|
|
|
/// 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。
|
|
|
/// </summary>
|
|
|
/// <param name="keys">关键字数组</param>
|
|
|
/// <param name="values">值数组</param>
|
|
|
/// <returns>总是返回 OK (因为 MSET 不可能失败)</returns>
|
|
|
public OperateResult WriteKey( string[] keys, string[] values )
|
|
|
{
|
|
|
if (keys == null) throw new ArgumentNullException( "keys" );
|
|
|
if (values == null) throw new ArgumentNullException( "values" );
|
|
|
if (keys.Length != values.Length) throw new ArgumentException( "Two arguement not same length" );
|
|
|
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "MSET" );
|
|
|
for (int i = 0; i < keys.Length; i++)
|
|
|
{
|
|
|
list.Add( keys[i] );
|
|
|
list.Add( values[i] );
|
|
|
}
|
|
|
|
|
|
return OperateStatusFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将字符串值 value 关联到 key 。
|
|
|
/// 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
|
|
|
/// 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <returns> SET 在设置操作成功完成时，才返回 OK 。</returns>
|
|
|
public OperateResult WriteKey( string key, string value )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "SET", key, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将字符串值 value 关联到 key 。并发布一个订阅的频道数据，都成功时，才返回成功
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <returns>是否成功的结果对象</returns>
|
|
|
public OperateResult WriteAndPublishKey(string key, string value )
|
|
|
{
|
|
|
OperateResult write = WriteKey( key, value );
|
|
|
if (!write.IsSuccess) return write;
|
|
|
|
|
|
return Publish( key, value );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。如果 key 已经存在， SETEX 命令将覆写旧值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数值</param>
|
|
|
/// <param name="seconds">生存时间，单位秒</param>
|
|
|
/// <returns>设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。</returns>
|
|
|
public OperateResult WriteExpireKey( string key, string value, long seconds )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "SETEX", key, seconds.ToString( ), value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 SETNX 不做任何动作。设置成功，返回 1 。设置失败，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <returns>设置成功，返回 1 。设置失败，返回 0 。</returns>
|
|
|
public OperateResult<int> WriteKeyIfNotExists( string key, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "SETNX", key, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始。不存在的 key 当作空白字符串处理。返回被 SETRANGE 修改之后，字符串的长度。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数值</param>
|
|
|
/// <param name="offset">起始的偏移量</param>
|
|
|
/// <returns>被 SETRANGE 修改之后，字符串的长度。</returns>
|
|
|
public OperateResult<int> WriteKeyRange( string key, string value, int offset )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "SETRANGE", key, offset.ToString( ), value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回 key 所储存的字符串值的长度。当 key 储存的不是字符串值时，返回一个错误。返回符串值的长度。当 key 不存在时，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>字符串值的长度。当 key 不存在时，返回 0 。</returns>
|
|
|
public OperateResult<int> ReadKeyLength( string key )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "STRLEN", key } );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region List Operate
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将值 value 插入到列表 key 当中，位于值 pivot 之前。
|
|
|
/// 当 pivot 不存在于列表 key 时，不执行任何操作。
|
|
|
/// 当 key 不存在时， key 被视为空列表，不执行任何操作。
|
|
|
/// 如果 key 不是列表类型，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数值</param>
|
|
|
/// <param name="pivot">原先的值</param>
|
|
|
/// <returns>
|
|
|
/// 如果命令执行成功，返回插入操作完成之后，列表的长度。
|
|
|
/// 如果没有找到 pivot ，返回 -1 。
|
|
|
/// 如果 key 不存在或为空列表，返回 0 。
|
|
|
/// </returns>
|
|
|
public OperateResult<int> ListInsertBefore( string key, string value, string pivot )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "LINSERT", key, "BEFORE", pivot, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将值 value 插入到列表 key 当中，位于值 pivot 之后。
|
|
|
/// 当 pivot 不存在于列表 key 时，不执行任何操作。
|
|
|
/// 当 key 不存在时， key 被视为空列表，不执行任何操作。
|
|
|
/// 如果 key 不是列表类型，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">数值</param>
|
|
|
/// <param name="pivot">原先的值</param>
|
|
|
/// <returns>
|
|
|
/// 如果命令执行成功，返回插入操作完成之后，列表的长度。
|
|
|
/// 如果没有找到 pivot ，返回 -1 。
|
|
|
/// 如果 key 不存在或为空列表，返回 0 。
|
|
|
/// </returns>
|
|
|
public OperateResult<int> ListInsertAfter( string key, string value, string pivot )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "LINSERT", key, "AFTER", pivot, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回列表 key 的长度。如果 key 不存在，则 key 被解释为一个空列表，返回 0 .如果 key 不是列表类型，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>列表 key 的长度。</returns>
|
|
|
public OperateResult<int> GetListLength( string key )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "LLEN", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回列表 key 中，下标为 index 的元素。下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
|
|
|
/// 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。如果 key 不是列表类型，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="index">索引位置</param>
|
|
|
/// <returns>列表中下标为 index 的元素。如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。</returns>
|
|
|
public OperateResult<string> ReadListByIndex( string key, long index )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "LINDEX", key, index.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除并返回列表 key 的头元素。列表的头元素。当 key 不存在时，返回 nil 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字信息</param>
|
|
|
/// <returns>列表的头元素。</returns>
|
|
|
public OperateResult<string> ListLeftPop( string key )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "LPOP", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将一个或多个值 value 插入到列表 key 的表头，如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。返回执行 LPUSH 命令后，列表的长度。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">值</param>
|
|
|
/// <returns>执行 LPUSH 命令后，列表的长度。</returns>
|
|
|
public OperateResult<int> ListLeftPush( string key, string value )
|
|
|
{
|
|
|
return ListLeftPush( key, new string[] { value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将一个或多个值 value 插入到列表 key 的表头，如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。返回执行 LPUSH 命令后，列表的长度。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="values">值</param>
|
|
|
/// <returns>执行 LPUSH 命令后，列表的长度。</returns>
|
|
|
public OperateResult<int> ListLeftPush( string key, string[] values )
|
|
|
{
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "LPUSH" );
|
|
|
list.Add( key );
|
|
|
list.AddRange( values );
|
|
|
|
|
|
return OperateNumberFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。和 LPUSH 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。
|
|
|
/// 返回LPUSHX 命令执行之后，表的长度。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">值</param>
|
|
|
/// <returns>是否插入数据成功</returns>
|
|
|
public OperateResult<int> ListLeftPushX( string key, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "LPUSHX", key, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
|
|
|
/// 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
|
|
|
/// 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
|
|
|
/// 返回一个列表，包含指定区间内的元素。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="start">开始的索引</param>
|
|
|
/// <param name="stop">结束的索引</param>
|
|
|
/// <returns>返回一个列表，包含指定区间内的元素。</returns>
|
|
|
public OperateResult<string[]> ListRange( string key, long start, long stop )
|
|
|
{
|
|
|
return OperateStringsFromServer( new string[] { "LRANGE", key, start.ToString( ), stop.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 根据参数 count 的值，移除列表中与参数 value 相等的元素。count 的值可以是以下几种：
|
|
|
/// count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
|
|
|
/// count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
|
|
|
/// count = 0 : 移除表中所有与 value 相等的值。
|
|
|
/// 返回被移除的数量。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="count">移除参数</param>
|
|
|
/// <param name="value">匹配的值</param>
|
|
|
/// <returns>被移除元素的数量。因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。</returns>
|
|
|
public OperateResult<int> ListRemoveElementMatch( string key, long count, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "LREM", key, count.ToString( ), value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 设置数组的某一个索引的数据信息，当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="index">索引位置</param>
|
|
|
/// <param name="value">值</param>
|
|
|
/// <returns>操作成功返回 ok ，否则返回错误信息。</returns>
|
|
|
public OperateResult ListSet( string key, long index, string value )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "LSET", key.ToString( ), index.ToString( ), value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
|
|
|
/// 举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
|
|
|
/// 下标( index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
|
|
|
/// 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
|
|
|
/// 当 key 不是列表类型时，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字信息</param>
|
|
|
/// <param name="start">起始的索引信息</param>
|
|
|
/// <param name="end">结束的索引信息</param>
|
|
|
/// <returns>操作成功返回 ok ，否则返回错误信息。</returns>
|
|
|
public OperateResult ListTrim( string key, long start, long end )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "LTRIM", key, start.ToString( ), end.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除并返回列表 key 的尾元素。当 key 不存在时，返回 nil 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字信息</param>
|
|
|
/// <returns>列表的尾元素。</returns>
|
|
|
public OperateResult<string> ListRightPop( string key )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "RPOP", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：
|
|
|
/// 1. 将列表 source 中的最后一个元素( 尾元素)弹出，并返回给客户端。
|
|
|
/// 2. 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
|
|
|
/// 举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。
|
|
|
/// 如果 source 不存在，值 nil 被返回，并且不执行其他动作。
|
|
|
/// 如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转( rotation)操作。
|
|
|
/// </summary>
|
|
|
/// <param name="key1">第一个关键字</param>
|
|
|
/// <param name="key2">第二个关键字</param>
|
|
|
/// <returns>返回的移除的对象</returns>
|
|
|
public OperateResult<string> ListRightPopLeftPush( string key1, string key2 )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "RPOPLPUSH", key1, key2 } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
|
|
|
/// 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">值</param>
|
|
|
/// <returns>返回执行 RPUSH 操作后，表的长度。</returns>
|
|
|
public OperateResult<int> ListRightPush( string key, string value )
|
|
|
{
|
|
|
return ListRightPush( key, new string[] { value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
|
|
|
/// 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，
|
|
|
/// 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。
|
|
|
/// 返回执行 RPUSH 操作后，表的长度。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="values">值</param>
|
|
|
/// <returns>返回执行 RPUSH 操作后，表的长度。</returns>
|
|
|
public OperateResult<int> ListRightPush( string key, string[] values )
|
|
|
{
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "RPUSH" );
|
|
|
list.Add( key );
|
|
|
list.AddRange( values );
|
|
|
|
|
|
return OperateNumberFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
|
|
|
/// 和 RPUSH 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="value">值</param>
|
|
|
/// <returns>RPUSHX 命令执行之后，表的长度。</returns>
|
|
|
public OperateResult<int> ListRightPushX( string key, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "RPUSHX", key, value } );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Hash Operate
|
|
|
|
|
|
/// <summary>
|
|
|
/// 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <returns>被成功移除的域的数量，不包括被忽略的域。</returns>
|
|
|
public OperateResult<int> DeleteHashKey( string key, string field )
|
|
|
{
|
|
|
return DeleteHashKey( key, new string[] { field } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。返回被成功移除的域的数量，不包括被忽略的域。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="fields">所有的域</param>
|
|
|
/// <returns>返回被成功移除的域的数量，不包括被忽略的域。</returns>
|
|
|
public OperateResult<int> DeleteHashKey( string key, string[] fields )
|
|
|
{
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "HDEL" );
|
|
|
list.Add( key );
|
|
|
list.AddRange( fields );
|
|
|
|
|
|
return OperateNumberFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 查看哈希表 key 中，给定域 field 是否存在。如果哈希表含有给定域，返回 1 。
|
|
|
/// 如果哈希表不含有给定域，或 key 不存在，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <returns>如果哈希表含有给定域，返回 1 。如果哈希表不含有给定域，或 key 不存在，返回 0 。</returns>
|
|
|
public OperateResult<int> ExistsHashKey( string key, string field )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "HEXISTS", key, field } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回哈希表 key 中给定域 field 的值。当给定域不存在或是给定 key 不存在时，返回 nil
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键值</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <returns>
|
|
|
/// 给定域的值。
|
|
|
/// 当给定域不存在或是给定 key 不存在时，返回 nil 。
|
|
|
/// </returns>
|
|
|
public OperateResult<string> ReadHashKey( string key, string field )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "HGET", key, field } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回哈希表 key 中，所有的域和值。在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键值</param>
|
|
|
/// <returns>
|
|
|
/// 以列表形式返回哈希表的域和域的值。
|
|
|
/// 若 key 不存在，返回空列表。
|
|
|
/// </returns>
|
|
|
public OperateResult<string[]> ReadHashKeyAll( string key )
|
|
|
{
|
|
|
return OperateStringsFromServer( new string[] { "HGETALL", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。
|
|
|
/// 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <param name="value">增量值</param>
|
|
|
/// <returns>返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。</returns>
|
|
|
public OperateResult<long> IncrementHashKey( string key, string field, long value )
|
|
|
{
|
|
|
return OperateLongNumberFromServer( new string[] { "HINCRBY", key, field, value.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。
|
|
|
/// 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <param name="value">增量值</param>
|
|
|
/// <returns>返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。</returns>
|
|
|
public OperateResult<string> IncrementHashKey( string key, string field, float value )
|
|
|
{
|
|
|
return OperateStringFromServer( new string[] { "HINCRBYFLOAT", key, field, value.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回哈希表 key 中的所有域。当 key 不存在时，返回一个空表。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键值</param>
|
|
|
/// <returns>
|
|
|
/// 一个包含哈希表中所有域的表。
|
|
|
/// 当 key 不存在时，返回一个空表。
|
|
|
/// </returns>
|
|
|
public OperateResult<string[]> ReadHashKeys( string key )
|
|
|
{
|
|
|
return OperateStringsFromServer( new string[] { "HKEYS", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回哈希表 key 中域的数量。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>哈希表中域的数量。当 key 不存在时，返回 0 。</returns>
|
|
|
public OperateResult<int> ReadHashKeyLength( string key )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "HLEN", key } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。
|
|
|
/// 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键值</param>
|
|
|
/// <param name="fields">指定的域</param>
|
|
|
/// <returns>
|
|
|
/// 一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。
|
|
|
/// </returns>
|
|
|
public OperateResult<string[]> ReadHashKey( string key, string[] fields )
|
|
|
{
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "HMGET" );
|
|
|
list.Add( key );
|
|
|
list.AddRange( fields );
|
|
|
|
|
|
return OperateStringsFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将哈希表 key 中的域 field 的值设为 value 。
|
|
|
/// 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
|
|
|
/// 如果域 field 已经存在于哈希表中，旧值将被覆盖。
|
|
|
/// 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
|
|
|
/// 如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <returns>
|
|
|
/// 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
|
|
|
/// 如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
|
|
|
/// </returns>
|
|
|
public OperateResult<int> WriteHashKey( string key, string field, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "HSET", key, field, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 同时将多个 field-value (域-值)对设置到哈希表 key 中。
|
|
|
/// 此命令会覆盖哈希表中已存在的域。
|
|
|
/// 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="fields">域</param>
|
|
|
/// <param name="values">数据值</param>
|
|
|
/// <returns>
|
|
|
/// 如果命令执行成功，返回 OK 。
|
|
|
/// 当 key 不是哈希表(hash)类型时，返回一个错误
|
|
|
/// </returns>
|
|
|
public OperateResult WriteHashKey( string key, string[] fields, string[] values )
|
|
|
{
|
|
|
if (fields == null) throw new ArgumentNullException( "fields" );
|
|
|
if (values == null) throw new ArgumentNullException( "values" );
|
|
|
if (fields.Length != values.Length) throw new ArgumentException( "Two arguement not same length" );
|
|
|
|
|
|
List<string> list = new List<string>( );
|
|
|
list.Add( "HMSET" );
|
|
|
list.Add( key );
|
|
|
for (int i = 0; i < fields.Length; i++)
|
|
|
{
|
|
|
list.Add( fields[i] );
|
|
|
list.Add( values[i] );
|
|
|
}
|
|
|
|
|
|
return OperateStatusFromServer( list.ToArray( ) );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。若域 field 已经存在，该操作无效。
|
|
|
/// 设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="field">域</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <returns>设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。</returns>
|
|
|
public OperateResult<int> WriteHashKeyNx( string key, string field, string value )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "HSETNX", key, field, value } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回哈希表 key 中所有域的值。当 key 不存在时，返回一个空表。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键值</param>
|
|
|
/// <returns>
|
|
|
/// 返回哈希表 key 中所有域的值。
|
|
|
/// 当 key 不存在时，返回一个空表。
|
|
|
/// </returns>
|
|
|
public OperateResult<string[]> ReadHashValues( string key )
|
|
|
{
|
|
|
return OperateStringsFromServer( new string[] { "HVALS", key } );
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Server Operate
|
|
|
|
|
|
/// <summary>
|
|
|
/// SAVE 命令执行一个同步保存操作，将当前 Redis 实例的所有数据快照(snapshot)以 RDB 文件的形式保存到硬盘。
|
|
|
/// </summary>
|
|
|
/// <returns>保存成功时返回 OK 。</returns>
|
|
|
public OperateResult Save( )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "SAVE" } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 在后台异步(Asynchronously)保存当前数据库的数据到磁盘。
|
|
|
/// BGSAVE 命令执行之后立即返回 OK ，然后 Redis fork 出一个新子进程，原来的 Redis 进程(父进程)继续处理客户端请求，而子进程则负责将数据保存到磁盘，然后退出。
|
|
|
/// </summary>
|
|
|
/// <returns>反馈信息。</returns>
|
|
|
public OperateResult SaveAsync( )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "BGSAVE" } );
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取服务器的时间戳信息，可用于本地时间的数据同步问题
|
|
|
/// </summary>
|
|
|
/// <returns>带有服务器时间的结果对象</returns>
|
|
|
public OperateResult<DateTime> ReadServerTime( )
|
|
|
{
|
|
|
OperateResult<string[]> times = OperateStringsFromServer( new string[] { "TIME" } );
|
|
|
if (!times.IsSuccess) return OperateResult.CreateFailedResult<DateTime>( times );
|
|
|
|
|
|
long timeTick = long.Parse( times.Content[0] );
|
|
|
DateTime dateTime = new DateTime( 1970, 1, 1, 8, 0, 0 ).AddSeconds( timeTick );
|
|
|
return OperateResult.CreateSuccessResult( dateTime );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Publish
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将信息 message 发送到指定的频道 channel，返回接收到信息 message 的订阅者数量。
|
|
|
/// </summary>
|
|
|
/// <param name="channel">频道，和关键字不是一回事</param>
|
|
|
/// <param name="message">消息</param>
|
|
|
/// <returns>接收到信息 message 的订阅者数量。</returns>
|
|
|
public OperateResult<int> Publish( string channel, string message )
|
|
|
{
|
|
|
return OperateNumberFromServer( new string[] { "PUBLISH", channel, message } );
|
|
|
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region DB Block
|
|
|
|
|
|
/// <summary>
|
|
|
/// 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。默认使用 0 号数据库。
|
|
|
/// </summary>
|
|
|
/// <param name="db">索引值</param>
|
|
|
/// <returns>是否切换成功</returns>
|
|
|
public OperateResult SelectDB( int db )
|
|
|
{
|
|
|
return OperateStatusFromServer( new string[] { "SELECT", db.ToString( ) } );
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Private Member
|
|
|
|
|
|
private string password = string.Empty; // 密码信息
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Object Override
|
|
|
|
|
|
/// <summary>
|
|
|
/// 返回表示当前对象的字符串
|
|
|
/// </summary>
|
|
|
/// <returns>字符串信息</returns>
|
|
|
public override string ToString( )
|
|
|
{
|
|
|
return $"RedisClient[{IpAddress}:{Port}]";
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
}
|
|
|
}
|