/// <summary>
/// Adds an object into cache based on the parameters provided.
/// </summary>
/// <param name="tag">The tag.</param>
/// <param name="name">The name.</param>
/// <param name="itemPolicy">The itemPolicy object.</param>
/// <param name="value">The value to store in cache.</param>
/// <param name="dispatch">The dispatch.</param>
/// <returns></returns>
public object Set(object tag, string name, CacheItemPolicy itemPolicy, object value, ServiceCacheByDispatcher dispatch)
{
if (itemPolicy == null)
{
throw new ArgumentNullException("itemPolicy");
}
var updateCallback = itemPolicy.UpdateCallback;
if (updateCallback != null)
{
updateCallback(name, value);
}
string regionName;
Settings.TryGetRegion(ref name, out regionName);
//
Cache.Set(name, value, GetCacheDependency(tag, itemPolicy, dispatch), regionName);
var registration = dispatch.Registration;
if (registration != null && registration.UseHeaders)
{
var headerPolicy = new SystemCaching.CacheItemPolicy();
headerPolicy.ChangeMonitors.Add(Cache.CreateCacheEntryChangeMonitor(new[] { name }, regionName));
var header = dispatch.Header;
header.Item = name;
Cache.Set(name + "#", header, headerPolicy, regionName);
}
return(value);
}
private void PrimeCache()
{
lock (_cache)
{
var policy = new CacheItemPolicy { Priority = CacheItemPriority.NotRemovable };
TexasHoldemOdds[] oddsList;
using (var cacheFile = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("PokerOdds.Web.OWIN.Cache.PrimeCache.json")))
{
oddsList = JsonConvert.DeserializeObject<TexasHoldemOdds[]>(cacheFile.ReadToEnd());
}
foreach (var odds in oddsList)
{
var keys = new string[0];
try
{
keys = _cache.GetKeys();
}
catch { }
if (!keys.Contains(odds.GetCacheKey()))
{
_cache.Add(odds.GetCacheKey(), odds, policy);
}
}
}
}
public async Task<IAnime> GetAnime(int id)
{
IAnime finalItem = null;
var item = _animeCahce.Get(id.ToString());
if (item == null)
{
Console.WriteLine($"{DateTime.Now} - [Cache] Cache miss [{id}]");
var anime = await _animeRetriever.GetAnime(id);
finalItem = anime;
var cip = new CacheItemPolicy
{
AbsoluteExpiration = DateTime.Now.AddHours(1),
RemovedCallback = RemovedCallback
};
lock (AnimePadlock.GetOrAdd(id.ToString(), new object()))
{
item = _animeCahce.Get(id.ToString());
if (item == null)
{
_animeCahce.Add(id.ToString(), finalItem, cip);
Console.WriteLine($"{DateTime.Now} [Cache] Added to cache [{id}]");
}
}
}
else
{
Console.WriteLine($"{DateTime.Now} - [Cache] Cache hit [{id}]");
finalItem = (IAnime) item;
}
return finalItem;
}
public void Set(string key, object data, string filePath)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.ChangeMonitors.Add(new HostFileChangeMonitor(new List<string> { filePath }));
Cache.Add(new CacheItem(key, data), policy);
}
public override void Set(string key, object value, TimeSpan? slidingExpireTime = null, TimeSpan? absoluteExpireTime = null)
{
if (value == null)
{
throw new AbpException("Can not insert null values to the cache!");
}
var cachePolicy = new CacheItemPolicy();
if (absoluteExpireTime != null)
{
cachePolicy.AbsoluteExpiration = DateTimeOffset.Now.Add(absoluteExpireTime.Value);
}
else if (slidingExpireTime != null)
{
cachePolicy.SlidingExpiration = slidingExpireTime.Value;
}
else if(DefaultAbsoluteExpireTime != null)
{
cachePolicy.AbsoluteExpiration = DateTimeOffset.Now.Add(DefaultAbsoluteExpireTime.Value);
}
else
{
cachePolicy.SlidingExpiration = DefaultSlidingExpireTime;
}
_memoryCache.Set(key, value, cachePolicy);
}
/// <summary>
/// 添加
/// </summary>
/// <param name="key"></param>
/// <param name="obj"></param>
public void Add(string key, object obj)
{
var cacheItem = new CacheItem(GeneralKey(key), obj);
var cacheItemPolicy = new CacheItemPolicy();
cache.Add(cacheItem, cacheItemPolicy);
}
public void Add(TenantInstance instance, Action<string, TenantInstance> removedCallback)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (removedCallback == null)
{
removedCallback = delegate { };
}
// Add a cache entry for the instance id that will be used as a cache dependency
// for the running instances
var cacheDependencyPolicy = new CacheItemPolicy
{
// Make the "MaxAge" configurable - when the dependency is removed so are the instances
AbsoluteExpiration = DateTimeOffset.UtcNow.AddHours(12)
};
var cacheDependency = new CacheItem(instance.Id.ToString(), instance.Id);
// We need to add the dependency before we set up the instance change monitors,
// otherwise they'll be removed from the cache immediately!
cache.Set(instance.Id.ToString(), instance.Id, cacheDependencyPolicy);
// Now cache the running instance for each identifier
// The policies must be unique since the RemovedCallback can only be called once-per-policy
foreach (var id in instance.Tenant.RequestIdentifiers)
{
cache.Set(new CacheItem(id, instance), GetCacheItemPolicy(removedCallback, cacheDependency));
}
}
protected override void Save(string key, object value, CacheItemPolicy policy)
{
try
{
var expiration = policy.SlidingExpiration;
if (policy.SlidingExpiration == TimeSpan.MinValue)
{
expiration = _default_duration;
}
var cache = GetCache();
if (Exists(key))
{
_cache.Put(key, value, expiration);
}
else
{
cache.Add(key, value, expiration);
}
}
catch (Exception ex)
{
Trace.TraceError(string.Format("Caching error; Message {0} Trace {1}", ex.Message, ex.StackTrace));
}
}
public void SqlQuerySingleEntityFactoryCache()
{
var session = new DataSession("Tracker").Log(Console.WriteLine);
session.Should().NotBeNull();
string email = "*****@*****.**";
string sql = "select * from [User] where EmailAddress = @EmailAddress";
var policy = new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) };
var user = session.Sql(sql)
.Parameter("@EmailAddress", email)
.UseCache(policy)
.QuerySingle<User>();
user.Should().NotBeNull();
user.EmailAddress.Should().Be(email);
var cachedUser = session.Sql(sql)
.Parameter("@EmailAddress", email)
.UseCache(policy)
.QuerySingle<User>();
cachedUser.Should().NotBeNull();
cachedUser.EmailAddress.Should().Be(email);
}
public static string GetConfig(string key)
{
string output = string.Empty;
ObjectCache cache = MemoryCache.Default;
Dictionary<string, string> textConfigs = cache[CACHE_KEY] as Dictionary<string, string>;
if (textConfigs == null)
{
CacheItemPolicy policy = new CacheItemPolicy();
List<string> filePaths = new List<string>();
filePaths.Add(fileName);
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
textConfigs = File
.ReadAllLines(fileName)
.Select(x => x.Split('\t'))
.Where(x => x.Length > 1)
.ToDictionary(x => x[0].Trim(), x => x[(int)appEnv]);
cache.Set(CACHE_KEY, textConfigs, policy);
}
output = textConfigs[key];
return output;
}
private static bool IsPolicyValid(CacheItemPolicy policy) {
if (policy == null) {
return false;
}
// see if any change monitors have changed
bool hasChanged = false;
Collection<ChangeMonitor> changeMonitors = policy.ChangeMonitors;
if (changeMonitors != null) {
foreach (ChangeMonitor monitor in changeMonitors) {
if (monitor != null && monitor.HasChanged) {
hasChanged = true;
break;
}
}
}
// if the monitors haven't changed yet and we have an update callback
// then the policy is valid
if (!hasChanged && policy.UpdateCallback != null) {
return true;
}
// if the monitors have changed we need to dispose them
if (hasChanged) {
foreach (ChangeMonitor monitor in changeMonitors) {
if (monitor != null) {
monitor.Dispose();
}
}
}
return false;
}
public void CachedLifetimeReturnsDifferentInstanceIfCacheExpired()
{
using (var container = new IocContainer())
{
var policy = new CacheItemPolicy()
{
SlidingExpiration = new TimeSpan(0, 0, 1)
};
container.Register<IFoo>(c => new Foo1()).WithCachedLifetime(policy);
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
Thread.Sleep(1500);
var result3 = container.Resolve<IFoo>();
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.AreSame(result1, result2);
Assert.AreNotSame(result1, result3);
}
}
public void Agregar(string key, object valor)
{
Condicion.ValidarParametro(key).IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
Condicion.ValidarParametro(valor).IsNotNull("El valor no puede ser nulo.");
var politica = new CacheItemPolicy();
_objectCache.Add(key, valor, politica);
}
public IEnumerable<INamedColourDetail> GetNamedColourDetails()
{
ObjectCache cache = MemoryCache.Default;
List<NamedColourDetail> namedColours = cache["NamedColourDetailList"] as List<NamedColourDetail>;
if ( namedColours == null)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = new DateTimeOffset(DateTime.UtcNow.AddMinutes(20)); // TODO read cache timeout from config
string namedColourFileName = "NamedColours.json";
if (!File.Exists(namedColourFileName))
{
throw new ApplicationException("missing named colours file " + namedColourFileName);
}
string namedColoursJSON = File.ReadAllText(namedColourFileName);
namedColours = JsonConvert.DeserializeObject<List<NamedColourDetail>>(namedColoursJSON);
cache.Set("NamedColourDetailList", namedColours, policy);
}
return namedColours;
}
public static bool IsInMaintenanceMode()
{
bool inMaintenanceMode;
string connStr = "Data Source=KIM-MSI\\KIMSSQLSERVER;Initial Catalog=MVWDataBase;User ID=sa;Password=mis123;MultipleActiveResultSets=True";
if (MemoryCache.Default["MaintenanceMode"] == null)
{
Console.WriteLine("Hitting the database...");
CacheItemPolicy policy = new CacheItemPolicy();
SqlDependency.Start(connStr);
using (SqlConnection conn = new SqlConnection(connStr))
{
using (SqlCommand command = new SqlCommand("Select MaintenanceMode From dbo.MaintenanceMode", conn))
{
command.Notification = null;
SqlDependency dep = new SqlDependency();
dep.AddCommandDependency(command);
conn.Open();
inMaintenanceMode = (bool)command.ExecuteScalar();
SqlChangeMonitor monitor = new SqlChangeMonitor(dep);
policy.ChangeMonitors.Add(monitor);
dep.OnChange += Dep_OnChange;
}
}
MemoryCache.Default.Add("MaintenanceMode", inMaintenanceMode, policy);
}
else
{
inMaintenanceMode = (bool)MemoryCache.Default.Get("MaintenanceMode");
}
return inMaintenanceMode;
}
/// <summary>
/// Adds an item to the cache.
/// </summary>
/// <param name="key">
/// A unique identifier for the cache entry.
/// </param>
/// <param name="value">
/// The object to insert.
/// </param>
/// <param name="policy">
/// Optional. An <see cref="T:System.Runtime.Caching.CacheItemPolicy"/> object that contains eviction details for the cache entry. This object
/// provides more options for eviction than a simple absolute expiration. The default value for the optional parameter
/// is null.
/// </param>
/// <param name="regionName">
/// Optional. A named region in the cache to which the cache entry can be added,
/// if regions are implemented. The default value for the optional parameter
/// is null.
/// </param>
/// <returns>
/// True if the insertion try succeeds, or false if there is an already an entry
/// in the cache with the same key as key.
/// </returns>
public static bool AddItem(string key, object value, CacheItemPolicy policy = null, string regionName = null)
{
bool isAdded;
using (new WriteLock(Locker))
{
if (policy == null)
{
// Create a new cache policy with the default values
policy = new CacheItemPolicy();
}
try
{
Cache.Set(key, value, policy, regionName);
isAdded = true;
}
catch
{
isAdded = false;
}
if (isAdded)
{
CacheItems[key] = regionName;
}
}
return isAdded;
}
public void Set(string key, object data, int cacheTime)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
Cache.Add(new CacheItem(key, data), policy);
}
/// <summary>
/// Insert or update a cache value with an expiry date
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="expiresAt"></param>
protected override void SetInternal(string key, object value, DateTime expiresAt)
{
var policy = new sys.CacheItemPolicy();
policy.AbsoluteExpiration = expiresAt;
Set(key, value, policy);
}
public static void Set(string key, object value, int minutesToCache = 20, bool slidingExpiration = true)
{
if (minutesToCache <= 0)
{
throw new ArgumentOutOfRangeException("minutesToCache",
String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
}
else if (slidingExpiration && (minutesToCache > 365 * 24 * 60))
{
// For sliding expiration policies, MemoryCache has a time limit of 365 days.
throw new ArgumentOutOfRangeException("minutesToCache",
String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_LessThanOrEqualTo, 365 * 24 * 60));
}
CacheItemPolicy policy = new CacheItemPolicy();
TimeSpan expireTime = new TimeSpan(0, minutesToCache, 0);
if (slidingExpiration)
{
policy.SlidingExpiration = expireTime;
}
else
{
policy.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(minutesToCache);
}
MemoryCache.Default.Set(key, value, policy);
}
public static void AddServerToCache(string server, ServerInfo si, CacheItemPolicy cip)
{
if (si != null && si.port != 0)
{
//ServerInfo si = alo.result.serverInfos[server];
if (si.players != null)
{
if (si.players.Count > 2)
{
si.normalTeamGame = checkIfTeamGame(si);
}
if (si.normalTeamGame)
{
si.players.Sort(PlayersSort.TeamSort);
}
else
{
si.players.Sort(PlayersSort.ScoreSort);
}
}
oc.Set(server, si, cip);
} //or maxplayers == -1 or numPlayers, etc
else
{
Debug.WriteLine("[{0}] {1} \t No response", DateTime.Now, server);
}
//string id = Ext.CreateReadableID(server, si.hostPlayer);
//context.Clients.All.addServer(id, server, si);
}
public override object AddOrGetExisting(string key, object value, CacheItemPolicy policy, string regionName = null)
{
return this.AddOrInsert(
HttpContext.Current.Cache.Add,
key, value, policy, regionName
);
}
public static StatisticsRootObject GetStatistics(DateTime from, DateTime to, string lang, int count = 15)
{
if (MemoryCache.Default["GetStat_"+lang] != null)
return MemoryCache.Default["GetStat_" + lang] as StatisticsRootObject;
string basePath = GetPath();
//Alla
//http://localhost:83/secret/Find/proxy/_stats/query/top?from=2016-02-23T09%3A00%3A00Z&to=2016-02-24T09%3A00%3A00Z&interval=day&type=top&size=30&dojo.preventCache=1456301878242
//Utan träffar
//http://localhost:83/secret/Find/proxy/_stats/query/top?from=2016-02-23T09%3A00%3A00Z&to=2016-02-24T09%3A00%3A00Z&interval=day&type=null&size=30&dojo.preventCache=1456301993480
//Utan relevanta träffar (dvs ingen klickad på ...)
//http://localhost:83/secret/Find/proxy/_stats/query/top?from=2016-02-23T09%3A00%3A00Z&to=2016-02-24T09%3A00%3A00Z&interval=day&type=nullclick&extended=true&size=25&dojo.preventCache=1456302059188
var requestAll = (HttpWebRequest)WebRequest.Create(basePath + "_stats/query/top?from=" + from.ToString("yyyy-MM-dd") + "&to=" + to.AddDays(1).ToString("yyyy-MM-dd") + "&interval=day&type=top&tags=language%3A"+lang+"&size=" + count + "&dojo.preventCache=" + DateTime.Now.Ticks);
var responseAll = (HttpWebResponse)requestAll.GetResponse();
var responseString = new StreamReader(responseAll.GetResponseStream()).ReadToEnd();
var requestNull = (HttpWebRequest)WebRequest.Create(basePath + "_stats/query/top?from=" + from.ToString("yyyy-MM-dd") + "&to=" + to.AddDays(1).ToString("yyyy-MM-dd") + "&interval=day&type=null&tags=language%3A" + lang + "&size=" + count + "&dojo.preventCache=" + DateTime.Now.Ticks);
var responseNull = (HttpWebResponse)requestNull.GetResponse();
var responseStringNull = new StreamReader(responseNull.GetResponseStream()).ReadToEnd();
var resultAll = Newtonsoft.Json.JsonConvert.DeserializeObject(responseString, typeof(StatisticsRootObject));
var resultNull = Newtonsoft.Json.JsonConvert.DeserializeObject(responseStringNull, typeof(StatisticsRootObject));
List<Hit> modifiedHitList = new List<Hit>();
if (resultAll != null && resultNull != null)
{
modifiedHitList = ((StatisticsRootObject)resultAll).hits.Except(((StatisticsRootObject)resultNull).hits).ToList();
((StatisticsRootObject)resultAll).hits = modifiedHitList;
}
//Insert data cache item with sliding timeout using changeMonitors
CacheItemPolicy itemPolicy = new CacheItemPolicy();
itemPolicy.SlidingExpiration = new TimeSpan(0, 5, 0);
MemoryCache.Default.Add("GetStat_" + lang, resultAll as StatisticsRootObject, itemPolicy, null);
return resultAll as StatisticsRootObject;
}
private CacheItemPolicy CreatePolicy(IEnumerable<CacheExpirationInfo> expirationConfigs)
{
var policy = new CacheItemPolicy();
foreach (CacheExpirationInfo config in expirationConfigs) {
switch (config.Type) {
case "never":
policy.Priority = CacheItemPriority.NotRemovable;
break;
case "file":
if (!string.IsNullOrEmpty(config.Param)) {
policy.ChangeMonitors.Add(new HostFileChangeMonitor(new[] { config.Param }));
}
break;
case "absolute":
TimeSpan absoluteSpan;
if (TimeSpan.TryParse(config.Param, out absoluteSpan)) {
policy.AbsoluteExpiration = DateTimeOffset.Now.Add(absoluteSpan);
}
break;
case "sliding":
TimeSpan slidingSpan;
if (TimeSpan.TryParse(config.Param, out slidingSpan)) {
policy.SlidingExpiration = slidingSpan;
}
break;
}
}
return policy;
}
private void AddWithoutCheck(DataCacheObject obj)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromSeconds(obj.CacheTime);
lock (Cache)
Cache.Add(new CacheItem(GetKey(obj), obj.Data), policy);
}
protected void Page_Load(object sender, EventArgs e)
{
ObjectCache cache = MemoryCache.Default;
string usernameFromXml = cache["userFromXml"] as string;
if (usernameFromXml == null)
{
List<string> userFilePath = new List<string>();
userFilePath.Add(@"C:\Username.xml");
CacheItemPolicy policy = new CacheItemPolicy();
policy.ChangeMonitors.Add(new HostFileChangeMonitor(userFilePath));
XDocument xdoc = XDocument.Load(@"C:\Username.xml");
var query = from u in xdoc.Elements("usernames")
select u.Value;
usernameFromXml = query.First().ToString();
cache.Set("userFromXml", usernameFromXml, policy);
}
Label1.Text = usernameFromXml;
}
public DealsDto[] GetAllActiveDeals(bool canLoadCachedDeals)
{
try
{
var configLoader = new ConfigHelper();
if (!canLoadCachedDeals)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration =
DateTimeOffset.Now.AddMinutes(configLoader.GetAppSettingsIntlValue("DealCacheDuration"));
var dealsToBind = dDal.GetAllActiveDeals();
cacheDealObject.Set("Deals", dealsToBind, policy);
return dealsToBind;
}
DealsDto[] dealsToBindFromCache = cacheDealObject["Deals"] as DealsDto[];
if (dealsToBindFromCache == null)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration =
DateTimeOffset.Now.AddMinutes(configLoader.GetAppSettingsIntlValue("DealCacheDuration"));
dealsToBindFromCache = dDal.GetAllActiveDeals();
cacheDealObject.Set("Deals", dealsToBindFromCache, policy);
}
return dealsToBindFromCache;
}
catch (Exception ex)
{
lBal.LogMessage(ex.InnerException.Message + "at " + ex.StackTrace, LogMessageTypes.Error);
return null;
}
}
public static string GetHtmlPageContent(string path)
{
var key = HtmlPageContentKeyPrefix + path;
var cache = MemoryCache.Default;
var cachedPage = (string)cache.Get(key);
if (cachedPage != null)
return cachedPage;
lock (CacheLock)
{
cachedPage = (string)cache.Get(key);
if (cachedPage != null)
return cachedPage;
var htmlPath = HttpContext.Current.Server.MapPath(path);
cachedPage = File.ReadAllText(htmlPath, Encoding.UTF8);
// создаём политику хранения данных
var policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(Settings.Default.HtmlPageCacheAge);
// сохраняем данные в кэше
cache.Add(key, cachedPage, policy);
return cachedPage;
}
}
private void ExecuteSearch(string searchTerm)
{
ThreadPool.QueueUserWorkItem(o =>
{
var searchTermEncode = HttpUtility.UrlEncode(searchTerm);
var key = String.Format("{0}:{1}", GetType().Name, searchTermEncode);
ObjectCache cache = MemoryCache.Default;
var bowerPackagesFromMemory = cache.Get(key) as IEnumerable<string>;
if (bowerPackagesFromMemory != null)
{
_searchResults = bowerPackagesFromMemory;
}
else
{
string url = string.Format(Constants.SearchUrl, searchTermEncode);
string result = Helper.DownloadText(url);
var children = GetChildren(result);
if (!children.Any())
{
_dte.StatusBar.Text = "No packages found matching '" + searchTerm + "'";
base.Session.Dismiss();
return;
}
_dte.StatusBar.Text = string.Empty;
_searchResults = children;
var cachePolicy = new CacheItemPolicy();
cache.Set(key, _searchResults, cachePolicy);
}
Helper.ExecuteCommand(_dte, "Edit.CompleteWord");
});
}
public async Task<IAnime> GetAnime(int id)
{
IAnime finalItem;
var item = _animeCahce.Get(id.ToString());
if (item == null)
{
Log.Information("Cache miss for {AnimeId}", id);
var anime = await _animeRetriever.GetAnime(id);
finalItem = anime;
var cip = new CacheItemPolicy
{
AbsoluteExpiration = DateTime.Now.AddHours(1),
RemovedCallback = RemovedCallback
};
lock (_animePadlock.GetOrAdd(id.ToString(), new object()))
{
item = _animeCahce.Get(id.ToString());
if (item == null)
{
_animeCahce.Add(id.ToString(), finalItem, cip);
Log.Information("Added {AnimeId} to cache", id);
}
}
}
else
{
Log.Information("Cache hit for {AnimeId}", id);
finalItem = (IAnime) item;
}
return finalItem;
}
protected override void SetInternal(string key, object value, TimeSpan lifespan)
{
var policy = new sys.CacheItemPolicy();
policy.SlidingExpiration = lifespan;
Set(key, value, policy);
}
public void AddItem(CacheItem item, double span)
{
CacheItemPolicy cp = new CacheItemPolicy();
cp.SlidingExpiration.Add(TimeSpan.FromMinutes(span));
cache.Add(item, cp);
}
/// <summary>
/// Return all the CommonFilter
/// </summary>
/// <param name="bypassCache">Option to go directly to the DB default false</param>
/// <returns>Return all the CommonFilter</returns>
public IHttpActionResult Get(bool bypassCache = false)
{
try
{
var response = new List<CommonFilter>();
var memCache = MemoryCache.Default.Get("CommonFilters");
if ((bypassCache) || (memCache == null))
{
using (var context = new DbModel())
{
response = context.CommonFilters.ToList();
}
var policy = new CacheItemPolicy { SlidingExpiration = TimeSpan.FromHours(1) };
MemoryCache.Default.Add("CommonFilters", response, policy);
}
else
{
response = (List<CommonFilter>)memCache;
}
return Ok(response);
}
catch (Exception e)
{
logger.Error(e);
return InternalServerError(e);
}
}
void IDnsCache.Set(string key, byte[] bytes, int ttlSeconds)
{
CacheItem item = new CacheItem(key, bytes);
CacheItemPolicy policy = new CacheItemPolicy {AbsoluteExpiration = DateTimeOffset.Now + TimeSpan.FromSeconds(ttlSeconds)};
_cache.Add(item, policy);
}
public DataTable GetProdutos(string connection, ABUtil.ABCommandArgs AbArgs)
{
try
{
DataTable Produtos = cache["Produtos"] as DataTable;
WriteLog.Log(System.Diagnostics.TraceLevel.Info, LogTypeName.TAT2Request, "GetProdutos - TB196 ", AbArgs.USERNT, AbArgs.SN_HOSTNAME);
//Vai lêr à tabela
if (Produtos == null)
{
OdbcConnection con = new OdbcConnection(connection);
DataSet ds = new DataSet();
try
{
OdbcDataAdapter ad = new OdbcDataAdapter("SELECT CELEMTAB1, GELEM30, NELEMC01, NELEMC02 FROM TB196 where NELEMC01 != '' AND NELEMC13 = 'S' order by NELEMC01", con); //Tabela geral TB196
ad.Fill(ds);
}
finally
{
con.Close();
}
WriteLog.Log(System.Diagnostics.TraceLevel.Verbose, LogTypeName.TAT2Request, "Setting cache for [Produtos]", AbArgs.USERNT, AbArgs.SN_HOSTNAME);
//Set Cache
System.Runtime.Caching.CacheItemPolicy policy = new System.Runtime.Caching.CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddDays(1);
cache.Set("Produtos", ds.Tables[0], policy);
WriteLog.Log(System.Diagnostics.TraceLevel.Verbose, LogTypeName.TAT2Request, "Retun value count: " + ds.Tables[0].Rows.Count, AbArgs.USERNT, AbArgs.SN_HOSTNAME);
return(ds.Tables[0]);
}
//Devolver valor em cache
else
{
WriteLog.Log(System.Diagnostics.TraceLevel.Verbose, LogTypeName.TAT2Request, "Cache found for [Produtos] : " + Produtos.Rows.Count, AbArgs.USERNT, AbArgs.SN_HOSTNAME);
return(Produtos);
}
}
catch (Exception ex)
{
WriteLog.Log(System.Diagnostics.TraceLevel.Error, MultilinhasObjects.LogTypeName.TAT2Request, ex, AbArgs.USERNT, AbArgs.SN_HOSTNAME);
DataTable dt = new DataTable();
return(dt);
}
}
public ASP.CacheItemPolicy GetCacheItemPolicy()
{
ASP.CacheItemPolicy policy = new ASP.CacheItemPolicy
{
AbsoluteExpiration = this._absoluteOffset == TimeSpan.Zero ? this.AbsoluteExpiration : DateTime.Now.Add(this._absoluteOffset),
SlidingExpiration = this.SlidingExpiration,
Priority = this.Priority,
// TODO: Add Callback Support
};
// TODO: Add dependency tracking
// if (this.Dependencies.CacheKeys != null && this.Dependencies.CacheKeys.Count() > 0)
// {
// policy.ChangeMonitors.Add(ASP.MemoryCache.Default.CreateCacheEntryChangeMonitor(this.Dependencies.CacheKeys.Distinct()));
// }
// TODO: Add more Support for more ChangeMonitors (Files + SQL)
return(policy);
}
public static void SetMemoryCacheDefault(this string key, object obj, int seconds = 7200)
{
try
{
var cache = System.Runtime.Caching.MemoryCache.Default;
var policy = new System.Runtime.Caching.CacheItemPolicy
{
AbsoluteExpiration = DateTime.Now.AddSeconds(seconds)
};
cache.Set(key, obj, policy);
}
catch (Exception ex)
{
Console.WriteLine(string.Format("异常[{0}]:{1}", System.Reflection.MethodBase.GetCurrentMethod().ReflectedType.FullName, ex.Message));
}
finally
{
}
}
private SystemCaching.CacheItemPolicy GetCacheDependency(object tag, CacheItemPolicy itemPolicy, ServiceCacheByDispatcher dispatch)
{
// item priority
SystemCaching.CacheItemPriority itemPriority;
switch (itemPolicy.Priority)
{
case CacheItemPriority.NotRemovable:
itemPriority = SystemCaching.CacheItemPriority.NotRemovable;
break;
default:
itemPriority = SystemCaching.CacheItemPriority.Default;
break;
}
var removedCallback = (itemPolicy.RemovedCallback != null ? new SystemCaching.CacheEntryRemovedCallback(x => { itemPolicy.RemovedCallback(x.CacheItem.Key, x.CacheItem.Value); }) : null);
var updateCallback = (itemPolicy.UpdateCallback != null ? new SystemCaching.CacheEntryUpdateCallback(x => { itemPolicy.UpdateCallback(x.UpdatedCacheItem.Key, x.UpdatedCacheItem.Value); }) : null);
var newItemPolicy = new SystemCaching.CacheItemPolicy
{
AbsoluteExpiration = itemPolicy.AbsoluteExpiration,
Priority = itemPriority,
RemovedCallback = removedCallback,
SlidingExpiration = itemPolicy.SlidingExpiration,
UpdateCallback = updateCallback,
};
var changeMonitors = GetCacheDependency(tag, itemPolicy.Dependency, dispatch);
if (changeMonitors != null)
{
var list = newItemPolicy.ChangeMonitors;
foreach (var changeMonitor in changeMonitors)
{
list.Add(changeMonitor);
}
}
return(newItemPolicy);
}
public virtual bool Add(CacheItem item, CacheItemPolicy policy)
{
return(AddOrGetExisting(item, policy) == null);
}
public virtual bool Add(string key, object value, CacheItemPolicy policy, string regionName = null)
{
return(AddOrGetExisting(key, value, policy, regionName) == null);
}
public abstract CacheItem AddOrGetExisting(CacheItem value, CacheItemPolicy policy);
public abstract object AddOrGetExisting(string key, object value, CacheItemPolicy policy, string regionName = null);
public Boolean Add(ASP.CacheItem item, ASP.CacheItemPolicy policy)
{
return(false);
}
public override bool Add(CacheItem item, CacheItemPolicy policy)
{
CacheItem existingEntry = AddOrGetExisting(item, policy);
return(existingEntry == null || existingEntry.Value == null);
}
public override void Set(System.Runtime.Caching.CacheItem item, System.Runtime.Caching.CacheItemPolicy policy)
{
throw new NotImplementedException();
}
public override void Set(CacheItem item, CacheItemPolicy policy)
{
Add(item, policy);
}
public override object AddOrGetExisting(string key, object value, DateTimeOffset absoluteExpiration, string regionName = null)
{
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = absoluteExpiration;
return AddOrGetExisting(key, value, policy, regionName);
}
public abstract void Set(CacheItem item, CacheItemPolicy policy);
protected override void SetInternal(string key, object value)
{
var policy = new sys.CacheItemPolicy();
Set(key, value, policy);
}
public override object AddOrGetExisting(string key, object value, System.Runtime.Caching.CacheItemPolicy policy, string regionName = null)
{
throw new NotImplementedException();
}
public override System.Runtime.Caching.CacheItem AddOrGetExisting(System.Runtime.Caching.CacheItem value, System.Runtime.Caching.CacheItemPolicy policy)
{
throw new NotImplementedException();
}
public abstract void Set(string key, object value, CacheItemPolicy policy, string regionName = null);
public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null)
{
Add(key, value, policy, regionName);
}
private void Set(string key, object value, sys.CacheItemPolicy policy)
{
_cache.Set(key, value, policy);
}