使用变量构建实体框架 Linq 查询

Question

I am struggling to find best practise for something I have occasionally came across number of times and each time I am left with an impression that this is not the most elegant, best and most certainly efficient way to achieve what I want to do.

Consider this:

model:

public class User
{
  public string firstName {get; set;}
  public string lastName {get; set;}
  public string middleName {get; set;}
  public string someName {get; set;}

 // etc... up to, let's say 20 inputs
}

html:

<input type="text" name="firstName">
<input type="text" name="lastName" disabled>
<input type="text" name="middleName" disabled>
<input type="text" name="someName" disabled>```

controller:

private dbcontext db = new dbcontext();
List<User> users = db.Users.Where( x => firstName != null && x.firstName == fisrtName ||
                   lastName != null && x.lastName == lastName ||
// and so on, and so on...

Now, some bloke on the other end will have the option to enable above inputs and query database for some user with the passed parameters.

I hope that by now you get the idea what I am struggling to understand here. I like to use only variables that were enabled and combine them into AND query instead of OR . I know, I know - that && are used for that matter but this doesn't work the way I would like to.

I do not want to use if statement to check every single variable for null and then create query for every scenario that could happen.

My appologies if thats a repost, but I couldn't find answer for that.

Answer 1

Model :

public class User
{
  public string firstName {get; set;}
  public string lastName {get; set;}
  public string middleName {get; set;}
  public string someName {get; set;}

 // etc... up to, let's say 20 inputs
}

HTML :

@model YourModel
@Html.TextBoxFor(m => m.firstName, "", new { })
@Html.TextBoxFor(m => m.lastName, "", new { @disabled = true })
@Html.TextBoxFor(m => m.middleName, "", new { @disabled = true })
@Html.TextBoxFor(m => m.someName, "", new { @disabled = true })

Controller :

        private readonly YourContext _db;

        public YourController(YourContext db)
        {
            _db = db;
        }
        [HttpGet]
        public async Task<IActionResult> YouReturningView()
        {
          var model = await _db.YourDbSet.Where(Your Where).FirstAsync();
          return View(model);
        }

I think thats the mode elegant and officient way how to do it. Generated Html will have all needed attributed that are like in your class.

Answer 2

If you want to query the records based on the fields that are enabled, you need to go for dynamic where clause in linq query

below query can be used to enable the where clause dynamically only when data is present in field. If data is present in firstName it will check for the records for firstName based on record, else it will return true and goes for next condition. If both firstName and middleName has data, then it will get the records based on both first and middle name. Same approach for all other fields

If no data is present in all the fields then it will return all the records from database

List<User> users = (from u in db.Users
                   where 
                   (firstName != null? u.firstName == firstName:true) &&
                   (lastName != null? u.lastName == lastName:true) &&
                   (middleName != null ? u.middleName == middleName:true) &&
                   (someName != null ? u.someName == someName:true)

                   select new User
                   {
                       firstName = u.firstName,
                       lastName = u.lastName,
                       middleName = u.middleName,
                       someName = u.someName


                   }).ToList();

Answer 3

Assuming the web request is converted to an instance of your User model, you can start with a bit of reflection to get this done.

To start with, let's assume the object comes back from the web request as a User object that may or may not have all the field populated. Let's call it SearchUser .

First, we can reflect on the User type to get all of the properties.

var filledProperties = typeof(User).GetProperties()
    .Where(t => t.GetValue(SearchUser) != null 
    && !string.IsNullOrEmpty(t.GetValue(SearchUser).ToString()));

What this is doing is inspecting the SearchUser object and returning an array of PropertyInfo objects that have a non-null value and are not empty strings. This means that your web request could have values for 5 of 20 properties or all 20, and however many are populated will end up in this array.

Next, we can use it to query your database.

List<User> users = db.Users
    .Where(u => filledProperties.Any(p => p.GetValue(u) != null
    && p.GetValue(u).ToString()
    == p.GetValue(SearchUser).ToString()))
    ToList();

What we've done here is inspect each database user and return it if any of the properties in it match both of the following:

• The matching DB property to the tested property in filledProperties is not null, and
• the matching property in the DB has the same value as the property in the SearchUser object with the same name.

The pros of this approach is that no matter how many string properties are available on your User class, this will work, and you don't need to change any of the query code. Also, it works if some of your properties are null or empty, in either the SearchUser or the Database object.

The cons are of course that is is using reflection pretty heavily. This will be a heavy query to run so if you have a lot of concurrent requests or you have a large table of users, this might not be ideal. In that case, you may look toward shadowing the DB data in something like ElastiSearch so you can run your searches faster on a tool that is designed better for the task. That's up to you though, but this gets your example working.