public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
Connect();
var creationTime = DateTimeOffset.UtcNow;
var absoluteExpiration = GetAbsoluteExpiration(creationTime, options);
var result = _cache.ScriptEvaluate(SetScript, new RedisKey[] { _instance + key },
new RedisValue[]
{
absoluteExpiration?.Ticks ?? NotPresent,
options.SlidingExpiration?.Ticks ?? NotPresent,
GetExpirationInSeconds(creationTime, absoluteExpiration, options) ?? NotPresent,
value
});
}
/// <summary>
/// Tries to get the value from the cache, and only calls the delegating handler on cache misses.
/// </summary>
/// <returns>The HttpResponseMessage from cache, or a newly invoked one.</returns>
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
string key = request.RequestUri.ToString();
// gets the data from cache, and returns the data if it's a cache hit
if (request.Method == HttpMethod.Get)
{
var data = await responseCache.TryGetAsync(key);
if (data != null)
{
HttpResponseMessage cachedResponse = PrepareCachedEntry(request, data);
StatsProvider.ReportCacheHit(cachedResponse.StatusCode);
return cachedResponse;
}
}
// cache misses need to ask the inner handler for an actual response
HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
// puts the retrieved response into the cache and returns the cached entry
if (request.Method == HttpMethod.Get)
{
byte[] entry = await response.ToCacheEntry();
var options = new DistributedCacheEntryOptions {AbsoluteExpirationRelativeToNow = response.StatusCode.GetAbsoluteExpirationRelativeToNow(cacheExpirationPerHttpResponseCode)};
await responseCache.TrySetAsync(key, entry, options);
HttpResponseMessage cachedResponse = PrepareCachedEntry(request, entry);
StatsProvider.ReportCacheMiss(cachedResponse.StatusCode);
return cachedResponse;
}
// returns the original response
return response;
}
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
Set(key, value, options);
return CompletedTask;
}
/// <summary>
/// Tries to set a new value to the cache, that is, ignoring all exceptions.
/// </summary>
/// <param name="cache">The distributed cache.</param>
/// <param name="key">The key for this cache entry.</param>
/// <param name="value">The value of this cache entry.</param>
/// <param name="options">Cache options for the entry.</param>
/// <returns>A task, when completed, has tried to put the entry into the cache.</returns>
public static async Task TrySetAsync(this IDistributedCache cache, string key, byte[] value, DistributedCacheEntryOptions options)
{
try
{
await cache.SetAsync(key, value, options);
}
catch (Exception)
{
// ignoer all exceptions
}
}
/// <inheritdoc />
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return _distributedCache.SetAsync(key, value, options);
}
public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var memoryCacheEntryOptions = new MemoryCacheEntryOptions();
memoryCacheEntryOptions.AbsoluteExpiration = options.AbsoluteExpiration;
memoryCacheEntryOptions.AbsoluteExpirationRelativeToNow = options.AbsoluteExpirationRelativeToNow;
memoryCacheEntryOptions.SlidingExpiration = options.SlidingExpiration;
_memCache.Set(key, value, memoryCacheEntryOptions);
}
public static async Task SetUsingBytesAsync<T>(this IDistributedCache distributedCache, string key, T value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) => await distributedCache.SetAsync(key, value.ToByteArray(), options, token);
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
return _distributedCache.SetAsync(key, value, options);
}
public virtual async Task SetCacheItemAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
var utcNow = SystemClock.UtcNow;
var absoluteExpiration = GetAbsoluteExpiration(utcNow, options);
ValidateOptions(options.SlidingExpiration, absoluteExpiration);
using (var connection = new SqlConnection(ConnectionString))
{
var upsertCommand = new SqlCommand(SqlQueries.SetCacheItem, connection);
upsertCommand.Parameters
.AddCacheItemId(key)
.AddCacheItemValue(value)
.AddSlidingExpirationInSeconds(options.SlidingExpiration)
.AddAbsoluteExpiration(absoluteExpiration)
.AddWithValue("UtcNow", SqlDbType.DateTimeOffset, utcNow);
await connection.OpenAsync();
try
{
await upsertCommand.ExecuteNonQueryAsync();
}
catch (SqlException ex)
{
if (IsDuplicateKeyException(ex))
{
// There is a possibility that multiple requests can try to add the same item to the cache, in
// which case we receive a 'duplicate key' exception on the primary key column.
}
else
{
throw;
}
}
}
}
public DistributedCacheRegistration(string name, DistributedCacheEntryOptions entryOptions, DistributedCacheItemBuilderAsync builder, Func <object, object[], string[]> cacheTags)
: this(new StackTrace(), name, entryOptions, null, builder, cacheTags)
{
}
private static long? GetExpirationInSeconds(DateTimeOffset creationTime, DateTimeOffset? absoluteExpiration, DistributedCacheEntryOptions options)
{
if (absoluteExpiration.HasValue && options.SlidingExpiration.HasValue)
{
return (long)Math.Min(
(absoluteExpiration.Value - creationTime).TotalSeconds,
options.SlidingExpiration.Value.TotalSeconds);
}
else if (absoluteExpiration.HasValue)
{
return (long)(absoluteExpiration.Value - creationTime).TotalSeconds;
}
else if (options.SlidingExpiration.HasValue)
{
return (long)options.SlidingExpiration.Value.TotalSeconds;
}
return null;
}
public static void Set <T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options)
where T : class, new ()
{
byte[] data = Serialize(value);
cache.Set(key, data, options);
}
public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
{
base.Set(key, value, new DistributedCacheEntryOptions());
}
public static async Task SetUsingJsonAsync<T>(this IDistributedCache distributedCache, string key, T value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) => await distributedCache.SetStringAsync(key, JsonConvert.SerializeObject(value), options, token);
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
throw new NotImplementedException();
}
public static async Task SetUsingJsonAsync<T>(this IDistributedCache distributedCache, T value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) => await distributedCache.SetUsingJsonAsync(typeof(T).FullName, value, options, token);
public static void SetUsingJson<T>(this IDistributedCache distributedCache, string key, T value, DistributedCacheEntryOptions options) => distributedCache.SetString(key, JsonConvert.SerializeObject(value), options);
public static void SetUsingJson<T>(this IDistributedCache distributedCache, T value, DistributedCacheEntryOptions options) => distributedCache.SetUsingJson(typeof(T).FullName, value, options);
public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
{
base.Set(key, value, new Microsoft.Framework.Caching.Distributed.DistributedCacheEntryOptions());
}
public async static Task SetAsync <T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken))
where T : class, new()
{
byte[] data = Serialize(value);
await cache.SetAsync(key, data, options, token);
}
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
return base.SetAsync(key, value, new Microsoft.Framework.Caching.Distributed.DistributedCacheEntryOptions());
}
public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
await ConnectAsync();
var creationTime = DateTimeOffset.UtcNow;
await _cache.ScriptEvaluateAsync(SetScript, new RedisKey[] { _instance + key },
new RedisValue[]
{
options.AbsoluteExpiration?.Ticks ?? NotPresent,
options.SlidingExpiration?.Ticks ?? NotPresent,
GetExpirationInSeconds(creationTime, options) ?? NotPresent,
value
});
}
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
return base.SetAsync(key, value, new DistributedCacheEntryOptions());
}
private static long? GetExpirationInSeconds(DateTimeOffset creationTime, DistributedCacheEntryOptions options)
{
// Calculate absolute expiration time
DateTimeOffset? absoluteExpiration = null;
if (options.AbsoluteExpirationRelativeToNow.HasValue)
{
absoluteExpiration = creationTime + options.AbsoluteExpirationRelativeToNow;
}
else if (options.AbsoluteExpiration.HasValue)
{
if (options.AbsoluteExpiration <= creationTime)
{
throw new ArgumentOutOfRangeException(
nameof(DistributedCacheEntryOptions.AbsoluteExpiration),
options.AbsoluteExpiration.Value,
"The absolute expiration value must be in the future.");
}
absoluteExpiration = options.AbsoluteExpiration;
}
if (absoluteExpiration.HasValue && options.SlidingExpiration.HasValue)
{
return (long)Math.Min(
(absoluteExpiration.Value - creationTime).TotalSeconds,
options.SlidingExpiration.Value.TotalSeconds);
}
else if (absoluteExpiration.HasValue)
{
return (long)(absoluteExpiration.Value - creationTime).TotalSeconds;
}
else if (options.SlidingExpiration.HasValue)
{
return (long)options.SlidingExpiration.Value.TotalSeconds;
}
return null;
}
public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
{
this.SetAsync(key, value, options).Wait();
}
// Internal for unit testing
internal DistributedCacheEntryOptions GetDistributedCacheEntryOptions()
{
var options = new DistributedCacheEntryOptions();
if (ExpiresOn != null)
{
options.SetAbsoluteExpiration(ExpiresOn.Value);
}
if (ExpiresAfter != null)
{
options.SetAbsoluteExpiration(ExpiresAfter.Value);
}
if (ExpiresSliding != null)
{
options.SetSlidingExpiration(ExpiresSliding.Value);
}
return options;
}
private static DateTimeOffset? GetAbsoluteExpiration(DateTimeOffset creationTime, DistributedCacheEntryOptions options)
{
if (options.AbsoluteExpiration.HasValue && options.AbsoluteExpiration <= creationTime)
{
throw new ArgumentOutOfRangeException(
nameof(DistributedCacheEntryOptions.AbsoluteExpiration),
options.AbsoluteExpiration.Value,
"The absolute expiration value must be in the future.");
}
var absoluteExpiration = options.AbsoluteExpiration;
if (options.AbsoluteExpirationRelativeToNow.HasValue)
{
absoluteExpiration = creationTime + options.AbsoluteExpirationRelativeToNow;
}
return absoluteExpiration;
}
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
throw new NotImplementedException();
}
public async Task SetAsync(
string key,
byte[] value,
DistributedCacheEntryOptions options)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
await _dbOperations.SetCacheItemAsync(key, value, options);
ScanForExpiredItemsIfRequired();
}
public DistributedCacheRegistration(string name, DistributedCacheEntryOptions entryOptions, DistributedCacheItemBuilderAsync builder, params string[] cacheTags)
: this(new StackTrace(), name, entryOptions, null, builder, cacheTags != null && cacheTags.Length > 0 ? (a, b) => cacheTags : (Func <object, object[], string[]>)null)
{
}
protected DateTimeOffset? GetAbsoluteExpiration(DateTimeOffset utcNow, DistributedCacheEntryOptions options)
{
// calculate absolute expiration
DateTimeOffset? absoluteExpiration = null;
if (options.AbsoluteExpirationRelativeToNow.HasValue)
{
absoluteExpiration = utcNow.Add(options.AbsoluteExpirationRelativeToNow.Value);
}
else if (options.AbsoluteExpiration.HasValue)
{
if (options.AbsoluteExpiration.Value <= utcNow)
{
throw new InvalidOperationException("The absolute expiration value must be in the future.");
}
absoluteExpiration = options.AbsoluteExpiration.Value;
}
return absoluteExpiration;
}
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
{
DateTimeOffset? absoluteExpiration = null;
var currentTime = DateTimeOffset.UtcNow;
if (options.AbsoluteExpirationRelativeToNow.HasValue)
{
absoluteExpiration = currentTime.Add(options.AbsoluteExpirationRelativeToNow.Value);
}
else if (options.AbsoluteExpiration.HasValue)
{
if (options.AbsoluteExpiration.Value <= currentTime)
{
throw new ArgumentOutOfRangeException(
nameof(options.AbsoluteExpiration),
options.AbsoluteExpiration.Value,
"The absolute expiration value must be in the future.");
}
absoluteExpiration = options.AbsoluteExpiration;
}
var item = new CachedItem(partitionKey, key, value) { LastAccessTime = currentTime };
if (absoluteExpiration.HasValue)
{
item.AbsolutExperiation = absoluteExpiration;
}
if (options.SlidingExpiration.HasValue)
{
item.SlidingExperiation = options.SlidingExpiration;
}
var op = TableOperation.InsertOrReplace(item);
return this.azuretable.ExecuteAsync(op);
}
internal static Task SetAsync(
[NotNull] this IDistributedCache cache, [NotNull] string key,
[NotNull] Func<DistributedCacheEntryOptions, byte[]> factory) {
var options = new DistributedCacheEntryOptions();
var buffer = factory(options);
return cache.SetAsync(key, buffer, options);
}
public static void SetUsingBytes<T>(this IDistributedCache distributedCache, string key, T value, DistributedCacheEntryOptions options) => distributedCache.Set(key, value.ToByteArray(), options);
public void Displayed(ShapeDisplayedContext context)
{
// TODO: Configure duration of sliding expiration
var cacheContext = context.ShapeMetadata.Cache();
// If the shape is not cached, evaluate the ESIs
if(cacheContext == null)
{
string content;
using (var sw = new StringWriter())
{
context.ChildContent.WriteTo(sw, HtmlEncoder.Default);
content = sw.ToString();
}
ProcessESIs(ref content, GetDistributedCache);
context.ChildContent = new HtmlString(content);
}
else if (!_cached.Contains(cacheContext) && context.ChildContent != null)
{
var cacheEntries = GetCacheEntries(cacheContext).ToList();
string cacheKey = GetCacheKey(cacheContext.CacheId, cacheEntries);
using (var sw = new StringWriter())
{
context.ChildContent.WriteTo(sw, HtmlEncoder.Default);
var content = sw.ToString();
_cached.Add(cacheContext);
_cache[cacheKey] = content;
var contexts = String.Join(ContextSeparator.ToString(), cacheContext.Contexts.ToArray());
context.ChildContent = new HtmlString($"[[cache id='{cacheContext.CacheId}' contexts='{contexts}']]");
var bytes = Encoding.UTF8.GetBytes(content);
// Default duration is sliding expiration (permanent as long as it's used)
DistributedCacheEntryOptions options = new DistributedCacheEntryOptions
{
SlidingExpiration = new TimeSpan(0, 1, 0)
};
// If a custom duration is specified, replace the default options
if (cacheContext.Duration.HasValue)
{
options = new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = cacheContext.Duration
};
}
_dynamicCache.SetAsync(cacheKey, bytes, options).Wait();
_tagCache.Tag(cacheKey, cacheContext.Tags.ToArray());
}
}
}
public static async Task SetAsync <T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options) where T : class
{
var json = JsonConvert.SerializeObject(value);
await cache.SetStringAsync(key, json, options);
}
