linq表达式作为参数

Question

I have to query collection like this:

myList.Where(s => myFilters.Contains(s.CountryCode))

s.CountryCode above is an example. I want to make it variable and call for different columns, like this:

myList.Where(s => myFilters.Contains(s.City))
myList.Where(s => myFilters.Contains(s.Region))
myList.Where(s => myFilters.Contains(s.Zipcode))

So I would like to define function where the column expression is a parameter. What is the signature of such function?

public void MySelect( ??? )
{
    myList.Where(s => myFilters.Contains(???);
}

myList is an ObservableCollection , and myFilters is List<string>

Answer 1

Put this extension method in a static class:

public static IEnumerable<T> WhereContains<T, TValue> (this IEnumerable<T> obj, IEnumerable<TValue> container, Func<T, TValue> propertyAccess)
{
    return obj.Where(o => container.Contains(propertyAccess(o)));
}

The way this extension method works is that it accepts a lambda function that resolves the property given an object of your type. So you just need to pass a simple lamba like x => x.City to it.

Since it's completely generic and not specific to your one myFilters collection, you also need to pass it to the function. But that allows you to use this WhereContains for many other situations too.

Using it looks like this:

// Test is a class with two string properties `City` and `Region`
var myList = new List<Test>{
    new Test() { City = "asdf", Region = "fdsa" },
    new Test() { City = "foo", Region = "bar" },
    new Test() { City = "bar", Region = "baz" }
};

var myFilters = new List<string> { "asdf", "bar" };

myList.WhereContains(myFilters, x => x.City); // contains asdf/fdsa and bar/baz
myList.WhereContains(myFilters, x => x.Region); // contains foo/bar

Answer 2

You can use Reflection

 public void MySelect(string column)
 {
   var result  = myList.Where(s => myFilters.Contains(s.GetType().GetProperty(column)));
 }

Answer 3

As an alternative solution you can use the following approach which allows to specify either filter field or filter function:

var adresses = new List<Address>{
    new Address() { City = "ABC", Country = "USA" },
    new Address() { City = "BC", Country = "USA" },
    new Address() { City = "C", Country = "UK" }
};
var filterValues = new List<string> { "B", "UK", "U" };
//
var FilterContains = filterValues.@Specify((values, value) => values.Contains(value));
var FilterStartsWith = filterValues.@Specify((values, value) => values.Any(v => value.StartsWith(v)));
//
var AdressesByCity = adresses.@Specify(a => a.City);
var adressesByCitiesContains = AdressesByCity(filterValues, FilterContains); // B->{ABC;USA},{BC;USA}
var adressesByCitiesStartsWith = AdressesByCity(filterValues, FilterStartsWith);// B->{BC;USA}
//
var AdressesByCountry = adresses.@Specify(a => a.Country);
var adressesByCountriesContains = AdressesByCountry(filterValues, FilterContains);//U,UK-> {C;UK}
var adressesByCountriesStartsWith = AdressesByCountry(filterValues, FilterStartsWith); //U,UK->{ABC;USA},{BC;USA}{C;UK}

Here the @Specify extension methods are implemented as follows:

public static class @SpecifyExtension {
    public static Func<IEnumerable<V>, Func<IEnumerable<V>, V, bool>, IEnumerable<U>> @Specify<U, V>(this IEnumerable<U> source, Func<U, V> selector) {
        return (values, predicate) => source.Where(x => predicate(values, selector(x)));
    }
    public static Func<IEnumerable<TValue>, TValue, bool> @Specify<TValue>(this IEnumerable<TValue> source, Func<IEnumerable<TValue>, TValue, bool> func) {
        return func; // for Type-inference only
    }
}