Boilerplate code reducing

Wanna to see how DataTables.Queryable helps to reduce boilerplate code?

Before using DataTables.Queryable

Usually, if you use datatables.net on a client side, your server-side code looks like this:

// Step 1: parse incoming datatables.net request

var searchString = Request.QueryString["search[value]"];
var orderColumnIndex = Request.QueryString["order[0][column]"];
var orderColumn = Request.QueryString[$"columns[{orderColumnIndex}][data]"];
var orderDir = Request.QueryString["order[0][dir]"];
var start = Convert.ToInt32(Request.QueryString["start"]);
var length = Convert.ToInt32(Request.QueryString["length"]);

First you need to parse an incoming request and extract query parameters from it, like search string, columns ordering info, ordering direction, page number and etc.

Then you have to construct a query with tons of similar switch...case or if...else constructions:

// Step 2: filter by search string

var ctx = new DatabaseContext(); 

var queryable = ctx.Persons.Where(p =>
    p.Name.Contains(searchString) ||
    p.Position.Contains(searchString) ||
    p.Office.Contains(searchString) ||
    p.Extn.ToString().Contains(searchString) ||
    p.StartDate.ToString().Contains(searchString) ||
    p.Salary.ToString().Contains(searchString));

if (orderDir == "asc")
{
    switch (orderColumn)
    {
        case "Name":
            queryable = queryable.OrderBy(p => p.Name);
            break;
        case "Position":
            queryable = queryable.OrderBy(p => p.Position);
            break;
         case "Office":
            queryable = queryable.OrderBy(p => p.Office);
            break;
         case "Extn":
            queryable = queryable.OrderBy(p => p.Extn);
            break;
         case "StartDate":
            queryable = queryable.OrderBy(p => p.StartDate);
            break;
         case "Salary":
            queryable = queryable.OrderBy(p => p.Salary);
            break;
         default:
            break;
    }
}
else
{
    switch (orderColumn)
    {
        case "Name":
            queryable = queryable.OrderByDescending(p => p.Name);
            break;
        case "Position":
            queryable = queryable.OrderByDescending(p => p.Position);
            break;
        case "Office":
            queryable = queryable.OrderByDescending(p => p.Office);
            break;
        case "Extn":
            queryable = queryable.OrderByDescending(p => p.Extn);
            break;
        case "StartDate":
            queryable = queryable.OrderByDescending(p => p.StartDate);
            break;
        case "Salary":
            queryable = queryable.OrderByDescending(p => p.Salary);
            break;
        default:
            break;
    }
}

Finally, you need to execute the constructed query and get results:

// Step 3: paginate and get results:

var persons = queryable.Skip(start).Take(length).ToList();

But wait, what if you need to query data from another table with different model type and different properties? What if you need individual column search and ordering by multiple columns?

YOU HAVE TO WRITE SIMILAR CODE AGAIN.

It is an endless headpain, right?

After using DataTables.Queryable

Everything you need is a couple of lines:

var request = new DataTablesRequest<Person>(Request.QueryString);
using (var ctx = new DatabaseContext())
{
    var persons = ctx.Persons.ToPagedList(request);
    return JsonDataTable(persons);
}

Spend more time to write the business logic and enjoy!