Five Best Ways To Use Redis With ASP.NET MVC

12 Comments

Join the conversation! Your thoughts help the community grow.

zafar Ali2y ago
Source is not downloading
faraz6y ago
_cacheStrigsStack.StoreList<List<Country>>("countryList", countryListtemp, TimeSpan.MaxValue); showing me exception due to timespan i have use zero and minvalue also but still got erorr
faraz6y ago
From where i can downoad source code?
faraz6y ago
For dropdown list please mention database and also mentioned the controller and class name that have been created. i exactly need to do same but i am unable to do that thing
nguyễn lan7y ago
I was following your tutorial but i have problem. how can I fix it? " ServiceStack.Redis.RedisResponseException: 'WRONGTYPE Operation against a key holding the wrong kind of value' " In the public T GetList<T>(string key) funtion var wrapper = client.As<T>(); result = wrapper.GetValue(key);
Arindam Ghosh8y ago
Thanks for the article..Quick Question: How do we maintain load balancing using Redis Session
- Saineshwar Bageri8y ago
  Your both application will have a single state provider which is Redis cache as you do in asp.net state server.
kalu singh rao8y ago
I am waiting for that article. Thanks for sharing. Keep it up !!
Ankur Mistry8y ago
Nice share Saineshwar Bageri
- Saineshwar Bageri8y ago
  Thank you ankur mistry
Sarathlal Saseendran8y ago
Superb article sir. Thanks for sharing.
- Saineshwar Bageri8y ago
  Thank you sir

Output

Data Stored in Redis Cache

Multistep Forms

In some applications, a customer has a requirement that until the user does not fill the complete form, it is not considered as submitted. Here, we should keep the data on a temporary basis. Here, Redis comes in to play because you can store the data in Redis cache along with timespan (you can add time for data expiration). Let us say the user-filled data should be only valid for a week and after that, it should get deleted. If you do the same process with any RDBMS, then you require to schedule an SQL job to check which data is expired. Then, you can delete it.

For this demo, we are going to create 2 forms.

The first form will have Name and Email id.

The second form will have Address and Age.

Models that we have added

public class Demo1
{
public string Name { get; set; }
public string EmailId { get; set; }
}
public class Demo2
{
public string Address { get; set; }
public string Age { get; set; }
}

After adding models, we are going to add a controller with the name “MultiStepController” and in this controller, we are going to keep the user data of multiple forms. In Redis cache, for that, we have generated a UserID which will be stored as uniquid to recognize the users.

public class MultiStepController : Controller
{
private readonly CacheStrigsStack _cacheStrigsStack;
public MultiStepController()
{
_cacheStrigsStack = new CacheStrigsStack();
}
// GET: MultiStep
[HttpGet]
public ActionResult Form1()
{
Session["_userid"] = Convert.ToString(Guid.NewGuid());
return View();
}
[HttpPost]
public ActionResult Form1(Demo1 demo1)
{
var key = Convert.ToString(Session["_userid"]) + ":step1";
_cacheStrigsStack.StoreList(key, demo1, TimeSpan.FromMinutes(5));
return RedirectToAction("Form2");
}
// GET: MultiStep
[HttpGet]
public ActionResult Form2()
{
return View();
}
[HttpPost]
public ActionResult Form2(Demo2 demo2)
{
var key = Convert.ToString(Session["_userid"]) + ":step2";
_cacheStrigsStack.StoreList(key, demo2, TimeSpan.FromMinutes(5));
return View(demo2);
}
}

If you see here, we are using the StoreList method for storing the data which takes generic parameters along with the key and timespan. For this form, we have set the timespan to 5 minutes, i.e, this data will be deleted after 5 minutes.

public bool StoreList<T>(string key, T value, TimeSpan timeout)
{
try
{
using (var redisClient = new RedisClient(_redisEndpoint))
{
redisClient.As<T>().SetValue(key, value, timeout);
}
return true;
}
catch (Exception)
{
throw;
}
}

Use Redis With ASP.NET MVC

After storing the data, we are going to see in the tools. You can see that TTL (time to live) will get expired in a few minutes.

This snapshot is from the Keylord tool which is a free client that connects to the Redis Server to display all keys and values stored in it.

Step 1 - Data which is stored in the Redis Server

Step 2 - Data which is stored in Redis Server

After understanding multiple forms, next, we are going to store the chart's data into the database.

Cache Charts data

In this part, we are going to have a look at how to store charts data into Redis cache for performance, because in most customer-facing websites or all applications which show charts, this data is pulled from the database which may cause performance issues. The query which we write for chart data is bit complex where we take the average count of data. When it is too large this will take a long time to execute which will disappoint the end user.

For this demo, we are going to show a bar chart. For which on the first request we are going to pull data from the database and then keep it in the cache then for all further requests we are going to pull from Redis cache.

Let’s add a controller with name “DashboardController.” Inside this controller we are going to add Bar Chart Action method, next we need to pull data from the database. For doing that I added a Repository folder which Contains Interface (ICharts) and Concentre (ChartsConcrete) class in which I have written logic to get data from the database.

Note
All this source code is available for download along with the database.

Interface Code Snippet

namespace WebRedis.Repository
{
public interface ICharts
{
void ProductWiseSales(out string mobileCountList, out string productList);
}
}

Concrete Class Code Snippet

In this part, we are implementing the ICharts interface and its members. For getting the collection we are going to use dapper orm.

using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using Dapper;
using WebRedis.Models;
namespace WebRedis.Repository
{
public class ChartsConcrete : ICharts
{
public void ProductWiseSales(out string mobileCountList, out string productList)
{
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["Connection"].ToString()))
{
var productdata = con.Query<ProductModel>("Usp_GetTotalsalesProductwise", null, null, true, 0, CommandType.StoredProcedure).ToList();
var mobileSalesCounts = (from temp in productdata
select temp.MobileSalesCount).ToList();
var productNames = (from temp in productdata
select temp.ProductName).ToList();
mobileCountList = string.Join(",", mobileSalesCounts);
productList = string.Join(",", productNames);
}
}
}
}

After adding interface and a concrete method to get data from the database next we are going to work on Bar chart action method. In this method we are going to call ProductwiseSales method. And then we are going check the if keys of bar charts are exits in Redis Cache; if not then we are going to pull data from the database and then add it to the Redis cache. On the next request we are going pull data from Redis cache.

Dashboard Controller Code Snippet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using WebRedis.CacheLayer;
using WebRedis.Repository;
namespace WebRedis.Controllers
{
public class DashboardController : Controller
{
private readonly ICharts _iCharts;
private readonly CacheStrigsStack _cacheStrigsStack;
public DashboardController()
{
_iCharts = new ChartsConcrete();
_cacheStrigsStack = new CacheStrigsStack();
}
// GET: Dashboard
[HttpGet]
public ActionResult BarChart()
{
try
{
string tempMobile;
string tempProduct;
if (!_cacheStrigsStack.IsKeyExists("Barchart:Mobile") && !_cacheStrigsStack.IsKeyExists("Barchart:Product"))
{
_iCharts.ProductWiseSales(out tempMobile, out tempProduct);
_cacheStrigsStack.StoreList("Barchart:Mobile", tempMobile, TimeSpan.FromDays(1));
_cacheStrigsStack.StoreList("Barchart:Product", tempProduct, TimeSpan.MaxValue);
ViewBag.MobileCount_List = tempMobile.Trim();
ViewBag.Productname_List = tempProduct.Trim();
}
else
{
tempMobile = _cacheStrigsStack.GetList<string>("Barchart:Mobile");
tempProduct = _cacheStrigsStack.GetList<string>("Barchart:Product");
ViewBag.MobileCount_List = tempMobile.Trim();
ViewBag.Productname_List = tempProduct.Trim();
}
return View();
}
catch (Exception)
{
throw;
}
}
}
}

After adding action method, next we are going to add View and, on that View, we are going to use Chart.js to display charts.

Dashboard Controller Code Snippet

On view, we just place data to display charts.

<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.7.2/Chart.bundle.min.js"></script>
<script>
var barChartData =
{
labels: [@Html.Raw(ViewBag.Productname_List)],
datasets: [{
label: 'ProductWise Sales Count',
backgroundColor: [
"#f990a7",
"#aad2ed",
"#9966FF",
"#99e5e5",
"#f7bd83",
],
borderWidth: 2,
data: [@ViewBag.MobileCount_List]
}]
};
window.onload = function () {
var ctx1 = document.getElementById("barcanvas").getContext("2d");
window.myBar = new Chart(ctx1,
{
type: 'bar',
data: barChartData,
options:
{
title:
{
display: true,
text: "ProductWise Sales Count"
},
responsive: true,
maintainAspectRatio: true
}
});
}
</script>
<div style="width: 700px; height: 700px">
<div style="text-align: center">
<canvas id="barcanvas"></canvas>
</div>
<div style="text-align: center">
Disclaimer:- This data is for the demo. It is
not real data and not related to any company.
</div>
</div>

We have completed adding View and Controllers, so let’s run the application and check the output.

Let’s see the code in debug mode.

We are not jumping into the if block, we are jumping into the else block because the keys are added to Redis cache.

If you want to view what is stored in Redis Cache Use Keylord Tool. Just enter port, host and Connection Name to Connect.

This will save a lot of resources of SQL Server or My SQL server.

Next we are going to work on the last part which is Session Provider.

Session Provider

In this part, we are going to learn how to store session in out-proc in Redis Cache.

For storing session in out-proc, first we are going to add NuGet package “Microsoft.Web.RedisSessionStateProvider”.

After installing “Microsoft.Web.RedisSessionStateProvider” it will add sessionState tags in web.config file.

Next, we are going to add the host “127.0.0.1” and make SSL false because we are going to run this application locally. If we run it on production, then make SSL = true.

<system.web>
<compilation debug="true" targetFramework="4.5.2" />
<httpRuntime targetFramework="4.5.2" />
<sessionState mode="Custom" customProvider="MySessionStateStore">
<providers>
<add name="MySessionStateStore" type="Microsoft.Web.Redis.RedisSessionStateProvider" host="127.0.0.1" accessKey="" ssl="false" />
</providers>
</sessionState>
</system.web>

After making the changes in the application, next, let's store the some values in Session and check if it gets stored in Redis Cache.

Next, for the demo, we are going to add “DemoController” and in that controller, we are going to add Index action Method. In this method we are going set session and get value from the session.

Code Snippet of Controller

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace WebRedis.Controllers
{
public class DemoController : Controller
{
// GET: Demo
public ActionResult Index()
{
Session["Username"] = "Saineshwar Bageri";
Session["UserID"] = Convert.ToString(Guid.NewGuid());
return View();
}
}
}

After storing value, we are going to display stored session values on View.

Code Snippet of View

@model dynamic
<!DOCTYPE html>
<html>
<head>
<title>title</title>
</head>
<body>
<div class="container">
<div style="margin-top:30px;" class="row">
Username:- @Session["Username"]
</div>
</div>
</body>
</html>

Output

After displaying the value on View, next we are going see how these values are stored IN Redis Cache.

Session Timeout stored in Redis Cache.

In this way, we can store and use Redis Session Provider. If we have hosted an application on multiple Web servers then we need a common session store where we can keep the session. If we have kept Session in in-proc, then the user will find the session only on the single web server. If he gets another server, then he needs to again sign into that web server to get a session where the state of the user is not maintained.

Note

You can also Use Linux hosted Redis Cache with ASP.NET to try this example. You do not need to change the code, just change the port and host in web.config.