/// <summary> /// ExecuteBulkReplies /// </summary> /// <typeparam name="T"></typeparam> /// <param name="request"></param> /// <param name="valueFactory"></param> /// <param name="asyncState"></param> /// <returns></returns> /// <exception cref="ArgumentNullException">valueFactory is null.</exception> private Task <T> ExecuteBulkReplies <T>(RedisRequest request, Func <byte[], T> valueFactory, object asyncState) { if (valueFactory == null) { throw new ArgumentNullException("valueFactory"); } return(this.Execute <T>(request.ToPayload(), (source, response) => { var mbReeply = response.Reply as BulkReplies; if (mbReeply != null) { if (mbReeply.Payload == null || mbReeply.Payload.Length == 0) { source.TrySetResult(default(T)); return; } try { source.TrySetResult(valueFactory(mbReeply.Payload)); } catch (Exception ex) { source.TrySetException(ex); } return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException("Failed to resolve the bulkReplies")); }, asyncState)); }
/// <summary> /// ExecuteMultiBulkReplies /// </summary> /// <param name="request"></param> /// <param name="asyncState"></param> /// <returns></returns> private Task <byte[][]> ExecuteMultiBulkReplies(RedisRequest request, object asyncState) { return(this.Execute <byte[][]>(request.ToPayload(), (source, response) => { var mbReeply = response.Reply as MultiBulkReplies; if (mbReeply != null) { if (mbReeply.Replies == null) { source.TrySetResult(new byte[0][]); return; } byte[][] arrBytes = new byte[mbReeply.Replies.Length][]; for (int i = 0, l = mbReeply.Replies.Length; i < l; i++) { var objBulk = mbReeply.Replies[i] as BulkReplies; if (objBulk != null) { arrBytes[i] = objBulk.Payload; } } source.TrySetResult(arrBytes); return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException("Failed to resolve the multiBulkReplies.")); }, asyncState)); }
/// <summary> /// ExecuteMultiBulkReplies /// </summary> /// <typeparam name="T"></typeparam> /// <param name="request"></param> /// <param name="valueFactory"></param> /// <param name="asyncState"></param> /// <returns></returns> /// <exception cref="ArgumentNullException">valueFactory is null.</exception> private Task <T[]> ExecuteMultiBulkReplies <T>(RedisRequest request, Func <byte[], T> valueFactory, object asyncState) { if (valueFactory == null) { throw new ArgumentNullException("valueFactory"); } return(this.Execute <T[]>(request.ToPayload(), (source, response) => { var mbReeply = response.Reply as MultiBulkReplies; if (mbReeply != null) { if (mbReeply.Replies == null) { source.TrySetResult(null); return; } var arrResults = new T[mbReeply.Replies.Length]; for (int i = 0, l = mbReeply.Replies.Length; i < l; i++) { var objBulk = mbReeply.Replies[i] as BulkReplies; if (objBulk == null) { continue; } if (objBulk.Payload == null) { arrResults[i] = default(T); continue; } try { arrResults[i] = valueFactory(objBulk.Payload); } catch (Exception ex) { source.TrySetException(ex); return; } } source.TrySetResult(arrResults); return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException( "Failed to resolve the multiBulkReplies, expected is multiBulkReplies, but was " + response.Reply.GetType().Name)); }, asyncState)); }
/// <summary> /// Sets the specified fields to their respective values in the hash stored at key. /// This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created. /// </summary> /// <param name="key"></param> /// <param name="values"></param> /// <param name="asyncState"></param> /// <returns></returns> Task IHashCommands.Set(string key, Dictionary <string, byte[]> values, object asyncState) { if (values == null || values.Count == 0) { throw new ArgumentNullException("values is null or empty."); } var request = new RedisRequest(2 + values.Count * 2).AddArgument("HMSET").AddArgument(key); foreach (var child in values) { request.AddArgument(child.Key).AddArgument(child.Value); } return(this.ExecuteStatusReply(request, asyncState)); }
/// <summary> /// Returns the values associated with the specified fields in the hash stored at key. /// For every field that does not exist in the hash, a nil value is returned. /// </summary> /// <param name="key"></param> /// <param name="fields"></param> /// <param name="asyncState"></param> /// <returns>list of values associated with the given fields, in the same order as they are requested.</returns> Task <byte[][]> IHashCommands.Get(string key, string[] fields, object asyncState) { if (fields == null || fields.Length == 0) { throw new ArgumentNullException("fields is null or empty."); } var request = new RedisRequest(fields.Length + 2).AddArgument("HMGET").AddArgument(key); for (int i = 0, l = fields.Length; i < l; i++) { request.AddArgument(fields[i]); } return(this.ExecuteMultiBulkReplies(request, asyncState)); }
/// <summary> /// Removes the specified fields from the hash stored at key. /// Specified fields that do not exist within this hash are ignored. /// If key does not exist, it is treated as an empty hash and this command returns 0. /// </summary> /// <param name="key"></param> /// <param name="fields"></param> /// <param name="asyncState"></param> /// <returns> /// the number of fields that were removed from the hash, not including specified but non existing fields. /// </returns> /// <exception cref="ArgumentNullException">fields is null or empty.</exception> Task <int> IHashCommands.Remove(string key, string[] fields, object asyncState) { if (fields == null || fields.Length == 0) { throw new ArgumentNullException("fields is null or empty."); } var request = new RedisRequest(fields.Length + 2).AddArgument("HDEL").AddArgument(key); for (int i = 0, l = fields.Length; i < l; i++) { request.AddArgument(fields[i]); } return(this.ExecuteIntegerReply(request, asyncState)); }
/// <summary> /// Sets the given keys to their respective values. /// MSET replaces existing values with new values, just as regular SET. See MSETNX if you don't want to overwrite existing values. /// MSET is atomic, so all given keys are set at once. /// It is not possible for clients to see that some of the keys were updated while others are unchanged. /// </summary> /// <param name="dic"></param> /// <param name="asyncState"></param> /// <returns>always OK since MSET can't fail.</returns> /// <exception cref="ArgumentNullException">dic is null or empty.</exception> Task IStringCommands.Set(Dictionary <string, byte[]> dic, object asyncState) { if (dic == null || dic.Count == 0) { throw new ArgumentNullException("dic", "dic is null or empty."); } var request = new RedisRequest(dic.Count + dic.Count + 1).AddArgument("MSET"); foreach (var kv in dic) { request.AddArgument(kv.Key).AddArgument(kv.Value); } return(this.ExecuteStatusReply(request, asyncState)); }
/// <summary> /// ExecuteBulkReplies /// </summary> /// <param name="request"></param> /// <param name="asyncState"></param> /// <returns></returns> private Task <byte[]> ExecuteBulkReplies(RedisRequest request, object asyncState) { return(this.Execute <byte[]>(request.ToPayload(), (source, response) => { var mbReeply = response.Reply as BulkReplies; if (mbReeply != null) { source.TrySetResult(mbReeply.Payload); return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException("Failed to resolve the bulkReplies")); }, asyncState)); }
/// <summary> /// ExecuteStatusReply /// </summary> /// <param name="request"></param> /// <param name="asyncState"></param> /// <returns></returns> private Task <string> ExecuteStatusReply(RedisRequest request, object asyncState) { return(this.Execute <string>(request.ToPayload(), (source, response) => { var statusReply = response.Reply as StatusReply; if (statusReply != null) { source.TrySetResult(statusReply.Status); return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException("Failed to resolve the statusReply")); }, asyncState)); }
/// <summary> /// ExecuteIntegerReply2 /// </summary> /// <param name="request"></param> /// <param name="asyncState"></param> /// <returns></returns> private Task <bool> ExecuteIntegerReply2(RedisRequest request, object asyncState) { return(this.Execute <bool>(request.ToPayload(), (source, response) => { var intReply = response.Reply as IntegerReply; if (intReply != null) { source.TrySetResult(intReply.Value == 1); return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException("Failed to resolve the integerReply")); }, asyncState)); }
/// <summary> /// ExecuteIntegerReply /// </summary> /// <param name="request"></param> /// <param name="asyncState"></param> /// <returns></returns> private Task <int> ExecuteIntegerReply(RedisRequest request, object asyncState) { return(this.Execute <int>(request.ToPayload(), (source, response) => { var intReply = response.Reply as IntegerReply; if (intReply != null) { source.TrySetResult(intReply.Value); return; } if (response.Reply is ErrorReply) { source.TrySetException((response.Reply as ErrorReply).Error()); return; } source.TrySetException(new RedisException( "Failed to resolve the integerReply, expected is integerReply, but was " + response.Reply.GetType().Name)); }, asyncState)); }
/// <summary> /// unsubscribe pattern /// </summary> /// <param name="patterns"></param> private void UnPatternSubscribeInternal(string[] patterns) { if (patterns == null || patterns.Length == 0) { return; } var connection = this._currentConnection; if (connection == null) { return; } var r = new RedisRequest(patterns.Length + 1).AddArgument("PUNSUBSCRIBE"); foreach (var pattern in patterns) { r.AddArgument(pattern); } connection.BeginSend(new Packet(r.ToPayload())); }
/// <summary> /// unsubscribe channel /// </summary> /// <param name="channels"></param> private void UnSubscribeInternal(string[] channels) { if (channels == null || channels.Length == 0) { return; } var connection = this._currentConnection; if (connection == null) { return; } var r = new RedisRequest(channels.Length + 1).AddArgument("UNSUBSCRIBE"); foreach (var channel in channels) { r.AddArgument(channel); } connection.BeginSend(new Packet(r.ToPayload())); }
/// <summary> /// unsubscribe pattern /// </summary> /// <param name="patterns"></param> private void UnPatternSubscribeInternal(string[] patterns) { if (patterns == null || patterns.Length == 0) return; var connection = this._currentConnection; if (connection == null) return; var r = new RedisRequest(patterns.Length + 1).AddArgument("PUNSUBSCRIBE"); foreach (var pattern in patterns) r.AddArgument(pattern); connection.BeginSend(new Packet(r.ToPayload())); }
/// <summary> /// unsubscribe channel /// </summary> /// <param name="channels"></param> private void UnSubscribeInternal(string[] channels) { if (channels == null || channels.Length == 0) return; var connection = this._currentConnection; if (connection == null) return; var r = new RedisRequest(channels.Length + 1).AddArgument("UNSUBSCRIBE"); foreach (var channel in channels) r.AddArgument(channel); connection.BeginSend(new Packet(r.ToPayload())); }