Is there anyway to cache function/method in C#

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.

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

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.

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

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;
    }

You could use a Dictionary to cache the function. A dictionary maps keys to values and a function maps arguments to values. So conceptually, a dictionary fits as a cache for a function. Here's a simple class to do that:

/// <summary>
/// The lazy function map caches the results of calls to the backing function. Every time the function is called on an argument u and returns v,
/// the pair (u, v) is stored in the dictionary.
/// </summary>
class LazyFunctionMapImpl<T, U> : ILazyFunctionMap<T, U>
{
    private readonly Dictionary<T, U> _backingDictionary;
    private readonly Func<T, U> _backingFunction;

    public LazyFunctionMapImpl(Func<T, U> backingFunction)
    {
        _backingDictionary = new Dictionary<T, U>();
        _backingFunction = backingFunction;
    }

    public U this[T index]
    {
        get
        {
            if (_backingDictionary.ContainsKey(index))
            {                    
                return _backingDictionary[index];
            }                
            U valueAtIndex = _backingFunction(index);
            _backingDictionary.Add(index, valueAtIndex);
            return valueAtIndex;
        }
    }

    public void Clear()
    {
        _backingDictionary.Clear();
    }
}

And here's a couple of interfaces to go with it:

/// <summary>
/// A function map that should lazily cache param/result pairs until clear is called.
/// </summary>    
public interface ILazyFunctionMap<T, U> : IFunctionMap<T, U>
{
    /// <summary>
    /// Should invalidate any caches forcing the underyling function to be called afresh
    /// </summary>
    void Clear();
}

public interface IFunctionMap<T, U>
{
    /// <summary>
    /// Mapped values representing the underlying function.
    /// </summary>
    U this[T index] { get; }
}