Linq代码重构

Question

Please help me to refactor this code using Linq. How to use Where and ToList only once? Thx for help

private IEnumerable<SomeClass> Filter(IEnumerable<SomeClass> aaa, string name, string company, string address,int? age)       
{
    var ans = new List<SomeClass>();         
    if (!String.IsNullOrEmpty(name))
        ans = aaa.Where(x => x.name.equal(name)).ToList();

    if (!String.IsNullOrEmpty(company))
        ans = ans.Where(x => x.company.equal(company)).ToList();

    if (!String.IsNullOrEmpty(address))
        ans = ans.Where(x => x.address.equal(address)).ToList();

    if (age.HasValue)
        ans = ans.Where(x => x.age == age.Value).ToList();

    return ans;
}

Answer 1

You could use this:

var ans = aaa.Where( x => ( string.IsNullOrEmpty(name)
                            || x.name.equal(name)
                          )
                          &&
                          ( string.IsNullOrEmpty(company)
                            || x.company.equal(company)
                          )
                          &&
                          ( string.IsNullOrEmpty(address)
                            || x.address.equal(address)
                          )
                          &&
                          ( !age.HasValue
                            || x.age == age.Value
                          )
                   );

Answer 2

You can drop all calls to ToList . Without those calls, the combined filtering will be executed in a deferred way that you don't need to care about.

If you do want to influence the time at which filtering is executed (or make sure the result is based on the snapshot of aaa at the time of invocation of Filter and does not change if aaa changes later on), change your last line to

return ans.ToArray();

(a list is probably not necessary here; the returned value is typed to IEnumerable<SomeClass> anyway and callers shouldn't expect to be able to directly modify (add/remove items) the returned object.

Thus, the complete code would look like this:

private IEnumerable<SomeClass> Filter(IEnumerable<SomeClass> aaa, string name, string company, string address,int? age)       
{
    IEnumerable<SomeClass> ans = new SomeClass[0];
    if (!String.IsNullOrEmpty(name))
        ans = aaa.Where(x => x.name.Equals(name));

    if (!String.IsNullOrEmpty(company))
        ans = ans.Where(x => x.company.Equals(company));

    if (!String.IsNullOrEmpty(address))
        ans = ans.Where(x => x.address.Equals(address));

    if (age.HasValue)
        ans = ans.Where(x => x.age == age.Value);

    return ans.ToArray();
}

As other answers have shown, it is also possible to combine all Where calls into one, though sticking with your original chain of if s and Where s shows very clearly what it does, which might not be true for the combined solutions.

Answer 3

Just to add another answer here. Why create a List at all your input is an IEnumerable and so is your output is the same?

private IEnumerable<SomeClass> Filter(IEnumerable<SomeClass> aaa, string name, string company, string address, int? age)
{
    if (!String.IsNullOrEmpty(name))
        aaa = aaa.Where(x => x.name.Equals(name));

    if (!String.IsNullOrEmpty(company))
        aaa = aaa.Where(x => x.company.Equals(company));

    if (!String.IsNullOrEmpty(address))
        aaa = aaa.Where(x => x.address.Equals(address));

    if (age.HasValue)
        aaa = aaa.Where(x => x.age == age.Value);

    return aaa;
}

Answer 4

My two cents on the subject:

1. I don't think you need to simplify the method to one Where clause because if you keep it this way, you can easily add new filter parameters later and your code would be quite readable.
2. You don't need to specify ToList() .
3. Instead of String.IsNullOrEmpty() consider using String.IsNullOrWhiteSpace() . This way, you will not filter out entities if a non-empty but whitespace string is provided.
4. Instead of x.name.Equals(name) consider using x.name.Equals(name, StringComparison.InvariantCultureIgnoreCase) if appropriate.

Answer 5

You could do something like this:

var ans = aaa.Where(x => !string.IsNullOrEmpty(name) ? x.name.equal(name) : false).ToList()
             .Union(aaa.Where(x => !string.IsNullOrEmpty(company) ? x.company.equal(company) : false).ToList())
             .Union(aaa.Where(x => !string.IsNullOrEmpty(address) ? x.address.equal(address) : false).ToList());

ans = ans.Where(x => age.HasValue ? x.age == age.Value : true).ToList();

Answer 6

You should try something like this :

private static IEnumerable<SomeClass> Filter(IEnumerable<SomeClass> aaa, string name, string company, string address, int? age)
{

        var ans = aaa.Where(x => !String.IsNullOrEmpty(name) ? x.Name.Equals(name) : true)
                 .Where(x => !String.IsNullOrEmpty(company) ? x.Company.Equals(company) : true
                     && !String.IsNullOrEmpty(address) ? x.Address.Equals(address) : true
                     && age.HasValue ? x.Age == age.Value : true);


        return ans;
} 

But note that in your code, you always return 0 results if the "name" parameter is empty.