public async Task <IActionResult> Get()
{
ViewData["Message"] = "Called Memcached Get API.";
var data = await _memcachedClient.GetValueAsync <String>(CacheKey);
ViewData["GetData"] = data;
for (var i = 0; i < 30; i++)
{
var key = "memcached-key-" + i;
int testCacheSeconds = 120;
var result = await _memcachedClient.GetAsync <string>(key);
if (result.Value != null)
{
Console.WriteLine("Hit!!!! : " + result.Value);
}
else
{
Console.WriteLine("No Hit.....");
}
}
return(View());
}
public async Task <IForecastResponse> Query(GeoCoordinate coord)
{
var cacheKey = $"{coord.Lat},{coord.Long}";
var result = await _memcachedClient.GetAsync <ForecastResponse>(cacheKey);
if (!result.Success)
{
var sb = new StringBuilder("https://api.darksky.net/forecast/");
sb.Append(Environment.GetEnvironmentVariable("DARKSKY_API_KEY"));
sb.Append($"/{coord.Lat},{coord.Long}");
var query = sb.ToString();
var forecast = await _weatherQueryDispatchService.Query(query).ConfigureAwait(false);
await _memcachedClient.AddAsync(cacheKey, forecast, 600);
return(forecast);
}
else
{
return(result.Value);
}
}
public async Task <GeoResponse> Query(string q)
{
var cacheKey = q.Replace(" ", "").ToLower();
var result = await _memcachedClient.GetAsync <GeoResponse>(cacheKey);
if (!result.Success)
{
var queryParts = _geoQueryParser.Parse(q);
var sb = new StringBuilder("https://api.geocod.io/v1/geocode?");
foreach (var k in queryParts.Keys)
{
sb.Append($"{k}={queryParts[k]}&");
}
sb.Append("api_key=");
sb.Append(Environment.GetEnvironmentVariable("GEOCODIO_API_KEY"));
var query = sb.ToString();
var geo = await _geoQueryDispatchService.Query(query).ConfigureAwait(false);
await _memcachedClient.StoreAsync(StoreMode.Add, cacheKey, geo, DateTime.Now.AddDays(7));
return(geo);
}
else
{
return(result.Value);
}
}
public async ValueTask <T> Get <T>(string key)
{
try
{
using (var scope = _tracer.BuildSpan($"CacheProvider::Get::{typeof(T)}").StartActive(true))
{
var valueResult = await _memcachedClient.GetAsync <T>(key);
return(valueResult.HasValue ? valueResult.Value : default);
public async Task <IActionResult> Postbody()
{
var postbody = (await _blogPostService.GetRecent(10)).First()?.Body;
await _postbodyMemcachedClient.AddAsync(PostbodyCacheKey, postbody, 10);
var result = await _postbodyMemcachedClient.GetAsync <string>(PostbodyCacheKey);
return(result.Success ? Ok() : StatusCode(500));
}
public async Task <List <Dictionary <string, object> > > GetOrCreateOrdersListWaitAndPolicyMemcached(Func <Task <List <Dictionary <string, object> > > > query, string key)
{
ConcurrentDictionary <object, SemaphoreSlim> _locks = new ConcurrentDictionary <object, SemaphoreSlim>();
List <Dictionary <string, object> > cacheEntry;
var result = await _memcachedClient.GetAsync <List <Dictionary <string, object> > >(key);
if (!result.Success)
{
SemaphoreSlim mylock = _locks.GetOrAdd(key, k => new SemaphoreSlim(1, 1));
await mylock.WaitAsync();
try
{
result = await _memcachedClient.GetAsync <List <Dictionary <string, object> > >(key);
if (!result.Success)// Key not in cache, so get data.
{
cacheEntry = await query();
await _memcachedClient.AddAsync(key, cacheEntry, 100);
}
else
{
cacheEntry = result.Value;
}
}
finally
{
mylock.Release();
}
}
else
{
cacheEntry = result.Value;
}
return(cacheEntry);
}
public async void setValue()
{
for (var i = 0; i < 30; i++)
{
var key = "memcached-key-" + i;
int testCacheSeconds = 120;
var result = await _memcachedClient.GetAsync <string>(key);
if (result.Value != null)
{
Console.WriteLine("Hit!!!! : " + result.Value);
}
else
{
Console.WriteLine("No Hit.....");
}
}
}
public void CleanupCache(ILambdaContext context, string cacheReportName, int reportId)
{
TimeSpan limit = new TimeSpan(0, 0, 20);
string key = $"{cacheReportName}_Cleanup";
if (memcachedClient.Store(StoreMode.Add, key, true, new TimeSpan(0, 0, 20)))
{
if (context.RemainingTime <= limit)
{
memcachedClient.Remove(key);
return;
}
context.Logger.LogLine($"resetting cache for {cacheReportName}-{reportId}");
ulong index = 0;
IGetOperationResult <string> keyToRemove;
while ((index = memcachedClient.Decrement($"{cacheReportName}_Cache_Count", 0, 1)) != 0)
{
keyToRemove = memcachedClient.GetAsync <string>($"{cacheReportName}_Cache_{index}").Result;
if (keyToRemove.HasValue)
{
if (memcachedClient.Remove(keyToRemove.Value))
{
context.Logger.LogLine($"{keyToRemove.Value} removed from cache");
}
memcachedClient.Remove($"{cacheReportName}_Cache_{index}");
}
else
{
context.Logger.LogLine($"{cacheReportName}_Cache_{index} not removed from cache");
}
}
memcachedClient.Remove($"{cacheReportName}_GP_Count");
memcachedClient.Remove($"{cacheReportName}_Cache_Count");
memcachedClient.Remove($"{cacheReportName}_H2H_Matchup_Count");
//memcachedClient.Remove($"{cacheReportName}_H2H_Band_Count");
//memcachedClient.Remove($"{cacheReportName}_H2H_Count");
memcachedClient.Remove(key);
}
else
{
context.Logger.LogLine($"skipping resetting cache for {cacheReportName}-{reportId}");
}
}
/// <summary>
/// Gets all async.
/// </summary>
/// <returns>The all async.</returns>
/// <param name="cacheKeys">Cache keys.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task <IDictionary <string, CacheValue <T> > > GetAllAsync <T>(IEnumerable <string> cacheKeys) where T : class
{
ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
var values = await _memcachedClient.GetAsync <T>(cacheKeys);
var result = new Dictionary <string, CacheValue <T> >();
foreach (var item in values)
{
if (item.Value != null)
{
result.Add(item.Key, new CacheValue <T>(item.Value, true));
}
else
{
result.Add(item.Key, CacheValue <T> .NoValue);
}
}
return(result);
}
/// <summary>
/// 批量获取缓存，根据缓存键
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="cacheKeys">缓存键集合</param>
/// <returns></returns>
public async Task <IDictionary <string, CacheValue <T> > > GetAllAsync <T>(IEnumerable <string> cacheKeys)
{
Check.NotNullOrEmpty(cacheKeys, nameof(cacheKeys));
WriteLog($"GetAllAsync : cacheKeys = {string.Join(",", cacheKeys)}");
var values = await _memcachedClient.GetAsync <T>(cacheKeys);
var result = new Dictionary <string, CacheValue <T> >();
foreach (var value in values)
{
if (value.Value != null)
{
result.Add(value.Key, new CacheValue <T>(value.Value, true));
}
else
{
result.Add(value.Key, CacheValue <T> .NoValue);
}
}
return(result);
}
public async Task <T> GetAsync <T>(string key) where T : class
{
return(await _memcachedClient.GetAsync <T>(key).ConfigureAwait(false));
}
public Task <IGetOperationResult <T1> > GetAsync <T1>(string key)
{
return(_memcachedClient.GetAsync <T1>(key));
}
public static Task <IGetOperationResult <object> > GetAsync(this IMemcachedClient self, string key, ulong cas = Protocol.NO_CAS)
{
return(self.GetAsync <object>(key, cas));
}
public static Task <IGetOperationResult <T> > GetAsync <T>(this IMemcachedClient self, string key)
{
return(self.GetAsync <T>(key, Protocol.NO_CAS));
}
public async Task <T> GetAsync <T>(string key)
{
return((await _client.GetAsync <T>(key)).Value);
}
public async ValueTask <T> Get <T>(string key)
{
var valueResult = await _memcachedClient.GetAsync <T>(key);
return(valueResult.HasValue ? valueResult.Value : default);
public static IGetOperationResult <T> Get <T>(this IMemcachedClient self, string key, ulong cas = Protocol.NO_CAS)
{
return(self.GetAsync <T>(key, cas).RunAndUnwrap());
}
public string StringGet(string key)
{
return(_memcache.GetAsync <string>(key).Result);
}
public static IDictionary <string, IGetOperationResult <object> > Get(this IMemcachedClient self, IEnumerable <string> keys)
{
var keysWithoutCas = keys.Select(k => new KeyValuePair <string, ulong>(k, Protocol.NO_CAS));
return(self.GetAsync(keysWithoutCas).RunAndUnwrap());
}
