基於KeyValuePairs的過濾器列表

Question

我有一個列表，我想基於KeyValuePair列表進行過濾。 KeyValuePair中的所有鍵都存在於對象中。

所以我們可以說我有這個類對象的列表：

public class filters 
{ 
    public string Name { get; set; } 
    public string Age { get; set; } 
    public string Country { get; set; } 
} 

而且我有一個KeyValuePair有：

Key: "Name", Value: "test" 
Key: "Country", Value: "SE" 

是否有可能產生一些不同於那種LINQ謂詞KeyValuePair可用作list.Where(predicate)，謂詞將與我寫list.Where(c => c.Name == "test" && c.Country == "SE")時相同？

或者我該如何處理？

Answer 1

作爲一個班輪：

var filters = new Dictionary<string, string>{{"Name", "test"}, {"Country", "SE"}}; 
var result = list.Where(item => filters.All(f => (string)(item.GetType().GetProperty(f.Key)?.GetValue(item)) == f.Value)); 

這使您可以有任意多個過濾器。

對於list中的每個item，All謂詞將檢查每個過濾器的有效性。 item.GetType()獲取item的Type（即關於您班級的信息）。 GetProperty(f.Key)獲取特定屬性的信息，以當前過濾器f的Key命名。 GetValue(item)獲取當前item的屬性值。?是c＃6的新功能，即它是對null的內聯檢查，即如果未找到該屬性，則不會嘗試執行GetValue - 這將引發NullReferenceException - 但會返回null。然後您必須將屬性值轉換爲string並將其與當前過濾器的Value進行比較。你也可以使用String :: Compare（或者你喜歡的其他比較方法）。

All只返回true如果滿足所有過濾器，否則返回false。所以這個查詢的結果將包含滿足所有過濾器在你的字典中的所有元素

Answer 2

我可能有錯誤理解，你在這裏，但這樣做你想要做什麼：

// say I have a list of ilters like this 
// assume there are actually some filters in here though 
var filterCollection = new List<filters>() 

// build dictionary of key values 
var keyedSet = filterCollection.ToDictionary(i => i.Name + i.Country, i => i); 

// query them using key ... 
var filterItem = keyedSet["testSE"]; 

...或者你可以用謂詞中的擴展方法...

public IEnumerable<filters> ByNameAndCountry(this IEnumerable<filters> collection, string name, string country) 
{ 
    return collection.Where(i => i.Name == name && i => i.Country == country); 
} 

。 ..已經完成，你可以像這樣過濾原始列表...

var result = filterCollection.ByNameAndCountry("test", "ES"); 

Answer 3

這樣的事情？通過反射獲取Propertyname並進行平等檢查。

Func<filters, IEnumerable<KeyValuePair<string, string>>, bool> filter = (filters, pairs) => 
{ 
    foreach (var valuePair in pairs) 
    { 
     if (filters.GetType().GetProperty(valuePair.Key).GetValue(filters) != valuePair.Value) 
     { 
      return false; 
     } 
    } 
    return true; 
}; 

List<filters> list = new List<filters>(); 
list.Add(new filters() { Name = "Name1", Country = "DE"}); 
list.Add(new filters() { Name = "Name2", Country = "SE"}); 

var element = list.FirstOrDefault(x => filter(x, new List<KeyValuePair<string, string>>() { 
    new KeyValuePair<string, string>("Name", "Name2"), 
    new KeyValuePair<string, string>("Country", "SE"), 
})); 

Console.WriteLine(element.Name); 

Answer 4

這應該做的伎倆：

void Main() 
{ 
    List<Filter> filters = new List<Filter>() { 
     new Filter {Name = "Filter1", Age = 1, Country ="De"}, 
     new Filter {Name = "Filter2", Age = 2, Country ="Fr"}, 
     new Filter {Name = "Filter3", Age = 3, Country ="It"}, 
     new Filter {Name = "Filter4", Age = 4, Country ="Es"}, 
    }; 

    KeyValuePair<string, string> kvp = new KeyValuePair<string, string>("Filter1", "De"); 

    var result = filters.AsQueryable().Where (GetPredicate(kvp)); 
    result.Dump(); 
} 
//Create the predicate as an expression, which takes a Filter as input and a kvp as a parameter 
private static Expression<Func<Filter, bool>> GetPredicate(KeyValuePair<string,string> kvp) 
{ 
     return (f) => f.Name == kvp.Key && f.Country == kvp.Value; 
} 

結果：

Answer 5

你想從KeyValuePair，這是IEnumerable<KeyValuePair<string, string>>產生Predicate<filters>。所以這是

Func<IEnumerable<KeyValuePair<string, string>>, Predicate<filters>> 

使用反射枚舉KeyValuePair.Key上市All性能，並檢查是否每個屬性值匹配KeyValuePair.Value。完整的代碼是這樣

var lists = new List<filters> { new filters { Name = "abc", Country = "def" } }; 

Func<IEnumerable<KeyValuePair<string, string>>, Predicate<filters>> predicateBuilder = 
(keyValueParis) => filter => (from kp in keyValueParis 
           let pi = typeof(filters).GetProperty(kp.Key) 
           select pi.GetValue(filter) == kp.Value) 
           .All(r => r); 

var predicates = new List<KeyValuePair<string, string>> 
{ 
    new KeyValuePair<string, string>("Name", "abc"), 
    new KeyValuePair<string, string>("Country", "def") 
}; 
Predicate<filters> predicate = predicateBuilder(predicates); 

Console.WriteLine(lists.FindAll(predicate).Count); 

Answer 6

你可以使用這樣的方法：

void Main() 
{ 
    var keyValuePairs = new List<KeyValuePair> 
    { 
     new KeyValuePair {Key = "Name", Value = "Test"}, 
     new KeyValuePair {Key = "Age", Value = "42"}, 
     new KeyValuePair {Key = "Country", Value = "USA"} 
    }; 

    var list = new List<Filter>(); 
    list.Add(new Filter { Name = "Test", Age = "42", Country = "USA" }); 

    list.Where(keyValuePairs.ToPredicate<Filter>()).Dump(); 
} 

public class Filter 
{ 
    public string Name { get; set; } 
    public string Age { get; set; } 
    public string Country { get; set; } 
} 

public class KeyValuePair 
{ 
    public string Key { get; set; } 

    public string Value { get; set; } 
} 

public static class KeyValuePairExtensions 
{ 
    public static Func<T, bool> ToPredicate<T>(this IEnumerable<KeyValuePair> keyValuePairs) 
    { 
     if (keyValuePairs == null || !keyValuePairs.Any()) 
      return t => false; // default value in case the enumerable is empty 

     var parameter = Expression.Parameter(typeof(T)); 

     var equalExpressions = new List<BinaryExpression>(); 

     foreach (var keyValuePair in keyValuePairs) 
     { 
      var propertyInfo = typeof(T).GetProperty(keyValuePair.Key); 

      var property = Expression.Property(parameter, propertyInfo); 

      var value = Expression.Constant(keyValuePair.Value, propertyInfo.PropertyType); 

      var equalExpression = Expression.Equal(property, value); 
      equalExpressions.Add(equalExpression); 
     } 

     var expression = equalExpressions.First(); 

     if (equalExpressions.Count > 1) 
     { 
      // combine expression with and 
      expression = Expression.AndAlso(equalExpressions[0], equalExpressions[1]); 

      for (var i = 2; i < equalExpressions.Count; i++) 
      { 
       expression = Expression.AndAlso(expression, equalExpressions[i]); 
      } 
     } 

     var lambda = (Func<T, bool>)Expression.Lambda(expression, parameter).Compile(); 
     return lambda; 
    } 
} 

您還可以擴展ToPredicate方法將KeyValuePairs的東西結合起來不是and。