Use Azure Redis Cache With MVC And Entity Framework

Introduction

Azure Redis Cache is based on the popular open-source Redis cache. It is typically used as a cache to improve the performance and scalability of systems that rely heavily on backend data-stores. Performance is improved by temporarily copying frequently accessed data to fast storage located close to the application. With Redis cache, this fast storage is located in-memory with Redis Cache instead of being loaded from disk by a database.

Azure Redis Cache can also be used as an in-memory data structure store, distributed non-relational database, and message broker. Application performance is improved by taking advantage of the low-latency, high-throughput performance of the Redis engine.

Azure Redis Cache gives you access to a secure, dedicated Redis cache, managed by Microsoft, hosted within Azure, and accessible to any application within Azure.

This article shows you how to get started using Microsoft Azure Redis Cache with MVC.

Prerequisites

• Visual Studio
• The StackExchange.Redis client requires .NET Framework 4 or higher.

Create a cache

To create a cache, first, sign in to the Azure portal, and click Create a resource > Databases > Redis Cache.

 

In New Redis Cache, configure the settings for your new cache.

 

Once the new cache settings are configured, click Create.

It can take a few minutes for the cache to be created. To check the status, you can monitor the progress on the dashboard. After the cache has been created, your new cache has a Running status and is ready for use.

Retrieve the hostname, ports, and access keys using the Azure Portal

When connecting to an Azure Redis Cache instance, cache clients need the hostname, ports, and a key for the cache. Some clients may refer to these items by slightly different names. You can retrieve this information in the Azure portal.

To retrieve the access keys using the Azure portal, browse to your cache and click Access keys.

 

To retrieve hostname and ports, click Properties.

Create MVC Project

Open Visual Studio > Visual C# > Web > ASP.NET Web Application (.NET Framework).

 

Select Empty > select MVC > click OK

Edit the web.config file and add the following contents in app settings,

<add key="CacheConnection" value="<cache-name>.redis.cache.windows.net,abortConnect=false,ssl=true,password=<access-key>"/>

Replace <cache-name> with your cache host name.

Replace <access-key> with the primary key for your cache.

In the Models folder, create a new class named Employee.

[Serializable]
    public class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Salary { get; set; }

    }

from NuGet, add Entity Framework Package.

 

Create new class named EmployeeContext inherit from DbContext

public class EmployeeContext:DbContext
 {
     public EmployeeContext():base("name=mycs")
     {

     }
     public DbSet<Employee> Employees { get; set; }
 }

Add connection string to web.config.

<add name="mycs" providerName="System.Data.SqlClient" connectionString="Data Source=.;Initial Catalog=EmployeeDB_1;Integrated Security=True;MultipleActiveResultSets=True"/>

Create new class and rename to AzureCache, put the following code.

public static class AzureCache
    {
        private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
            return ConnectionMultiplexer.Connect(cacheConnection);
        });

        public static ConnectionMultiplexer Connection
        {
            get
            {
                return lazyConnection.Value;
            }
        }


        public static T Get<T>(string cacheKey)
        {
            return Deserialize<T>(Connection.GetDatabase().StringGet(cacheKey));
        }

        public static object Get(string cacheKey)
        {
            return Deserialize<object>(Connection.GetDatabase().StringGet(cacheKey));
        }

        public static void Set(string cacheKey, object cacheValue)
        {
            Connection.GetDatabase().StringSet(cacheKey, Serialize(cacheValue));
        }

        private static byte[] Serialize(object obj)
        {
            if (obj == null)
            {
                return null;
            }
            BinaryFormatter objBinaryFormatter = new BinaryFormatter();
            using (MemoryStream objMemoryStream = new MemoryStream())
            {
                objBinaryFormatter.Serialize(objMemoryStream, obj);
                byte[] objDataAsByte = objMemoryStream.ToArray();
                return objDataAsByte;
            }
        }

        private static T Deserialize<T>(byte[] bytes)
        {
            BinaryFormatter objBinaryFormatter = new BinaryFormatter();
            if (bytes == null)
                return default(T);

            using (MemoryStream objMemoryStream = new MemoryStream(bytes))
            {
                T result = (T)objBinaryFormatter.Deserialize(objMemoryStream);
                return result;
            }
        }
    }

Add new controller to project > Select MVC 5 Controller with views, using Entity Framework

 

Select the Model class, Data Context class and controller name

 

In Controller Class add the following code as a global variable

IDatabase cache = AzureCache.Connection.GetDatabase();
public class HomeController : Controller
    {
        IDatabase cache = AzureCache.Connection.GetDatabase();
…
}

Update the index action code to the following code,

var lstSampleObject = AzureCache.Get<List<Employee>>("lstEmps");
        if (lstSampleObject != null)
        {
            return View(lstSampleObject);
        }
        else
        {
            AzureCache.Set("lstEmps", db.Employees.ToList());
            return View(db.Employees.ToList());
        }

Update the Create action code to the following code,

[HttpPost]
   [ValidateAntiForgeryToken]
   public ActionResult Create([Bind(Include = "Id,Name,Salary")] Employee employee)
   {
       if (ModelState.IsValid)
       {
           db.Employees.Add(employee);
           db.SaveChanges();
            AzureCache.Set("lstEmps", db.Employees.ToList());
           return RedirectToAction("Index");
       }

       return View(employee);
   }

Update the Edit action code to the following code,

[HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "Id,Name,Salary")] Employee employee)
        {
            if (ModelState.IsValid)
            {
                db.Entry(employee).State = EntityState.Modified;
                db.SaveChanges();

                AzureCache.Set("lstEmps", db.Employees.ToList());

                return RedirectToAction("Index");

            }

Update the DeleteConfirmed action code to the following code,

[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public ActionResult DeleteConfirmed(int id)
{
    Employee employee = db.Employees.Find(id);
    db.Employees.Remove(employee);
    db.SaveChanges();
    AzureCache.Set("lstEmps", db.Employees.ToList());
    return RedirectToAction("Index");
}

Now, test your application.