/// <summary>
/// 设置迭代器到指定键的位置。
/// </summary>
/// <param name="key">键。</param>
public void Seek(BinaryValue key)
{
var keyData = key.ByteArray;
LevelDBInterop.leveldb_iter_seek(this._handle, keyData, new IntPtr(keyData.LongLength));
CheckLastError();
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset.stringValue)
{
hashcode = (hashcode * 397) + StringValue.GetHashCode();
}
if (__isset.smallIntValue)
{
hashcode = (hashcode * 397) + SmallIntValue.GetHashCode();
}
if (__isset.integerBitmask)
{
hashcode = (hashcode * 397) + IntegerBitmask.GetHashCode();
}
if (__isset.integerFlag)
{
hashcode = (hashcode * 397) + IntegerFlag.GetHashCode();
}
if (__isset.binaryValue)
{
hashcode = (hashcode * 397) + BinaryValue.GetHashCode();
}
if (__isset.lenValue)
{
hashcode = (hashcode * 397) + LenValue.GetHashCode();
}
}
return(hashcode);
}
/// <summary>
/// Find the child value with the specified index.
/// </summary>
/// <param name="nIndex">
/// Index of the child value to find.
/// </param>
/// <param name="ofStart">
/// Offset within the parent buffer to start search from.
/// </param>
/// <param name="iStart">
/// Index of the child value to start search from.
/// </param>
/// <returns>
/// The child value.
/// </returns>
protected override IPofValue FindChildInternal(int nIndex, int ofStart, int iStart)
{
BinaryMemoryStream buf = (BinaryMemoryStream)BinaryValue.GetStream();
buf.Position = ofStart;
DataReader reader = new DataReader(buf);
// check array bounds
if (nIndex < 0 || nIndex >= Length)
{
throw new IndexOutOfRangeException(
"Element index " + nIndex + " must be in the range [0 .. "
+ Length + ").");
}
// skip children until we find the one we are looking for
int iProp = iStart;
while (iProp < nIndex)
{
SkipChild(reader);
iProp++;
}
// child found. parse it and return it
int of = (int)buf.Position;
SkipChild(reader);
int cb = (int)(buf.Position - of);
return(ExtractChild(of, cb));
}
public void Xor(Command cmd)
{
var values = this.RequireTwoBinaryValues(cmd);
var result = BinaryValue.Xor(values[0], values[1]);
cmd.Commit(result);
}
public void SerializeDeserializeEmpty()
{
BinaryValue expected = new BinaryValue(new byte[0]);
BinaryValue actual = SerializeDeserialize(expected);
Assert.AreEqual <BinaryValue>(expected, actual);
}
/// <summary>
/// 删除指定键。
/// </summary>
/// <param name="key">键。</param>
public WriteBatch Remove(BinaryValue key)
{
var keyData = key.ByteArray;
LevelDBInterop.leveldb_writebatch_delete(_handle, keyData, (IntPtr)keyData.Length);
return(this);
}
/// <summary>
/// Find the child value with the specified index.
/// </summary>
/// <param name="nIndex">
/// Index of the child value to find.
/// </param>
/// <param name="ofStart">
/// Offset within the parent buffer to start search from.
/// </param>
/// <param name="iStart">
/// Index of the child value to start search from.
/// </param>
/// <returns>
/// The child value.
/// </returns>
protected override IPofValue FindChildInternal(int nIndex, int ofStart, int iStart)
{
BinaryMemoryStream buf = (BinaryMemoryStream)BinaryValue.GetStream();
buf.Position = ofStart;
DataReader reader = new DataReader(buf);
// skip children until we either find the one we are looking for,
// or reach the end of the sparse array (index == -1)
int ofLastIndex = ofStart;
int iProp = reader.ReadPackedInt32();
while (iProp < nIndex && iProp >= 0)
{
SkipChild(reader);
ofLastIndex = (int)buf.Position;
iProp = reader.ReadPackedInt32();
}
// child found. extract it from the parent buffer
if (iProp == nIndex)
{
int of = (int)buf.Position;
SkipChild(reader);
int cb = (int)(buf.Position - of);
return(ExtractChild(of, cb));
}
// child not found
return(InstantiateNullValue(ofLastIndex, nIndex));
}
/// <summary>
/// 为有序集 <paramref name="key"/> 的成员 <paramref name="member"/> 的权重值加上增量 <paramref name="increment"/>。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">有序集的键名。</param>
/// <param name="increment">递增量。可以通过传递一个负数值 <paramref name="increment"/> ，让权重减去相应的值。</param>
/// <param name="member">有序集的成员。</param>
/// <returns>递增 <paramref name="increment"/> 之后 <paramref name="key"/> 的 <paramref name="member"/> 的权重值。</returns>
public static double ZIncrBy(this IRedisClient client, string key, double increment, BinaryValue member)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
if(member == null) throw new ArgumentNullException(nameof(member));
return client.Execute(new RedisFloat("ZINCRBY", key, increment, member));
}
public void Not(Command cmd)
{
this.RequireArgs(1);
this.RequireType(0, RpnValueType.Binary);
var value = (BinaryValue)cmd.UseTopValue();
cmd.Commit(BinaryValue.Not(value, this.Calc));
}
public void WhenDecodeAndDefaultStrategy()
{
var req1 = System.Text.Encoding.UTF8.GetBytes("Hello world! :)");
var val1 = new BinaryValue(req1, null);
var res1 = val1.Decode().Value;
res1.Should().Be("Hello world! :)");
}
public void WhenEncryptAndDefaultStrategy()
{
var req1 = System.Text.Encoding.UTF8.GetBytes("Hello world! :)");
var val1 = new BinaryValue(req1, null);
var res1 = val1.Encrypt().Value;
res1.SequenceEqual(req1).Should().BeTrue();
}
public void WhenDecryptAndDefaultStrategy()
{
var req2 = System.Text.Encoding.UTF8.GetBytes("Hello world! :)");
var val2 = new BinaryValue(req2, null);
var res2 = val2.Decrypt().Value;
res2.SequenceEqual(req2).Should().BeTrue();
}
/// <summary>
/// Extract child IPofValue from this value.
/// </summary>
/// <param name="of">
/// Offset of the child within this value.
/// </param>
/// <param name="cb">
/// Length of the child in bytes.
/// </param>
/// <returns>
/// The child value.
/// </returns>
protected IPofValue ExtractChild(int of, int cb)
{
return(IsUniformCollection
? PofValueParser.ParseUniformValue(this, m_nElementType,
BinaryValue.GetBinary(of, cb), PofContext, Offset + of)
: PofValueParser.ParseValue(this,
BinaryValue.GetBinary(of, cb), PofContext, Offset + of));
}
/// <summary>
/// 设置指定键的值。
/// </summary>
/// <param name="key">键。</param>
/// <param name="value">值。</param>
public WriteBatch Set(BinaryValue key, BinaryValue value)
{
var keyData = key.ByteArray;
var valueData = value.ByteArray;
LevelDBInterop.leveldb_writebatch_put(_handle, keyData, (IntPtr)keyData.LongLength, valueData, (IntPtr)valueData.LongLength);
return(this);
}
/// <summary>
/// 将 <paramref name="value"/> 追加到 <paramref name="key"/> 原来的值的末尾。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">键名。</param>
/// <param name="value">键值。</param>
/// <returns>追加 <paramref name="value"/> 之后，<paramref name="key"/> 中的总字节长度。</returns>
public static long Append(this IRedisClient client, string key, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
if(value == null) throw new ArgumentNullException(nameof(value));
return client.Execute(new RedisInteger("APPEND", key, value));
}
public void WhenConvertBytesToBase64String()
{
var req1 = System.Text.Encoding.UTF8.GetBytes("Hello world! :)");
var val1 = new BinaryValue(req1, null);
var res1 = val1.ToBase64().Value;
res1.Should().Be(Convert.ToBase64String(req1));
}
public void SerializeDeserialize8BitLength()
{
BinaryValue expected = new BinaryValue(new[] { (byte)5 }, false);
BinaryValue actual = SerializeDeserialize(expected);
Assert.AreEqual <BinaryValue>(expected, actual);
}
public void SerializeDeserializeEmptyArray()
{
int[] expected = new int[0];
BinaryValueConverter target = new BinaryValueConverter(new Uri("store://a"), new JsonReliableStateSerializerResolver());
BinaryValue result = target.Serialize <int[]>(expected);
int[] actual = target.Deserialize <int[]>(result);
Assert.AreEqual(0, actual.Length);
}
private void RequireIntegerAndBinary(Command cmd, out int integerValue, out BinaryValue binaryValue)
{
this.RequireArgs(2);
this.RequireType(0, RpnValueType.Integer, RpnValueType.Double);
this.RequireType(1, RpnValueType.Binary);
var values = cmd.UseTopValues(2);
integerValue = (int)((NumericValue)values[0]).ToInteger();
binaryValue = (BinaryValue)values[1];
}
public void MyTestMethod()
{
var client = this.CreateClient();
client.Set("a", "b");
Assert.Equal("b", (string)client.Get("a"));
var value1 = new BinaryValue(TestModels.RootContainer.CreateFakeRoot());
client.Set("x", value1);
var value2 = client.Get("x");
Assert.Equal(value1.ByteArray, value2.ByteArray);
Assert.IsType<TestModels.RootContainer>(value2.ToModel());
}
public void SerializeDeserializeString()
{
string expected = "Mr. Burns";
BinaryValueConverter target = new BinaryValueConverter(new Uri("store://a"), new JsonReliableStateSerializerResolver());
BinaryValue result = target.Serialize <string>(expected);
string actual = target.Deserialize <string>(result);
Assert.AreEqual <string>(expected, actual);
}
public static BinaryValue GetBinaryValue(BinaryValue value, bool isExclusive, string nullValue)
{
if (!value.HasValue())
{
return(nullValue);
}
if (isExclusive)
{
return("(".ToBytes().Concat(value.ByteArray).ToArray());
}
return("[".ToBytes().Concat(value.ByteArray).ToArray());
}
public void SerializationSize255Bytes()
{
byte[] payload = new byte[255];
for (int i = 0; i < 255; ++i)
{
payload[i] = (byte)7;
}
BinaryValue target = new BinaryValue(payload);
Assert.AreEqual <long>(257, GetSerializdSize(target));
}
public void SerializationSize127Bytes()
{
byte[] payload = new byte[127];
for (int i = 0; i < 127; ++i)
{
payload[i] = (byte)7;
}
BinaryValue target = new BinaryValue(payload);
Assert.AreEqual <long>(128, GetSerializdSize(target));
}
private long GetSerializdSize(BinaryValue input)
{
BinaryValueStateSerializer target = new BinaryValueStateSerializer();
using (MemoryStream stream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(stream);
target.Write(input, writer);
return(stream.Length);
}
}
private IItem ConvertToItem(Value value)
{
if (value is BinaryValue)
{
IItem item = null;
BinaryValue binaryValue = (BinaryValue)value;
if (binaryValue.Value != null)
{
using (MemoryStream stream = new MemoryStream(binaryValue.Value)) {
try {
item = XmlParser.Deserialize <IItem>(stream);
}
catch (Exception) { }
stream.Close();
}
}
return(item != null ? item : new Data.StringValue(value.DataType.Name));
}
else if (value is BoolValue)
{
return(new Data.BoolValue(((BoolValue)value).Value));
}
else if (value is FloatValue)
{
return(new Data.DoubleValue(((FloatValue)value).Value));
}
else if (value is PercentValue)
{
return(new Data.PercentValue(((PercentValue)value).Value));
}
else if (value is DoubleValue)
{
return(new Data.DoubleValue(((DoubleValue)value).Value));
}
else if (value is IntValue)
{
return(new Data.IntValue((int)((IntValue)value).Value));
}
else if (value is LongValue)
{
return(new Data.IntValue((int)((LongValue)value).Value));
}
else if (value is StringValue)
{
return(new Data.StringValue(((StringValue)value).Value));
}
else if (value is TimeSpanValue)
{
return(new Data.TimeSpanValue(TimeSpan.FromSeconds((long)((TimeSpanValue)value).Value)));
}
return(null);
}
/// <summary>
/// Parses template data for binary value from given XML
/// </summary>
/// <param name="element">XElement containing template data for binary value</param>
/// <param name="partsList">current list of binary parts</param>
private void ParseValue(XElement element, ObservableCollection <BinaryPart> partsList)
{
long id = long.Parse(element.Attribute(Constants.TemplateXML_ID).Value);
string name = element.Attribute(Constants.TemplateXML_Name).Value;
string type = element.Attribute(Constants.TemplateXML_Type).Value.ToLower();
string converterName = element.Attribute(Constants.TemplateXML_Converter)?.Value ?? "";
IntToStringConverter converter = !string.IsNullOrWhiteSpace(converterName) ? converters.Where(x => x.Name == converterName).FirstOrDefault() : null;
BinaryValueType valueType = (BinaryValueType)Enum.Parse(typeof(BinaryValueType), type, true);
BinaryValue binaryValue = new BinaryValue(id, name, valueType, converter);
partsList.Add(binaryValue);
}
public void BinaryValue_SumInBinary_inputOne_11111111_inputTwo_00000000_should_return_valid_binary()
{
// Arrange
var inputOne = new BinaryValue("11111111");
var inputTwo = new BinaryValue("00000000");
var expectedBinary = "11111111";
// Act
var actualBinary = BinaryValue.SumInBinary(inputOne, inputTwo);
// Assert
Assert.AreEqual(expectedBinary, actualBinary, "converting addition to binary: 11111111");
}
public void BinaryValue_SumInDecimalFromStrings_inputOne_11111111_inputTwo_00000000_should_return_valid_decimal()
{
// Arrange
var inputOne = "11111111";
var inputTwo = "00000000";
var expectedDecimal = 255;
// Act
var actualDecimal = BinaryValue.SumInDecimalFromStrings(inputOne, inputTwo);
// Assert
Assert.AreEqual(expectedDecimal, actualDecimal, "converting addition to decimal: 255");
}
public void BinaryValue_DivisionInDecimalFromStrings_inputOne_10_inputTwo_10_should_return_valid_decimal()
{
// Arrange
var inputOne = "10";
var inputTwo = "10";
var expectedDecimal = 1;
// Act
var actualDecimal = BinaryValue.DivisionInDecimalFromStrings(inputOne, inputTwo);
// Assert
Assert.AreEqual(expectedDecimal, actualDecimal, "converting division to decimal: 1");
}
public void TestComparableDefault()
{
BinaryValue defaultValue = default(BinaryValue);
BinaryValue defaultValueSame = default(BinaryValue);
BinaryValue greater = new BinaryValue(BitConverter.GetBytes(2));
Assert.AreEqual <int>(defaultValue.GetHashCode(), defaultValueSame.GetHashCode());
Assert.AreEqual <int>(-1, defaultValue.CompareTo(greater));
Assert.AreEqual <int>(0, defaultValue.CompareTo(defaultValueSame));
Assert.AreEqual <int>(1, greater.CompareTo(defaultValue));
}
public void BinaryValue_SumInDecimalFromStrings_inputOne_1111111111111111111111111111111_inputTwo_1_should_return_valid_binary()
{
// Arrange
var inputOne = "1111111111111111111111111111111";
var inputTwo = "1";
var expectedDecimal = "2147483648";
// Act
var actualDecimal = BinaryValue.SumInDecimalFromStrings(inputOne, inputTwo);
// Assert
Assert.AreEqual(expectedDecimal, actualDecimal, "converting addition to binary: 2147483648");
}
public void TestComparable()
{
BinaryValue less = new BinaryValue(BitConverter.GetBytes(1));
BinaryValue same = new BinaryValue(BitConverter.GetBytes(1));
BinaryValue greater = new BinaryValue(BitConverter.GetBytes(2));
Assert.AreEqual <int>(less.GetHashCode(), same.GetHashCode());
Assert.AreEqual <int>(-1, less.CompareTo(greater));
Assert.AreEqual <int>(0, less.CompareTo(same));
Assert.AreEqual <int>(1, greater.CompareTo(less));
}
/// <summary>
/// 设置键值。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">键名。</param>
/// <param name="value">键值。</param>
/// <param name="expiration">生存时间。</param>
/// <param name="timeUnit">定位生存时间的单位。</param>
/// <param name="behavior">定位键的行为。</param>
/// <returns>设置成功返回 true，否则返回 false。</returns>
public static bool Set(this IRedisClient client, string key, BinaryValue value
, TimeSpan? expiration = null
, RedisExpireTimeUnit timeUnit = RedisExpireTimeUnit.EX
, RedisKeyBehavior behavior = RedisKeyBehavior.None)
{
long? expiration_64 = null;
if(expiration.HasValue) expiration_64 = expiration.Value.GetExpiration(timeUnit);
return Set(client, key, value, expiration_64, timeUnit, behavior);
}
/// <summary>
/// 动态地调整 Redis 服务器的配置。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="parameter">配置参数。</param>
/// <param name="value">参数的值。</param>
/// <returns>一个结果。</returns>
public static Result ConfigSet(this IRedisClient client, string parameter, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(parameter)) throw new ArgumentNullException(nameof(parameter));
return client.Execute(new RedisStatus("CONFIG SET", parameter, value));
}
/// <summary>
/// 初始化一个 <see cref="RedisFieldItem"/> 类的新实例。
/// </summary>
/// <param name="field">域名。</param>
/// <param name="value">域值。</param>
public RedisFieldItem(string field, BinaryValue value)
{
this._Field = field;
this._Value = value;
}
/// <summary>
/// 返回给定的有序集合键 <paramref name="key"/> 中，值介于 <paramref name="min"/> 和 <paramref name="max"/> 之间从低到高的顺序的成员。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">有序集的键名</param>
/// <param name="min">最小成员值。可以为 null 值，表示负无限。</param>
/// <param name="max">最大成员值。可以为 null 值，表示正无限。</param>
/// <param name="exclusiveMin">指示最小是否为开区间（true 时表示不含最小值）。</param>
/// <param name="exclusiveMax">指示最大值是否为开区间（true 时表示不含最大值）。</param>
/// <param name="offset">返回结果的偏移量。</param>
/// <param name="count">返回结果的数量。</param>
/// <returns>一个从低到高的顺序列表，列表里面包含了有序集合在指定范围内的成员。</returns>
public static BinaryValue[] ZRangeByLex(this IRedisClient client, string key
, BinaryValue min, BinaryValue max
, bool exclusiveMin = false, bool exclusiveMax = false
, long? offset = null, long? count = null)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
IEnumerable<object> args = new object[] { key
, RedisArgs.GetBinaryValue(min, exclusiveMin, "-")
, RedisArgs.GetBinaryValue(max, exclusiveMax, "+") };
if(offset.HasValue && count.HasValue)
{
args = RedisArgs.ConcatAll(args, new[] { "LIMIT", offset.Value.ToString(), count.Value.ToString() });
}
return client.Execute(RedisArray.Create(new RedisValue("ZRANGEBYLEX", args.ToArray())));
}
/// <summary>
/// 返回有序集 <paramref name="key"/> 中，成员 <paramref name="member"/> 的权重值。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">有序集的键名。</param>
/// <param name="member">有序集的成员。</param>
/// <returns>如果 <paramref name="member"/> 是有序集 <paramref name="key"/> 的成员，返回 <paramref name="member"/> 的权重值。否则返回 null 值。</returns>
public static double? ZScore(this IRedisClient client, string key, BinaryValue member)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
if(member == null) throw new ArgumentNullException(nameof(member));
return client.Execute(new RedisFloat.Nullable("ZSCORE", key, member));
}
/// <summary>
/// 返回有序集 <paramref name="key"/> 中成员 <paramref name="member"/> 的排名。其中有序集成员按权重值递减(从大到小)顺序排列。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">有序集的键名。</param>
/// <param name="member">有序集的成员。</param>
/// <returns>如果 <paramref name="member"/> 是有序集 <paramref name="key"/> 的成员，返回 <paramref name="member"/> 的排名。否则返回 null 值。</returns>
public static long? ZRevRank(this IRedisClient client, string key, BinaryValue member)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
if(member == null) throw new ArgumentNullException(nameof(member));
return client.Execute(new RedisInteger.Nullable("ZREVRANK", key, member));
}
/// <summary>
/// 初始化一个 <see cref="RedisScoreItem"/> 类的新实例。
/// </summary>
/// <param name="score">权重值。</param>
/// <param name="member">成员。</param>
public RedisScoreItem(double score, BinaryValue member)
{
this._Score = score;
this._Member = member;
}
void IRedisItem.Parse(RedisExecutor executor)
{
this._Member = executor.ReadBulk();
this._Score = Aoite.Redis.Commands.RedisFloat.FromString(executor.ReadBulkString());
}
/// <summary>
/// 将给定 <paramref name="key"/> 的值设为 <paramref name="value"/> ，并返回 key 的旧值。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">键名。</param>
/// <param name="value">键值。</param>
/// <returns>当 <paramref name="key"/> 不存在时，返回 null ，否则返回 <paramref name="key"/> 的旧值。</returns>
public static BinaryValue GetSet(this IRedisClient client, string key, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
return client.Execute(new RedisValue("GETSET", key, value));
}
/// <summary>
/// 判断 <paramref name="member"/> 是否集合 <paramref name="key"/> 的成员。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">集合的键名。</param>
/// <param name="member">集合的成员。</param>
/// <returns>存在返回 true，否则返回 false。</returns>
public static bool SIsMember(this IRedisClient client, string key, BinaryValue member)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
return client.Execute(new RedisBoolean("SISMEMBER", key, member));
}
/// <summary>
/// 将 <paramref name="member"/> 从 <paramref name="source"/> 集合移动到 <paramref name="destination"/> 集合。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="source">源集合。</param>
/// <param name="destination">目标集合。</param>
/// <param name="member">移动的成员。</param>
/// <returns>一个值，表示移动是否成功。</returns>
public static bool SMove(this IRedisClient client, string source, string destination, BinaryValue member)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(source)) throw new ArgumentNullException(nameof(source));
if(string.IsNullOrWhiteSpace(destination)) throw new ArgumentNullException(nameof(destination));
return client.Execute(new RedisBoolean("SMOVE", source, destination, member));
}
/// <summary>
/// 移除给定的有序集合键 <paramref name="key"/> 中，值介于 <paramref name="min"/> 和 <paramref name="max"/> 之间的成员。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">有序集的键名</param>
/// <param name="min">最小成员值。可以为 null 值，表示负无限。</param>
/// <param name="max">最大成员值。可以为 null 值，表示正无限。</param>
/// <param name="exclusiveMin">指示最小是否为开区间（true 时表示不含最小值）。</param>
/// <param name="exclusiveMax">指示最大值是否为开区间（true 时表示不含最大值）。</param>
/// <returns>被移除的成员数量。</returns>
public static long ZRemRangeByLex(this IRedisClient client, string key
, BinaryValue min, BinaryValue max
, bool exclusiveMin = false, bool exclusiveMax = false)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
return client.Execute(new RedisInteger("ZREMRANGEBYLEX", key
, RedisArgs.GetBinaryValue(min, exclusiveMin, "-")
, RedisArgs.GetBinaryValue(max, exclusiveMax, "+")));
}
/// <summary>
/// 将列表 <paramref name="key"/> 下标为 <paramref name="index"/> 的元素的值设置为 <paramref name="value"/> 。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">列表的键名。</param>
/// <param name="index">设置的索引。
/// <para>当 <paramref name="index"/> 参数超出范围，或对一个空列表( <paramref name="key"/> 不存在)进行 LSET 时，返回一个错误</para>
/// </param>
/// <param name="value">设置的元素值。</param>
/// <returns>一个结果。</returns>
public static Result LSet(this IRedisClient client, string key, long index, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
return client.Execute(new RedisStatus("LSET", key, index, value));
}
/// <summary>
/// 将值 <paramref name="value"/> 插入到列表 <paramref name="key"/> 当中，位于值 <paramref name="pivot"/> 之前或之后。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">列表的键名。</param>
/// <param name="position">插入的位置。</param>
/// <param name="pivot">定位的支点键名。</param>
/// <param name="value">插入的值。</param>
/// <returns>插入的结果。</returns>
public static long LInsert(this IRedisClient client, string key, RedisInsertPosition position, string pivot, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
if(string.IsNullOrWhiteSpace(pivot)) throw new ArgumentNullException(nameof(pivot));
return client.Execute(new RedisInteger("LINSERT", key
, position == RedisInsertPosition.Before ? "BEFORE" : "AFTER"
, pivot, value));
}
void IRedisItem.Parse(RedisExecutor executor)
{
this._Field = executor.ReadBulkString();
this._Value = executor.ReadBulk();
}
/// <summary>
/// 设置键值。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">键名。</param>
/// <param name="value">键值。</param>
/// <returns>设置成功返回 true，否则返回 false。</returns>
public static bool Set(this IRedisClient client, string key, BinaryValue value)
{
return Set(client, key, value, (long?)null);
}
/// <summary>
/// 根据参数 <paramref name="count"/> 的值，移除列表中与参数 <paramref name="value"/> 相等的元素。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">列表的键名。</param>
/// <param name="count">移除的数量。
/// <para>1、<paramref name="count"/> > 0 : 从表头开始向表尾搜索，移除与 <paramref name="value"/> 相等的元素，数量为 <paramref name="count"/> 。</para>
/// <para>2、<paramref name="count"/> < 0 : 从表尾开始向表头搜索，移除与 <paramref name="value"/> 相等的元素，数量为 <paramref name="count"/> 的绝对值。</para>
/// <para>3、<paramref name="count"/> = 0 : 移除表中所有与 <paramref name="value"/> 相等的值。</para>
/// </param>
/// <param name="value">匹配的元素值。</param>
/// <returns>被移除元素的数量。</returns>
public static long LRem(this IRedisClient client, string key, long count, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
return client.Execute(new RedisInteger("LREM", key, count, value));
}
/// <summary>
/// 初始化一个 <see cref="RedisKeyItem"/> 类的新实例。
/// </summary>
/// <param name="key">键名。</param>
/// <param name="value">键值。</param>
public RedisKeyItem(string key, BinaryValue value)
{
this._Key = key;
this._Value = value;
}
/// <summary>
/// 用 <paramref name="value"/> 参数覆写(overwrite)给定 <paramref name="key"/> 所储存的值，从偏移量 <paramref name="offset"/> 开始。
/// <para>不存在的 <paramref name="key"/> 当作空值处理。</para>
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">键名。</param>
/// <param name="offset">偏移量。</param>
/// <param name="value">覆盖的键值。</param>
/// <returns>修改之后的字节总长度。</returns>
public static long SetRange(this IRedisClient client, string key, long offset, BinaryValue value)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
if(offset < 0) throw new ArgumentOutOfRangeException(nameof(offset));
return client.Execute(new RedisInteger("SETRANGE", key, offset, value));
}
/// <summary>
/// 设置键值。
/// </summary>
/// <param name="client">Redis 客户端。</param>
/// <param name="key">键名。</param>
/// <param name="value">键值。</param>
/// <param name="expiration">生存时间。</param>
/// <param name="timeUnit">定位生存时间的单位。</param>
/// <param name="behavior">定位键的行为。</param>
/// <returns>设置成功返回 true，否则返回 false。</returns>
public static bool Set(this IRedisClient client, string key, BinaryValue value
, long? expiration = null
, RedisExpireTimeUnit timeUnit = RedisExpireTimeUnit.EX
, RedisKeyBehavior behavior = RedisKeyBehavior.None)
{
if(client == null) throw new ArgumentNullException(nameof(client));
if(string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key));
List<object> args = new List<object>(5);
args.Add(key);
args.Add(value);
if(expiration.HasValue && expiration.Value > 0)
{
args.Add(timeUnit == RedisExpireTimeUnit.EX ? "EX" : "PX");
args.Add(expiration.Value);
}
if(behavior != RedisKeyBehavior.None) args.Add(behavior == RedisKeyBehavior.NX ? "NX" : "XX");
return client.Execute(new RedisStatus.MultiBulk("SET", args.ToArray()));
}