Myujth

I got bored with writing same to code again and again to cache the objects in data access layer.

Is there anyway to cache c# function results without much changes to functions.

Is there any framework supports this functionality at the moment?

Can i archive the same by writing custom "c# function attributes"? if so, drop me some points to start implementation?

You can create caching attributes with PostSharp. Here is an example.

Possibility 1: Use IL Weaving

Postsharp was mentioned before.

You could also try the MethodCache.Fody package.

Possibility 2: Use an Proxy / Interception Framework

Example (Ninject & Ninject.Interception):

public class CacheAttribute : InterceptAttribute

 public override IInterceptor CreateInterceptor(IProxyRequest request)
 
 return request.Context.Kernel.Get<CachingInterceptor>();
 


public class CachingInterceptor : IInterceptor

 private ICache Cache get; set; 

 public CachingInterceptor(ICache cache)
 
 Cache = cache;
 

 public void Intercept(IInvocation invocation)
 
 string className = invocation.Request.Target.GetType().FullName;
 string methodName = invocation.Request.Method.Name;

 object arguments = invocation.Request.Arguments;

 StringBuilder builder = new StringBuilder(100);
 builder.Append(className);
 builder.Append(".");
 builder.Append(methodName);

 arguments.ToList().ForEach(x =>
 
 builder.Append("_");
 builder.Append(x);
 );

 string cacheKey = builder.ToString();

 object retrieve = Cache.Retrieve<object>(cacheKey);

 if (retrieve == null)
 
 invocation.Proceed();
 retrieve = invocation.ReturnValue;
 Cache.Store(cacheKey, retrieve);
 
 else
 
 invocation.ReturnValue = retrieve;
 
 

Then you could decorate functions like this:

[Cache]
public virtual Customer GetCustomerByID(int customerID)

 return CustomerRepository.GetCustomerByID(customerID);

Intercepted functions have to be virtual and classes must be created by the Ninject kernel. If you rely on performance, you could proxy classes directly via Castle.DynamicProxy (which is internally used by Ninject.Extensions.Interception.DynamicProxy).

Possibility 3: Use an Expression wrapper

You could pass the function as expression, generate a caching key containing class, method and parameter information and invoke the expression if not found in your Cache. This adds more runtime overhead than AOP / Proxy frameworks, but will be sufficient for simple solutions.

private T CacheAction<T>(Expression<Func<T>> action, [CallerMemberName] string memberName = "") where T : class

 MethodCallExpression body = (MethodCallExpression)action.Body;

 ICollection<object> parameters = new List<object>();

 foreach (MemberExpression expression in body.Arguments)
 
 parameters.Add(((FieldInfo)expression.Member).GetValue(((ConstantExpression)expression.Expression).Value));
 

 StringBuilder builder = new StringBuilder(100);
 builder.Append(GetType().FullName);
 builder.Append(".");
 builder.Append(memberName);

 parameters.ToList().ForEach(x =>
 
 builder.Append("_");
 builder.Append(x);
 );

 string cacheKey = builder.ToString();

 T retrieve = Cache.Retrieve<T>(cacheKey);

 if (retrieve == null)
 
 retrieve = action.Compile().Invoke();
 Cache.Store(cacheKey, retrieve);
 

 return retrieve;


public Customer GetCustomerByID(int customerID)

 return CacheAction(() => CustomerRepository.GetCustomerByID(customerID));

If I read you question correct, the right term for what you want is memoization. Wikipedia gives more details on this subjects. Unfortunately there is no reference to a C# library supporting it.

The Cache Application block is Microsoft's answer to built in library for Caching in .NET.

Lazy store it's value after first run.
Example: http://msdn.microsoft.com/en-us/vstudio/bb870976

I suggest Spring.Net AOP.
It basically creates a proxy and the calls can be redirected from/to the cache.
http://www.springframework.net/doc/reference/html/aop-quickstart.html

and then you can have something like that for your advice:

public class CachingAroundAdvice : IMethodInterceptor
{
 #region Variable Declarations
 private Priority priority = Priority.Normal;
 #endregion

 public object Invoke(IMethodInvocation invocation)
 
 // declare local variables
 string cacheKey = string.Empty;
 object dataObject = null;

 // build cache key with some algorithm
 cacheKey = CreateCacheKey(invocation.Method, invocation.Arguments);

 // retrieve item from cache
 dataObject = CacheManager.Cache.GetData(cacheKey);

 // if the dataobject is not in cache proceed to retrieve it
 if (null == dataObject)
 
 dataObject = invocation.Proceed();

 // add item to cache
 CacheManager.Cache.Add(cacheKey, dataObject, CachePriority, null, Expiration);
 

 // return data object
 return dataObject;
 

I use this simple implementation of the System.Runetime.Caching namespace:

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.AddHours(4));
 
 return item;
 

 public void Clear(string cacheKey)
 
 MemoryCache.Default.Remove(cacheKey);
 


interface ICacheService

 T GetOrSet<T>(string cacheKey, Func<T> getItemCallback) where T : class;
 void Clear(string cacheKey);

Can be used in the following manner:

var cacheProvider = new InMemoryCache();
var cachedResult = cacheProvider.GetOrSet("YourCacheKey",
 () => MethodToCache());

First call to the method will cache the result, the next call will return the cached result.