Supercharge Your ASP.NET Web API with Linq.Dynamic.Core (Source Code)

Building efficient APIs with ASP.NET Web API is already a powerful approach for modern application development. However, by leveraging Linq.Dynamic.Core, you can take your APIs to the next level, offering dynamic query generation, filtering, sorting, and more—all while reducing boilerplate code. Imagine supercharging your Web API with the flexibility and power that Linq.Dynamic.Core brings, making it easier to handle user inputs, create dynamic queries, and improve performance. Let's dive into how you can do this, using real-life analogies, source code, and best practices.

The Real-Life Analogy: Cooking with a Recipe vs. Cooking with Ingredients

Think of Linq.Dynamic.Core as cooking with a dynamic set of ingredients versus strictly following a recipe. With a recipe, you know exactly what to do—step-by-step. This is similar to using static queries in your API, where the filtering, sorting, and conditions are hardcoded. On the other hand, cooking with just ingredients allows you to be flexible, adjust to the situation, and adapt based on availability or taste. This is what Linq.Dynamic.Core allows you to do: create dynamic, user-driven queries at runtime.

For example, imagine you're building an API that manages a large library of books. Users might want to filter books by title, author, or publication date, and also want to sort the results by various fields. With traditional LINQ, you would have to write separate logic for each scenario. But with Linq.Dynamic.Core, users can pass the filtering and sorting parameters dynamically.

Setting up Linq.Dynamic.Core

First, you need to install the Linq.Dynamic.Core package into your ASP.NET Web API project. You can do this via the NuGet package manager:

bash

Install-Package System.Linq.Dynamic.Core

Once installed, let's walk through some code examples on how you can leverage this powerful tool.

Basic Use Case: Dynamic Sorting and Filtering

Imagine you're running an API that serves a list of products. A client may want to dynamically sort or filter the product data by properties like Price, Category, or Rating. Here’s how you can accomplish this:

Model Example

csharp

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }
    public double Rating { get; set; }
}

Controller Example

csharp

using System.Linq.Dynamic.Core;

[HttpGet]
public IActionResult GetProducts(string sortBy = "Price", string filterBy = "Category == \"Electronics\"")
{
    var products = _context.Products.AsQueryable();

    // Applying dynamic filtering
    if (!string.IsNullOrEmpty(filterBy))
    {
        products = products.Where(filterBy);  // Dynamic filtering
    }

    // Applying dynamic sorting
    if (!string.IsNullOrEmpty(sortBy))
    {
        products = products.OrderBy(sortBy);  // Dynamic sorting
    }

    return Ok(products.ToList());
}

Explanation:

Dynamic Filtering: We apply Where(filterBy), which allows users to filter products based on any valid expression. In this case, it filters products where the Category equals "Electronics".
Dynamic Sorting: We use OrderBy(sortBy) to sort the result set dynamically based on the user’s input, which in this case sorts by Price.

This dynamic approach eliminates the need to write multiple conditional checks or if-else logic to handle different filtering and sorting combinations.

Real-World Example: Search and Pagination in an E-commerce Store

Consider an e-commerce API where users can search for products and apply filters like Brand, PriceRange, or Ratings. Users also want the results to be paginated. With Linq.Dynamic.Core, you can achieve this efficiently.

csharp

[HttpGet]
public IActionResult SearchProducts(string filterBy, string sortBy, int page = 1, int pageSize = 10)
{
    var products = _context.Products.AsQueryable();

    // Applying dynamic filtering
    if (!string.IsNullOrEmpty(filterBy))
    {
        products = products.Where(filterBy);  // Dynamic filtering
    }

    // Applying dynamic sorting
    if (!string.IsNullOrEmpty(sortBy))
    {
        products = products.OrderBy(sortBy);  // Dynamic sorting
    }

    // Pagination
    var pagedProducts = products.Skip((page - 1) * pageSize).Take(pageSize).ToList();

    return Ok(pagedProducts);
}

Here, you’re empowering users to pass filter expressions like Price > 100 AND Brand == "Apple" and sort expressions like Price desc through the API. The users can also specify which page of the results they want to retrieve, effectively handling large datasets without complex code.

Other code sample

Controller

[ApiController]
[Route("api/[controller]")]
public class PeopleController : ControllerBase
{
    private readonly List<Person> _people = new List<Person>
    {
        new Person { Id = 1, Name = "John Doe", Age = 30 },
        new Person { Id = 2, Name = "Jane Doe", Age = 25 },
        new Person { Id = 3, Name = "Bob Smith", Age = 40 },
    };

    [HttpGet]
    public IActionResult GetPeople([FromQuery]QueryParams queryParams)
    {
        var query = _people.AsQueryable();

        // Filtering
        if (!string.IsNullOrEmpty(queryParams.Filter))
        {
            query = query.Where(queryParams.Filter);
        }

        // Selecting
        if (!string.IsNullOrEmpty(queryParams.Select))
        {
            var selectedProperties = queryParams.Select.Split(',');
            query = query.Select Dynamically(selectedProperties);
        }

        // Counting
        if (queryParams.Count != null)
        {
            return Ok(new { Count = query.Count() });
        }

        // Paging
        if (queryParams.Top != null && queryParams.Skip != null)
        {
            query = query.Take(queryParams.Top).Skip(queryParams.Skip);
        }

        return Ok(query.ToList());
    }
}

public class QueryParams
{
    public string Filter { get; set; }
    public string Select { get; set; }
    public int? Top { get; set; }
    public int? Skip { get; set; }
    public bool? Count { get; set; }
}

public static class QueryableExtensions
{
    public static IQueryable<T> Where<T>(this IQueryable<T> source, string predicate)
    {
        return source.Where Dynamically(predicate);
    }

    public static IQueryable<T> Select<T>(this IQueryable<T> source, string selectedProperties)
    {
        return source.Select Dynamically(selectedProperties);
    }
}

Usage

Get all people: GET /api/people
Filter by name: GET /api/people?filter=name eq 'John Doe'
Select specific properties: GET /api/people?select=name,age
Count: GET /api/people?count=true
Paging: GET /api/people?top=2&skip=1

Pros and Cons of Using Linq.Dynamic.Core

Pros:

Flexibility: Allows users to generate dynamic queries at runtime without the need for predefined query logic.
Code Reduction: Minimizes the boilerplate code you need to write for sorting, filtering, and pagination.
Powerful Querying: Supports complex expressions including joins, subqueries, and dynamic projections.
Performance: Since queries are composed on the database side, the performance overhead is generally minimal.

Cons:

Runtime Errors: Since queries are built dynamically, any errors in user input (e.g., invalid expressions) will result in runtime errors, not compile-time errors.
Security: Allowing direct input from users for filtering and sorting can be risky if not properly sanitized. Always validate and sanitize input to avoid issues like SQL injection.
Learning Curve: While powerful, it requires developers to become familiar with writing expressions in string form and managing runtime queries.

Best Practices for Using Linq.Dynamic.Core

Input Validation: Always validate and sanitize user input before applying dynamic queries to avoid potential security vulnerabilities.
Error Handling: Wrap dynamic queries in proper try-catch blocks to handle invalid expressions gracefully.
Test for Performance: Test your dynamic queries with large datasets to ensure they perform optimally.
Default Sorting: Provide default sorting options to avoid unexpected behavior when no sorting input is provided.
Security: Use libraries or write custom logic to ensure that user-provided input does not contain malicious queries.

Conclusion

By integrating Linq.Dynamic.Core with your ASP.NET Web API, you unlock a world of flexibility, enabling powerful runtime filtering, sorting, and pagination features with minimal code. As demonstrated, it provides a more dynamic, efficient, and user-friendly approach, especially for large datasets like e-commerce product listings or library catalogs.

Use this tool wisely by following best practices around input validation and security. With these steps in place, your API will be more versatile and capable of handling complex queries efficiently.