MVC 2 - Caching Strings in Memory

MVC 2 - Caching Strings in Memory - c#

I would like to cache strings in memory from the database so that I do not have to access the database every time. I tried using System.Runtime.Caching, but it does not seem to work.
On the local site, all the data is cached but the user has to be authenticated on a secondary site. Once the user is authenticated, they are brought back to the local site but all the data that was cached is gone.
Is there a way to fix the above issue? Below is part of my code:
using System.Runtime.Caching;
ObjectCache cache = MemoryCache.Default;
public bool CacheIsSet(string key)
{
return cache.Contains(key);
}
public object CacheGet(string key)
{
return cache.Get(key);
}
public void CacheSet(string key, object value)
{
CacheItemPolicy policy = new CacheItemPolicy();
cache.Set(key, value, policy);
}
Thanks very much.

You should be referencing the HttpRuntime.Cache object. I created a wrapper around this, similar to what you have referenced in your question. Feel free to use it:
using System.Web.Caching;
public class CachingService
{
protected Cache Cache
{
get;
set;
}
public int CacheDurationMinutes
{
get;
set;
}
public CachingService()
{
Cache = HttpRuntime.Cache;
CacheDurationMinutes = 60;
}
public virtual object Get(string keyname)
{
return Cache[keyname];
}
public virtual T Get<T>(string keyname)
{
T item = (T)Cache[keyname];
return item;
}
public virtual void Insert(string keyname, object item)
{
Cache.Insert(keyname, item, null, DateTime.UtcNow.AddMinutes(CacheDurationMinutes), Cache.NoSlidingExpiration);
}
public virtual void Insert(string keyname, object item, CacheDependency dependency)
{
Cache.Insert(keyname, item, dependency);
}
public virtual void Remove(string keyname)
{
Cache.Remove(keyname);
}
}
Here is a sample use case. The function LoadPosts is supposed to load blog posts to display on the site. The function will first see if the posts are cached, if not it will load the posts from the database, and then cache them:
public IEnumerable<BlogPost> LoadPosts()
{
var cacheService = new CachingService();
var blogPosts = cacheService.Get<IEnumerable<BlogPost>>("BlogPosts");
if (blogPosts == null)
{
blogPosts = postManager.LoadPostsFromDatabase();
cacheService.Insert("BlogPosts", blogPosts);
}
return blogPosts;
}
The first time this function is run, the cache will return null, because we didn't add anything to the BlogPosts key yet. The second time the function is called the posts will be in the cache and the code in the if block will not run, saving us a trip to the database.

Related

Call code once when controller is first accessed [duplicate]

I have read lots of information about page caching and partial page caching in a MVC application. However, I would like to know how you would cache data.
In my scenario I will be using LINQ to Entities (entity framework). On the first call to GetNames (or whatever the method is) I want to grab the data from the database. I want to save the results in cache and on the second call to use the cached version if it exists.
Can anyone show an example of how this would work, where this should be implemented (model?) and if it would work.
I have seen this done in traditional ASP.NET apps , typically for very static data.

Here's a nice and simple cache helper class/service I use:
using System.Runtime.Caching;
public class InMemoryCache: ICacheService
{
public T GetOrSet<T>(string cacheKey, Func<T> getItemCallback) where T : class
{
T item = MemoryCache.Default.Get(cacheKey) as T;
if (item == null)
{
item = getItemCallback();
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.AddMinutes(10));
}
return item;
}
}
interface ICacheService
{
T GetOrSet<T>(string cacheKey, Func<T> getItemCallback) where T : class;
}
Usage:
cacheProvider.GetOrSet("cache key", (delegate method if cache is empty));
Cache provider will check if there's anything by the name of "cache id" in the cache, and if there's not, it will call a delegate method to fetch data and store it in cache.
Example:
var products=cacheService.GetOrSet("catalog.products", ()=>productRepository.GetAll())

Reference the System.Web dll in your model and use System.Web.Caching.Cache
public string[] GetNames()
{
string[] names = Cache["names"] as string[];
if(names == null) //not in cache
{
names = DB.GetNames();
Cache["names"] = names;
}
return names;
}
A bit simplified but I guess that would work. This is not MVC specific and I have always used this method for caching data.

I'm referring to TT's post and suggest the following approach:
Reference the System.Web dll in your model and use System.Web.Caching.Cache
public string[] GetNames()
{
var noms = Cache["names"];
if(noms == null)
{
noms = DB.GetNames();
Cache["names"] = noms;
}
return ((string[])noms);
}
You should not return a value re-read from the cache, since you'll never know if at that specific moment it is still in the cache. Even if you inserted it in the statement before, it might already be gone or has never been added to the cache - you just don't know.
So you add the data read from the database and return it directly, not re-reading from the cache.

For .NET 4.5+ framework
add reference: System.Runtime.Caching
add using statement:
using System.Runtime.Caching;
public string[] GetNames()
{
var noms = System.Runtime.Caching.MemoryCache.Default["names"];
if(noms == null)
{
noms = DB.GetNames();
System.Runtime.Caching.MemoryCache.Default["names"] = noms;
}
return ((string[])noms);
}
In the .NET Framework 3.5 and earlier versions, ASP.NET provided an in-memory cache implementation in the System.Web.Caching namespace. In previous versions of the .NET Framework, caching was available only in the System.Web namespace and therefore required a dependency on ASP.NET classes. In the .NET Framework 4, the System.Runtime.Caching namespace contains APIs that are designed for both Web and non-Web applications.
More info:
https://msdn.microsoft.com/en-us/library/dd997357(v=vs.110).aspx
https://learn.microsoft.com/en-us/dotnet/framework/performance/caching-in-net-framework-applications

Steve Smith did two great blog posts which demonstrate how to use his CachedRepository pattern in ASP.NET MVC. It uses the repository pattern effectively and allows you to get caching without having to change your existing code.
http://ardalis.com/Introducing-the-CachedRepository-Pattern
http://ardalis.com/building-a-cachedrepository-via-strategy-pattern
In these two posts he shows you how to set up this pattern and also explains why it is useful. By using this pattern you get caching without your existing code seeing any of the caching logic. Essentially you use the cached repository as if it were any other repository.

I have used it in this way and it works for me.
https://msdn.microsoft.com/en-us/library/system.web.caching.cache.add(v=vs.110).aspx
parameters info for system.web.caching.cache.add.
public string GetInfo()
{
string name = string.Empty;
if(System.Web.HttpContext.Current.Cache["KeyName"] == null)
{
name = GetNameMethod();
System.Web.HttpContext.Current.Cache.Add("KeyName", name, null, DateTime.Noew.AddMinutes(5), Cache.NoSlidingExpiration, CacheitemPriority.AboveNormal, null);
}
else
{
name = System.Web.HttpContext.Current.Cache["KeyName"] as string;
}
return name;
}

AppFabric Caching is distributed and an in-memory caching technic that stores data in key-value pairs using physical memory across multiple servers. AppFabric provides performance and scalability improvements for .NET Framework applications. Concepts and Architecture

Extending #Hrvoje Hudo's answer...
Code:
using System;
using System.Runtime.Caching;
public class InMemoryCache : ICacheService
{
public TValue Get<TValue>(string cacheKey, int durationInMinutes, Func<TValue> getItemCallback) where TValue : class
{
TValue item = MemoryCache.Default.Get(cacheKey) as TValue;
if (item == null)
{
item = getItemCallback();
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.AddMinutes(durationInMinutes));
}
return item;
}
public TValue Get<TValue, TId>(string cacheKeyFormat, TId id, int durationInMinutes, Func<TId, TValue> getItemCallback) where TValue : class
{
string cacheKey = string.Format(cacheKeyFormat, id);
TValue item = MemoryCache.Default.Get(cacheKey) as TValue;
if (item == null)
{
item = getItemCallback(id);
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.AddMinutes(durationInMinutes));
}
return item;
}
}
interface ICacheService
{
TValue Get<TValue>(string cacheKey, Func<TValue> getItemCallback) where TValue : class;
TValue Get<TValue, TId>(string cacheKeyFormat, TId id, Func<TId, TValue> getItemCallback) where TValue : class;
}
Examples
Single item caching (when each item is cached based on its ID because caching the entire catalog for the item type would be too intensive).
Product product = cache.Get("product_{0}", productId, 10, productData.getProductById);
Caching all of something
IEnumerable<Categories> categories = cache.Get("categories", 20, categoryData.getCategories);
Why TId
The second helper is especially nice because most data keys are not composite. Additional methods could be added if you use composite keys often. In this way you avoid doing all sorts of string concatenation or string.Formats to get the key to pass to the cache helper. It also makes passing the data access method easier because you don't have to pass the ID into the wrapper method... the whole thing becomes very terse and consistant for the majority of use cases.

Here's an improvement to Hrvoje Hudo's answer. This implementation has a couple of key improvements:
Cache keys are created automatically based on the function to update data and the object passed in that specifies dependencies
Pass in time span for any cache duration
Uses a lock for thread safety
Note that this has a dependency on Newtonsoft.Json to serialize the dependsOn object, but that can be easily swapped out for any other serialization method.
ICache.cs
public interface ICache
{
T GetOrSet<T>(Func<T> getItemCallback, object dependsOn, TimeSpan duration) where T : class;
}
InMemoryCache.cs
using System;
using System.Reflection;
using System.Runtime.Caching;
using Newtonsoft.Json;
public class InMemoryCache : ICache
{
private static readonly object CacheLockObject = new object();
public T GetOrSet<T>(Func<T> getItemCallback, object dependsOn, TimeSpan duration) where T : class
{
string cacheKey = GetCacheKey(getItemCallback, dependsOn);
T item = MemoryCache.Default.Get(cacheKey) as T;
if (item == null)
{
lock (CacheLockObject)
{
item = getItemCallback();
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.Add(duration));
}
}
return item;
}
private string GetCacheKey<T>(Func<T> itemCallback, object dependsOn) where T: class
{
var serializedDependants = JsonConvert.SerializeObject(dependsOn);
var methodType = itemCallback.GetType();
return methodType.FullName + serializedDependants;
}
}
Usage:
var order = _cache.GetOrSet(
() => _session.Set<Order>().SingleOrDefault(o => o.Id == orderId)
, new { id = orderId }
, new TimeSpan(0, 10, 0)
);

public sealed class CacheManager
{
private static volatile CacheManager instance;
private static object syncRoot = new Object();
private ObjectCache cache = null;
private CacheItemPolicy defaultCacheItemPolicy = null;
private CacheEntryRemovedCallback callback = null;
private bool allowCache = true;
private CacheManager()
{
cache = MemoryCache.Default;
callback = new CacheEntryRemovedCallback(this.CachedItemRemovedCallback);
defaultCacheItemPolicy = new CacheItemPolicy();
defaultCacheItemPolicy.AbsoluteExpiration = DateTime.Now.AddHours(1.0);
defaultCacheItemPolicy.RemovedCallback = callback;
allowCache = StringUtils.Str2Bool(ConfigurationManager.AppSettings["AllowCache"]); ;
}
public static CacheManager Instance
{
get
{
if (instance == null)
{
lock (syncRoot)
{
if (instance == null)
{
instance = new CacheManager();
}
}
}
return instance;
}
}
public IEnumerable GetCache(String Key)
{
if (Key == null || !allowCache)
{
return null;
}
try
{
String Key_ = Key;
if (cache.Contains(Key_))
{
return (IEnumerable)cache.Get(Key_);
}
else
{
return null;
}
}
catch (Exception)
{
return null;
}
}
public void ClearCache(string key)
{
AddCache(key, null);
}
public bool AddCache(String Key, IEnumerable data, CacheItemPolicy cacheItemPolicy = null)
{
if (!allowCache) return true;
try
{
if (Key == null)
{
return false;
}
if (cacheItemPolicy == null)
{
cacheItemPolicy = defaultCacheItemPolicy;
}
String Key_ = Key;
lock (Key_)
{
return cache.Add(Key_, data, cacheItemPolicy);
}
}
catch (Exception)
{
return false;
}
}
private void CachedItemRemovedCallback(CacheEntryRemovedArguments arguments)
{
String strLog = String.Concat("Reason: ", arguments.RemovedReason.ToString(), " | Key-Name: ", arguments.CacheItem.Key, " | Value-Object: ", arguments.CacheItem.Value.ToString());
LogManager.Instance.Info(strLog);
}
}

I use two classes. First one the cache core object:
public class Cacher<TValue>
where TValue : class
{
#region Properties
private Func<TValue> _init;
public string Key { get; private set; }
public TValue Value
{
get
{
var item = HttpRuntime.Cache.Get(Key) as TValue;
if (item == null)
{
item = _init();
HttpContext.Current.Cache.Insert(Key, item);
}
return item;
}
}
#endregion
#region Constructor
public Cacher(string key, Func<TValue> init)
{
Key = key;
_init = init;
}
#endregion
#region Methods
public void Refresh()
{
HttpRuntime.Cache.Remove(Key);
}
#endregion
}
Second one is list of cache objects:
public static class Caches
{
static Caches()
{
Languages = new Cacher<IEnumerable<Language>>("Languages", () =>
{
using (var context = new WordsContext())
{
return context.Languages.ToList();
}
});
}
public static Cacher<IEnumerable<Language>> Languages { get; private set; }
}

I will say implementing Singleton on this persisting data issue can be a solution for this matter in case you find previous solutions much complicated
public class GPDataDictionary
{
private Dictionary<string, object> configDictionary = new Dictionary<string, object>();
/// <summary>
/// Configuration values dictionary
/// </summary>
public Dictionary<string, object> ConfigDictionary
{
get { return configDictionary; }
}
private static GPDataDictionary instance;
public static GPDataDictionary Instance
{
get
{
if (instance == null)
{
instance = new GPDataDictionary();
}
return instance;
}
}
// private constructor
private GPDataDictionary() { }
} // singleton

HttpContext.Current.Cache.Insert("subjectlist", subjectlist);

You can also try and use the caching built into ASP MVC:
Add the following attribute to the controller method you'd like to cache:
[OutputCache(Duration=10)]
In this case the ActionResult of this will be cached for 10 seconds.
More on this here

How can I create a class that caches objects?

Im new to generics in c#, and I'm trying to create a storage that other parts of my program can ask for models objects.
The idea was that if my cache class has the object, it checks its date and returns it if the object is not older then 10 min.
If it is older then 10 min it downloads a updated model from the server online.
It it does not have the object is downloads it and returns it.
But I'm having some problems pairing my objects with a DateTime, makeing it all generic.
// model
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string[] args)
{
Person p = new Person();
Cache c = new Cache();
p = c.Get<Person>(p);
}
}
public class Cache
{
struct DatedObject<T>
{
public DateTime Time { get; set; }
public T Obj { get; set; }
}
List<DatedObject<T>> objects;
public Cache()
{
objects = new List<DatedObject<T>>();
}
public T Get<T>(T obj)
{
bool found = false;
// search to see if the object is stored
foreach(var elem in objects)
if( elem.ToString().Equals(obj.ToString() ) )
{
// the object is found
found = true;
// check to see if it is fresh
TimeSpan sp = DateTime.Now - elem.Time;
if( sp.TotalMinutes <= 10 )
return elem;
}
// object was not found or out of date
// download object from server
var ret = JsonConvert.DeserializeObject<T>("DOWNLOADED JSON STRING");
if( found )
{
// redate the object and replace it in list
foreach(var elem in objects)
if( elem.Obj.ToString().Equals(obj.ToString() ) )
{
elem.Obj = ret;
elem.Time = DateTime.Now;
}
}
else
{
// add the object to the list
objects.Add( new DatedObject<T>() { Time = DateTime.Now, Obj = ret });
}
return ret;
}
}

Check out the memory cache class available as part of the .NET framework http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache.aspx
You'll need to add the System.RunTime.Caching assembly as a reference to your application. The following is a helper class to add items and remove them from cache.
using System;
using System.Runtime.Caching;
public static class CacheHelper
{
public static void SaveTocache(string cacheKey, object savedItem, DateTime absoluteExpiration)
{
MemoryCache.Default.Add(cacheKey, savedItem, absoluteExpiration);
}
public static T GetFromCache<T>(string cacheKey) where T : class
{
return MemoryCache.Default[cacheKey] as T;
}
public static void RemoveFromCache(string cacheKey)
{
MemoryCache.Default.Remove(cacheKey);
}
public static bool IsIncache(string cacheKey)
{
return MemoryCache.Default[cacheKey] != null;
}
}
The nice thing about this is that it's thread safe, and it takes care of expiring the cache automatically for you. So basically all you have to do is check if getting an item from MemoryCache is null or not. Note however that MemoryCache is only available in .NET 4.0+
If your application is a web application then use System.Web.Caching rather than MemoryCache. System.Web.Caching has been available since .NET 1.1 and there's no additional references you have to add to your project. Heres the same helper class for web.
using System.Web;
public static class CacheHelper
{
public static void SaveTocache(string cacheKey, object savedItem, DateTime absoluteExpiration)
{
if (IsIncache(cacheKey))
{
HttpContext.Current.Cache.Remove(cacheKey);
}
HttpContext.Current.Cache.Add(cacheKey, savedItem, null, System.Web.Caching.Cache.NoAbsoluteExpiration, new TimeSpan(0, 10, 0), System.Web.Caching.CacheItemPriority.Default, null);
}
public static T GetFromCache<T>(string cacheKey) where T : class
{
return HttpContext.Current.Cache[cacheKey] as T;
}
public static void RemoveFromCache(string cacheKey)
{
HttpContext.Current.Cache.Remove(cacheKey);
}
public static bool IsIncache(string cacheKey)
{
return HttpContext.Current.Cache[cacheKey] != null;
}
}
There are other cache expiration policies that you can use for both of these patterns, for instance cache based on a file path(s) so that when a file changes the cache automatically expires, SQL cache dependency (does periodic polling of the SQL server for changes), sliding expiration or you could build your own. They come in really handy.

storing items in ObjectCache : cant get old values

I use MemoryCache.Default instance of ObjectCache for storing data in MVC application; Every time I save some item and than immedeatly read it I see that items are stored as expected.But when new instance of Cashing class ( I mean class that used ObjectCache) is created I cant access old values.I have imlemented singleton for keeping only one instance for ObjectCache but this doesnt help me.
//here is single instance of caching object
public class CacheSingleton
{
private static CacheSingleton instance;
private CacheSingleton() { cache = MemoryCache.Default; }
public static CacheSingleton Instance
{
get
{
if (instance == null)
{
instance = new CacheSingleton();
}
return instance;
}
}
public ObjectCache cache { get; private set; }
}
// and here is piece of caching class
.........
private ObjectCache cache;
public DefaultCacheProvider()
{
cache = CacheSingleton.Instance.cache;
}
public object Get(string key)
{
return cache[key];
}
public void Set(string key, object data, int cacheTime, bool isAbsoluteExpiration)
{
CacheItemPolicy policy = new CacheItemPolicy();
if (isAbsoluteExpiration)
{
policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
}
else
{
policy.SlidingExpiration = TimeSpan.FromMinutes(cacheTime);
}
cache.Add(new CacheItem(key, data), policy);
}
public bool IsSet(string key)
{
return (cache[key] != null);
}
public void Invalidate(string key)
{
cache.Remove(key);
}
Can anybody explain why with every new instance of caching class (last code) I cant access old values.Thanks.

how use caching in asp.net mvc3?

I have problem with cache in my asp.net mvc3 application.
My code
using System.Web.Caching;
...
class RegularCacheProvider : ICacheProvider
{
Cache cache ;
public object Get(string name)
{
return cache[name];
}
public void Set(string name, object value)
{
cache.Insert(name, value);
}
public void Unset(string name)
{
cache.Remove(name);
}
}
And I use singleton for give value for it :
School schoolSettings = (School)CacheProviderFactory.Cache.Get("SchoolSettings");
if (schoolSettings == null)
{
CacheProviderFactory.Cache.Set("SchoolSettings", someObject);
}
So in first use it does not work and give me an error cache[name] is null.
What I'm doing wrong?
Any help would be appreciated.

At no point have you given cache a value... and note that the regular web cache probably isn't your best bet if you want it separate; perhaps
MemoryCache cache = new MemoryCache();

What about using the HttpRuntime.Cache, this example would cache for an hour?
HttpRuntime.Cache.Add("SchoolSettings", someObject, null, DateTime.Now.AddHours(1),
System.Web.Caching.Cache.NoSlidingExpiration,
System.Web.Caching.CacheItemPriority.Normal, null);

Try the following code. it works fine for my project
using System.Runtime.Caching;
public class RegularCacheProvider : ICacheProvider
{
private ObjectCache Cache { get { return MemoryCache.Default; } }
object ICacheProvider.Get(string key)
{
return Cache[key];
}
void ICacheProvider.Set(string key, object data, int cacheTime = 30)
{
var policy = new CacheItemPolicy {AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime)};
Cache.Add(new CacheItem(key, data), policy);
}
void ICacheProvider.Unset(string key)
{
Cache.Remove(key);
}
}

Change the code where you check for the value as follow:
School schoolSettings = CacheProviderFactory.Cache.Get("SchoolSettings") as (School);
Notice that I am using "as" rather than casting the object. Cast will blow up if the value is null while "as" will just give you a null value which is what you expect.

ASP.Net cache don't work under IIS 6.0

I have ASP.Net application with a simple cache helper.
Under VS web server it works fine.
Under IIS 6.0 cache doesn't work- object, was saved previos, doesn't returns after a minute (with no exception).
What could be wrong?
public static class CacheHelper
{
public static string Share<T>(T #object, TimeSpan period)
{
var uniqueKey = Guid.NewGuid().ToString();
HttpContext.Current.Cache.Add(uniqueKey, #object, null, Cache.NoAbsoluteExpiration,
period, CacheItemPriority.BelowNormal, null);
return uniqueKey;
}
public static void ShareViaCookie<T>(string key, T #object, TimeSpan period)
{
var cachedObject = GetFromCookie<T>(key);
if (ReferenceEquals(cachedObject, null))
{
var uniqueKey = Share(#object, period);
HttpContext.Current.Response.Cookies.Set(new HttpCookie(key, uniqueKey)
{
Expires = DateTime.Now.AddYears(1)
});
}
else
{
HttpContext.Current.Cache[GetKeyFromCookie(key)] = #object;
}
}
public static T GetShared<T>(string key)
{
string uniqueKey = HttpContext.Current.Request.QueryString[key];
return !string.IsNullOrEmpty(uniqueKey) ? (T)HttpContext.Current.Cache.Get(uniqueKey) : GetFromCookie<T>(key);
}
private static T GetFromCookie<T>(string key)
{
string uniqueKey = GetKeyFromCookie(key);
return !string.IsNullOrEmpty(uniqueKey) ? (T)HttpContext.Current.Cache.Get(uniqueKey) : default(T);
}
private static string GetKeyFromCookie(string key)
{
return HttpContext.Current.Request.Cookies[key]
.IIf(it => it != null, it => it.Value, it => null);
}
}

Maybe nothing is technically wrong. A cache does not mean that any object will be returned the moment after it is persisted.
If your site is caching a lot of items and the cache is not big enough it may constantly be looking for objects to remove from the cache. In this situations, sometimes the object that has only just been cached can be a good candidate to be removed. If you had room for 100 objects and the cache was full with items that had been accessed at least once, then it may never cache your new object that "has never been accessed". This does actually happen on the odd occasion.

Develop Reference

C# (C-Sharp) is a programming language developed by Microsoft that runs on the .NET Framework.

MVC 2 - Caching Strings in Memory - c#

Related

Call code once when controller is first accessed [duplicate]

How can I create a class that caches objects?

storing items in ObjectCache : cant get old values

how use caching in asp.net mvc3?

ASP.Net cache don't work under IIS 6.0

Categories

Resources