基于 KeyValuePairs 的过滤列表

Question

我有一个列表，我想根据 KeyValuePairs 列表进行过滤。 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"

是否可以从 KeyValuePair 生成某种可用作list.Where(predicate) 的 LINQ 谓词，并且该谓词与我写的 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

这样的？通过反射获取 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 3

我可能在这里误解了你的意思，但这是否符合你的要求：

// 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 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 生成的 Predicate<filters>，即 IEnumerable<KeyValuePair<string, string>>。原来如此

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 以外的其他内容结合起来。