ASP.NET MVC - Is there an easy way to add Data Caching to my Service Layer?

I've got my MVC application wired up so that the Repository Layer queries the LINQ to SQL classes, the Service Layer queries the Repository Layer, and the Controllers call the Service layer.

Basically I have code as follows

Repository

    Public Function GetRegions() As IQueryable(Of Region) Implements IRegionRepository.GetRegions
        Dim region = (From r In dc.Regions
                 Select r)
        Return region.AsQueryable
    End Function

Service

    Public Function GetRegionById(ByVal id As Integer) As Region Implements IRegionService.GetRegionById
        Return _RegionRepository.GetRegions() _
            .Where(Function(r) (r.ID = id _
                                And r.isActive)) _
            .FirstOrDefault()
    End Function

    Public Function GetRegionByNameAndParentID(ByVal region As String, ByVal parentid As Integer) As Region Implements IRegionService.GetRegionByNameAndParentID
        Return _RegionRepository.GetRegions() _
            .Where(Function(r) (r.Region = region _
                                And r.ParentID = parentid _
                                And r.isActive)) _
            .FirstOrDefault()
    End Function

    Public Function GetActiveRegions() As List(Of Region) Implements IRegionService.GetActiveRegions
        Return _RegionRepository.GetRegions() _
            .Where(Function(r) r.isActive) _
            .ToList
    End Function

    Public Function GetAllRegions() As List(Of Region) Implements IRegionService.GetAllRegions
        Return _RegionRepository.GetRegions().ToList
    End Function

I'm wondering if there's a nice/efficient way to add Caching to the Service layer so t开发者_Python百科hat it doesn't always have to be calling the REPO if the calls are the same.

As caching is a cross cutting concern (do a search in Wikipedia), you can use policy injection to implement caching on your repository layer, but the constraint is that you use a DI framework like Castle, Unity, ... Advantage of this concept is that you keep clean code in your repository layer.

I'll start with It Depends, but in simple scenario's where no interaction with other service agents is required, it is only recommended to cache the access to the database, as database access is the slowest of all. That's why I would recommend not to cache the access to the service layer, but rather the repository layer. This is also what Martin Fowler describes in his data mapper pattern.

If you are in a distributed scenario, whereby your controller and service are running on different servers, you might opt to cache on your controller as well to prevent the serialization of reference data every time you load e.g. your countrylist dropdown or tax code values.

In your scenario, I would attach a CachingHandler to your repository GetRegions(), and make a CacheKey which combines e.g. the method and parameters (if any). In a simplistic approach, save the CacheKey and the list of results to an Hashtable (in real life, use Patterns & Practices Caching application block or System.Web.Cache), and to every request to your repository, see if the cache key is in your Hashtable, then return the cached list.

A quick search in google gives you this to get started: http://entlib.codeplex.com/Thread/View.aspx?ThreadId=34190

rockinthesixstring - yes, you can add an http cache into that layer using an anonymous function to either pull from the repo or pull from cache. basically, you'd do it allong the following lines (this is from an app that i'm working on just now that uses subsonic, but the premise of what you're after is identical.

    /// <summary>
    /// Returns an IQueryable based on the passed-in Expression Database
    /// </summary>
    IQueryable<T> IRepository<T>.Find(Expression<Func<T, bool>> expression)
    {
        // set up our object cacheKey
        string keyValue = ParseExpression(expression);

        if(keyValue==null)
        {
            return _repository.Find(expression);
        }

        string cacheKey = string.Format(EntityrootList, _className, "Find", keyValue, DateTime.UtcNow.Ticks.ToString(), string.Empty);

        // try to populate from the cache
        // rockinthesixstring - this is the part that is most relevant to you
        var result = Cache.Get(cacheKey,
                                () => _repository.Find(expression),
                                CacheDuration);

        return result;
    }

[edit] in the controller, you'd call it like so (the controller _repository is set as:

readonly IRepository<Booking> _repository; 

in the example):

[Authorize]
[AcceptVerbs(HttpVerbs.Post)]
public ContentResult ListBookings(int shareholderid)
{
    Expression<Func<Booking, bool>> exprTree = x => x.FundShareholderEntity.ShareholderID == shareholderid;
    var bookings = _repository.Find(exprTree).OrderByDescending(x => x.BookingDetailEntity.ActualDateFrom).OrderBy(x => x.BookingTypeID);
    return Content(this.RenderPartialToString("BookingListNoPaging", bookings));
}

In the above example, Cache (i.e. Cache.Get()) is a class that wraps the httpcontext cache in a more user friendly way.

hope this helps...

jim

[edit] - added cache interface to add to the 'debate' :)

public interface ISessionCache
{
    T Get<T>(string key);
    T Get<T>(string key, Func<T> getUncachedItem, int cacheDuration);
    void Insert(string key, object obj, int cacheDuration, CacheDependency arg0, TimeSpan arg2);
    void Remove(string key);
    object this[string key] { get; } // default indexer
    IDictionaryEnumerator GetEnumerator();
}

in the injectable class would be used along the lines of:

public class FakeCache : ISessionCache
{... all inteface members implemented here etc..}

or for httpcache:

public class HttpContextCache : ISessionCache
{... all inteface members implemented here etc..}

etc, etc.. cheers again - jim