如何基于动态接收的JSON键值对构建LINQ员工查询？

Great question! Handling dynamic search parameters in LINQ is a super common task, and there are two straightforward approaches depending on your needs—one that uses plain LINQ with conditional chaining (no extra libraries) and another that leverages Dynamic LINQ for more flexibility.

Approach 1: Plain LINQ with Conditional Chaining #

This is the simplest method if you have a fixed set of possible parameters. The key here is using LINQ's deferred execution to build your query step by step, applying filters only when the corresponding parameter exists in your input.

First, let's assume your Employee class looks like this:

public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Department { get; set; }
}

Then, parse your input JSON into a dictionary (I'll use Newtonsoft.Json for this example, but you can use System.Text.Json too):

using Newtonsoft.Json;

// Example JSON input: {"name":"John", "age":"20"}
var jsonInput = ...;
var searchParams = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonInput);

Now build your query dynamically:

// Start with the full employee list (could be IQueryable for EF or IEnumerable for in-memory)
IQueryable<Employee> query = dbContext.Employees;

// Apply name filter if present
if (searchParams.TryGetValue("name", out var name) && !string.IsNullOrWhiteSpace(name))
{
    query = query.Where(e => e.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
}

// Apply age filter if present and valid
if (searchParams.TryGetValue("age", out var ageStr) && int.TryParse(ageStr, out int age))
{
    query = query.Where(e => e.Age == age);
}

// Apply department filter if present
if (searchParams.TryGetValue("dept", out var dept) && !string.IsNullOrWhiteSpace(dept))
{
    query = query.Where(e => e.Department.Equals(dept, StringComparison.OrdinalIgnoreCase));
}

// Execute the query
var matchingEmployees = query.ToList();

Why this works: #

LINQ uses deferred execution, meaning none of the filters run until you call ToList() (or another enumeration method). This lets you safely add filters conditionally without duplicating code.

Approach 2: Dynamic LINQ (For Advanced Scenarios) #

If you have a large number of possible parameters or need to support dynamic operators (like >, <, Contains), use the System.Linq.Dynamic.Core library. It lets you write LINQ queries using string expressions.

First, install the NuGet package:

Install-Package System.Linq.Dynamic.Core

Then build your dynamic query string:

using System.Linq.Dynamic.Core;
using Newtonsoft.Json;

var jsonInput = ...;
var searchParams = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonInput);

var conditions = new List<string>();
var parameters = new List<object>();

foreach (var (key, value) in searchParams)
{
    switch (key.ToLower())
    {
        case "name":
            conditions.Add("Name.Equals(@0, StringComparison.OrdinalIgnoreCase)");
            parameters.Add(value);
            break;
        case "age":
            if (int.TryParse(value, out int age))
            {
                conditions.Add("Age == @0");
                parameters.Add(age);
            }
            break;
        case "dept":
            conditions.Add("Department.Equals(@0, StringComparison.OrdinalIgnoreCase)");
            parameters.Add(value);
            break;
        // Add more cases for additional parameters or operators
    }
}

// Combine conditions with AND
var whereClause = string.Join(" AND ", conditions);

// Execute the query
var matchingEmployees = dbContext.Employees.Where(whereClause, parameters.ToArray()).ToList();

Key Notes: #

• Always validate input values (like parsing age to int) to avoid runtime errors.
• Parameterized queries (using @0, @1, etc.) prevent SQL injection risks, even with dynamic strings.
• This approach scales better if you need to support many different parameters or custom operators.

内容的提问来源于stack exchange，提问作者John