/// <summary>
/// Removes all serialized objects associated with the given tag names and optionally with keys matching the given pattern.
/// WARNING: THIS IS A VERY EXPENSIVE OPERATION FOR LARGE TAG CACHES. USE WITH CAUTION.
/// </summary>
/// <param name="tagNames">The tag names.</param>
/// <param name="pattern">The search pattern (RegEx). Optional. If not specified, the default of "*" is used to indicate match all.</param>
public void RemoveTagged(IEnumerable<string> tagNames, string pattern = "*")
{
// Sanitize
if (tagNames == null)
{
throw new ArgumentNullException("tagNames");
}
if (!tagNames.Any())
{
throw new ArgumentException("must have at least one element", "tagNames");
}
if (string.IsNullOrWhiteSpace(pattern))
{
throw new ArgumentException("cannot be null, empty, or white space", "pattern");
}
byte[] command;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("del-tag");
memoryStream.WriteSpace();
memoryStream.Write(pattern);
foreach (var tagName in tagNames)
{
memoryStream.WriteSpace();
memoryStream.Write(tagName);
}
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.RepeatingCacheKeys);
// Send
_client.Send(command);
}
/// <summary>
/// Gets all serialized objects associated with the given tag name.
/// </summary>
/// <param name="tagNames">The tag names.</param>
/// <returns>A list of the serialized objects.</returns>
public List<byte[]> GetTagged(IEnumerable<string> tagNames)
{
// Sanitize
if (tagNames == null)
{
throw new ArgumentNullException("tagNames");
}
if (!tagNames.Any())
{
throw new ArgumentException("must have at least one element", "tagNames");
}
byte[] command = null;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("get-tag");
foreach (var tagName in tagNames)
{
memoryStream.WriteSpace();
memoryStream.Write(tagName);
}
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.RepeatingCacheKeys);
// Send and receive
command = _client.SendReceive(command);
// Parse string
var commandResult = DacheProtocolHelper.CommunicationEncoding.GetString(command);
// Verify that we got something
if (commandResult == null)
{
return null;
}
// Parse command from bytes
var commandResultParts = commandResult.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
return ParseCacheObjects(commandResultParts);
}
/// <summary>
/// Removes the serialized objects at the given cache keys from the cache.
/// </summary>
/// <param name="cacheKeys">The cache keys.</param>
public void Remove(IEnumerable<string> cacheKeys)
{
// Sanitize
if (cacheKeys == null)
{
throw new ArgumentNullException("cacheKeys");
}
if (!cacheKeys.Any())
{
throw new ArgumentException("must have at least one element", "cacheKeys");
}
byte[] command = null;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("del");
foreach (var cacheKey in cacheKeys)
{
memoryStream.WriteSpace();
memoryStream.Write(cacheKey);
}
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.RepeatingCacheKeys);
// Send
_client.Send(command);
}
/// <summary>
/// Gets all cache keys associated with the given tag names and optionally matching the given pattern.
/// WARNING: THIS IS A VERY EXPENSIVE OPERATION FOR LARGE TAG CACHES. USE WITH CAUTION.
/// </summary>
/// <param name="tagNames">The tag names.</param>
/// <param name="pattern">The search pattern (RegEx). Optional. If not specified, the default of "*" is used to indicate match all.</param>
/// <returns>The list of cache keys matching the provided pattern.</returns>
public List<byte[]> GetCacheKeysTagged(IEnumerable<string> tagNames, string pattern = "*")
{
if (tagNames == null)
{
throw new ArgumentNullException("tagNames");
}
if (!tagNames.Any())
{
throw new ArgumentException("must have at least one element", "tagNames");
}
if (string.IsNullOrWhiteSpace(pattern))
{
throw new ArgumentException("cannot be null, empty, or white space", "pattern");
}
byte[] command;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("keys-tag");
memoryStream.WriteSpace();
memoryStream.Write(pattern);
foreach (var tagName in tagNames)
{
memoryStream.WriteSpace();
memoryStream.Write(tagName);
}
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.Literal);
// Send and receive
var rawResult = _client.SendReceive(command);
// Verify that we got something
if (rawResult == null)
{
return null;
}
// Parse string
var decodedResult = DacheProtocolHelper.CommunicationEncoding.GetString(rawResult);
if (string.IsNullOrWhiteSpace(decodedResult))
{
return null;
}
// Parse command from bytes
var commandResultParts = decodedResult.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
return ParseCacheObjects(commandResultParts);
}
/// <summary>
/// Gets all cache keys, optionally matching the provided pattern.
/// WARNING: THIS IS A VERY EXPENSIVE OPERATION FOR LARGE CACHES. USE WITH CAUTION.
/// </summary>
/// <param name="pattern">The search pattern (RegEx). Optional. If not specified, the default of "*" is used to indicate match all.</param>
/// <returns>The list of cache keys matching the provided pattern</returns>
public List<byte[]> GetCacheKeys(string pattern = "*")
{
// Sanitize
if (string.IsNullOrWhiteSpace(pattern))
{
throw new ArgumentException("cannot be null, empty, or white space", "pattern");
}
byte[] command;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("keys {0}", pattern);
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.Literal);
// Send and receive
var rawResult = _client.SendReceive(command);
// Verify that we got something
if (rawResult == null)
{
return null;
}
// Parse string
var decodedResult = DacheProtocolHelper.CommunicationEncoding.GetString(rawResult);
if (string.IsNullOrWhiteSpace(decodedResult))
{
return null;
}
// Parse command from bytes
var commandResultParts = decodedResult.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
return ParseCacheObjects(commandResultParts);
}
/// <summary>
/// Clears the cache.
/// </summary>
public void Clear()
{
byte[] command;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("clear");
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.Literal);
// Send
_client.Send(command);
}
/// <summary>
/// Adds or updates the interned serialized objects in the cache at the given cache keys.
/// NOTE: interned objects use significantly less memory when placed in the cache multiple times however cannot expire or be evicted.
/// You must remove them manually when appropriate or else you may face a memory leak.
/// </summary>
/// <param name="cacheKeysAndSerializedObjects">The cache keys and associated serialized objects.</param>
/// <param name="tagName">The tag name.</param>
public void AddOrUpdateTaggedInterned(IEnumerable<KeyValuePair<string, byte[]>> cacheKeysAndSerializedObjects, string tagName)
{
// Sanitize
if (cacheKeysAndSerializedObjects == null)
{
throw new ArgumentNullException("cacheKeysAndSerializedObjects");
}
if (!cacheKeysAndSerializedObjects.Any())
{
throw new ArgumentException("must have at least one element", "cacheKeysAndSerializedObjects");
}
if (string.IsNullOrWhiteSpace(tagName))
{
throw new ArgumentException("cannot be null, empty, or white space", "tagName");
}
byte[] command = null;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("set-tag-intern {0}", tagName);
foreach (var cacheKeyAndSerializedObjectKvp in cacheKeysAndSerializedObjects)
{
memoryStream.WriteSpace();
memoryStream.Write(cacheKeyAndSerializedObjectKvp.Key);
memoryStream.WriteSpace();
memoryStream.WriteBase64(cacheKeyAndSerializedObjectKvp.Value);
}
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.RepeatingCacheKeysAndObjects);
// Send
_client.Send(command);
}
/// <summary>
/// Adds or updates the serialized objects in the cache at the given cache keys.
/// </summary>
/// <param name="cacheKeysAndSerializedObjects">The cache keys and associated serialized objects.</param>
/// <param name="slidingExpiration">The sliding expiration.</param>
public void AddOrUpdate(IEnumerable<KeyValuePair<string, byte[]>> cacheKeysAndSerializedObjects, TimeSpan slidingExpiration)
{
// Sanitize
if (cacheKeysAndSerializedObjects == null)
{
throw new ArgumentNullException("cacheKeysAndSerializedObjects");
}
if (!cacheKeysAndSerializedObjects.Any())
{
throw new ArgumentException("must have at least one element", "cacheKeysAndSerializedObjects");
}
byte[] command = null;
using (var memoryStream = new MemoryStream())
{
memoryStream.WriteControlBytePlaceHolder();
memoryStream.Write("set {0}", (int)slidingExpiration.TotalSeconds);
foreach (var cacheKeyAndSerializedObjectKvp in cacheKeysAndSerializedObjects)
{
memoryStream.WriteSpace();
memoryStream.Write(cacheKeyAndSerializedObjectKvp.Key);
memoryStream.WriteSpace();
memoryStream.WriteBase64(cacheKeyAndSerializedObjectKvp.Value);
}
command = memoryStream.ToArray();
}
// Set control byte
command.SetControlByte(DacheProtocolHelper.MessageType.RepeatingCacheKeysAndObjects);
// Send
_client.Send(command);
}
