Question

我正在尝试创建一个带有三个参数的泛型方法。 1）列表集合 2）String PropertyName 3）String FilterString

我们的想法是传递一个对象集合，即对象属性的名称和筛选条件，它返回属性包含的对象列表 FilterString。

此外，PropertyName是可选的，因此如果未提供，我想返回在任何属性中包含FilterString的所有对象。

任何关于此的指示都会非常有用。

我正在尝试这样的方法签名： public static List FilterList（List collection，String FilterString，String Property =“”）

这样我可以从任何地方调用此方法并将其传递给任何List，它会返回一个筛选列表。

Answer 1

你可以使用LINQ做你想做的事情，

var collection = ...
var filteredCollection = 
    collection.Where(item => item.Property == "something").ToList();

否则，您可以尝试反思，

public List<T> Filter<T>(
    List<T> collection, 
    string property, 
    string filterValue)
{
    var filteredCollection = new List<T>();
    foreach (var item in collection)
    {
         // To check multiple properties use,
         // item.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)

         var propertyInfo = 
             item.GetType()
                 .GetProperty(property, BindingFlags.Public | BindingFlags.Instance);
         if (propertyInfo == null)
             throw new NotSupportedException("property given does not exists");             

         var propertyValue = propertyInfo.GetValue(item, null);
         if (propertyValue == filterValue)
             filteredCollection.Add(item);       
    }

    return filteredCollection;
}

此解决方案的问题是对属性名称或拼写错误的更改会导致运行时错误，而不是使用名称为硬类型的实际属性表达式的编译错误。

另外，请注意，根据绑定标记，这仅适用于public，non-static属性。您可以通过传递不同的flags来修改此类行为。

Answer 2

您应该使用Dynamic LINQ，例如，给定SomeClass：

public class SomeClass 
{
    public int SomeField { get; set; }
}
List<SomeClass> list = new List<SomeClass>() { new SomeClass() { SomeField = 2 } };

然后：

var temp = list.AsQueryable().Where("SomeField == 1").Select("it");
var result= temp .Cast<SomeClass>().ToList();

所以你的函数会更简单，属性名称和过滤器合并为一个参数：

public List<T> Filter<T>(List<T> list, string filter)
{
    var temp = list.AsQueryable().Where(filter).Select("it");
    return temp.Cast<T>().ToList();
}

您可以提供不同的过滤器，例如"SomeField > 4 && SomeField < 10"等。

Answer 3

您可以为此使用反射和动态表达式的组合。我把第一眼看起来有点长的样本放在一起。但是，它符合您的要求并通过

解决这些问题

使用反射查找字符串类型的属性并匹配属性名称 - 如果提供。
创建一个在已识别的所有属性上调用string.Contains的表达式。如果已识别多个属性，则对String.Contains的调用由Or-expressions组合。编译此过滤器表达式并将其作为参数传递给Where扩展方法。使用表达式过滤提供的列表。

按照此link运行示例。

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;

public class Test
{
    public static IEnumerable<T> SelectItems<T>(IEnumerable<T> items, string propName, string value)
    {
        IEnumerable<PropertyInfo> props;
        if (!string.IsNullOrEmpty(propName))
            props = new PropertyInfo[] { typeof(T).GetProperty(propName) };
        else
            props = typeof(T).GetProperties();
        props = props.Where(x => x != null && x.PropertyType == typeof(string));
        Expression lastExpr = null;
        ParameterExpression paramExpr = Expression.Parameter(typeof(T), "x");
        ConstantExpression valueExpr = Expression.Constant(value);
        foreach(var prop in props)
        {
            var propExpr = GetPropertyExpression(prop, paramExpr, valueExpr);
            if (lastExpr == null)
                lastExpr = propExpr;
            else
                lastExpr = Expression.MakeBinary(ExpressionType.Or, lastExpr, propExpr);
        }
        if (lastExpr == null)
            return new T[] {};
        var filterExpr = Expression.Lambda(lastExpr, paramExpr);
        return items.Where<T>((Func<T, bool>) filterExpr.Compile());
    }

    private static Expression GetPropertyExpression(PropertyInfo prop, ParameterExpression paramExpr, ConstantExpression valueExpr)
    {
        var memberAcc = Expression.MakeMemberAccess(paramExpr, prop);
        var containsMember = typeof(string).GetMethod("Contains");
        return Expression.Call(memberAcc, containsMember, valueExpr);
    }

    class TestClass
    {
        public string SomeProp { get; set; }
        public string SomeOtherProp { get; set; }
    }

    public static void Main()
    {
        var data = new TestClass[] {
            new TestClass() { SomeProp = "AAA", SomeOtherProp = "BBB" }, 
            new TestClass() { SomeProp = "BBB", SomeOtherProp = "CCC" }, 
            new TestClass() { SomeProp = "CCC", SomeOtherProp = "AAA" }, 
        };
        var result = SelectItems(data, "", "A");
        foreach(var item in result)
            Console.WriteLine(item.SomeProp);
    }
}

与完全基于反射的方法相比，这个方法只将过滤器表达式组装一次并对其进行编译，这样我就可以期待（小）性能提升。

Answer 4

使用Markus解决方案时，只有当所有String属性都不为null时才会起作用。为了确保你能做到这一点：

class TestClass
{
    private string _someProp { get; set; }
    public string SomeProp { 
        get
        {
            if(string.IsNullOrEmpty(_someProp)
            {
                _someProp = "";
            }
            return _someProp;
        }
        set
        {
            _someProp = value;
        }
    }
    private string _someOtherProp { get; set; }
    public string SomeOtherProp { 
        get
        {
            if(string.IsNullOrEmpty(_someOtherProp)
            {
                _someOtherProp = "";
            }
            return _someOtherProp;
        }
        set
        {
            _someOtherProp = value;
        }
    }
}

由于我的代表不到50，我无法发表评论;）

筛选列表对象的通用方法

4 个答案: