C# 如何构建不敏感地从ObservableCollection案例中搜索项目的表达式

我正在使用ExpressionBuilder构建表达式来搜索ObservableCollection中的项，但该表达式对集合的搜索区分大小写。我希望使其不区分大小写。我怎么做？ 我的代码在这里：

public class ExpressionBuilder
{
    private MethodInfo containsMethod = typeof(string).GetMethod("Contains");
    private MethodInfo startsWithMethod = typeof(string).GetMethod("StartsWith",new Type[] { typeof(string)});
    private MethodInfo endsWithMethod =  typeof(string).GetMethod("EndsWith",new Type[] { typeof(string)});

    public Expression<Func<T, bool>> GetExpression<T>(IList<SearchFilter> filter)
    {
        var filters = new List<SearchFilter>(filter);
        if (filters.Count == 0)
            return null;

        ParameterExpression param = Expression.Parameter(typeof(T), "t");
        Expression exp = null;

        if (filters.Count == 1)
            exp = GetExpression<T>(param, filters[0]);
        else if (filters.Count == 2)
            exp = GetExpression<T>(param, filters[0], filters[1]);
        else
        {
            while (filters.Count > 0)
            {
                var f1 = filters[0];
                var f2 = filters[1];

                if (exp == null)
                    exp = GetExpression<T>(param, filters[0], filters[1]);
                else
                    if(filter[1].Andor == "And" || filter[1].Andor == null)
                    {
                    exp = Expression.AndAlso(exp, GetExpression<T>(param, filters[0], filters[1]));
                    }
                    else
                    {
                    exp = Expression.Or(exp, GetExpression<T>(param, filters[0], filters[1]));
                    }                        

                filters.Remove(f1);
                filters.Remove(f2);

                if (filters.Count == 1)
                {
                    if (filter[1].Andor == "And" || filter[1].Andor == null)
                    {
                        exp = Expression.AndAlso(exp, GetExpression<T>(param, filters[0]));
                    }
                    else
                    {
                        exp = Expression.Or(exp, GetExpression<T>(param, filters[0]));
                    }
                    filters.RemoveAt(0);
                }
            }
        }

        return Expression.Lambda<Func<T, bool>>(exp, param);
    }

    private Expression GetExpression<T>(ParameterExpression param, SearchFilter filter)
    {
        object con;
        MemberExpression member = Expression.Property(param, filter.PropertyName);

        if (filter.PropertyName == "Emp_ID")
        {
            con = Convert.ChangeType(filter.Value,Convert.ToInt32(filter.Value).GetType());
        }
        else
        {
            con = Convert.ChangeType(filter.Value.ToString().ToLower(),filter.Value.GetType());                
        }

        ConstantExpression constant = Expression.Constant(con);
        Expression expReturn = null;

        switch (filter.Operation)
        {
            case Operation.Equals:
                expReturn = Expression.Equal(member,Expression.Convert(constant, member.Type));
                break;

            case Operation.GreaterThan:
                expReturn = Expression.GreaterThan(member,Expression.Convert(constant, member.Type));
                break;

            case Operation.GreaterThanOrEqual:
                expReturn = Expression.GreaterThanOrEqual(member,Expression.Convert(constant, member.Type));
                break;

            case Operation.LessThan:
                expReturn = Expression.LessThan(member,Expression.Convert(constant, member.Type));
                break;

            case Operation.LessThanOrEqual:
                expReturn = Expression.LessThanOrEqual(member,Expression.Convert(constant, member.Type));
                break;

            case Operation.Contains:
                expReturn = Expression.Call(member, containsMethod,Expression.Convert(constant,member.Type));
                break;

            case Operation.StartsWith:
                expReturn = Expression.Call(member, startsWithMethod,Expression.Convert(constant, member.Type));
                break;

            case Operation.EndsWith:
                expReturn = Expression.Call(member, endsWithMethod,Expression.Convert(constant, member.Type));
                break;
        }

        return expReturn;
    }

    private BinaryExpression GetExpression<T>(ParameterExpression param, SearchFilter filter1, SearchFilter filter2)
    {
        Expression bin1 = GetExpression<T>(param, filter1);
        Expression bin2 = GetExpression<T>(param, filter2);
        if(filter2.Andor == "And" || filter2.Andor == null)
        {
            return Expression.AndAlso(bin1, bin2);
        }
        return Expression.Or(bin1, bin2);
    }

公共类ExpressionBuilder
{
私有MethodInfo containsMethod=typeof（string）.GetMethod（“Contains”）；
私有MethodInfo startsWithMethod=typeof（string）.GetMethod（“StartsWith”，新类型[]{typeof（string）}）；
私有MethodInfo endsWithMethod=typeof（string）.GetMethod（“EndsWith”，新类型[]{typeof（string）}）；
公共表达式GetExpression（IList筛选器）
{
var过滤器=新列表（过滤器）；
如果（filters.Count==0）
返回null；
ParameterExpression param=表达式参数（typeof（T），“T”）；
表达式exp=null；
如果（filters.Count==1）
exp=GetExpression（参数，过滤器[0]）；
else if（filters.Count==2）
exp=GetExpression（参数，过滤器[0]，过滤器[1]）；
其他的
{
而（filters.Count>0）
{
var f1=过滤器[0]；
var f2=过滤器[1]；
如果（exp==null）
exp=GetExpression（参数，过滤器[0]，过滤器[1]）；
其他的
如果（筛选器[1]。和或==”和“| |筛选器[1]。和或==null）
{
exp=Expression.AndAlso（exp，GetExpression（参数，过滤器[0]，过滤器[1]）；
}
其他的
{
exp=Expression.Or（exp，GetExpression（param，filters[0]，filters[1]）；
}                        
过滤器。移除（f1）；
过滤器。移除（f2）；
如果（filters.Count==1）
{
如果（筛选器[1]。和或==”和“| |筛选器[1]。和或==null）
{
exp=Expression.AndAlso（exp，GetExpression（param，filters[0]）；
}
其他的
{
exp=Expression.Or（exp，GetExpression（param，filters[0]）；
}
过滤器。移除（0）；
}
}
}
返回表达式.Lambda（exp，param）；
}
私有表达式GetExpression（ParameterExpression param，SearchFilter筛选器）
{
对象con；
MemberExpression member=Expression.Property（param，filter.PropertyName）；
如果（filter.PropertyName==“Emp_ID”）
{
con=Convert.ChangeType（filter.Value，Convert.ToInt32（filter.Value.GetType（））；
}
其他的
{
con=Convert.ChangeType（filter.Value.ToString（）.ToLower（），filter.Value.GetType（））；
}
恒常压力常数=表达式常数（con）；
表达式expReturn=null；
开关（过滤器操作）
{
案例操作。等于：
expReturn=Expression.Equal（member，Expression.Convert（constant，member.Type））；
打破
案例操作。大于：
expReturn=Expression.GreaterThan（member，Expression.Convert（constant，member.Type））；
打破
病例操作。大于或等于：
expReturn=Expression.GreaterThanOrEqual（member，Expression.Convert（constant，member.Type））；
打破
案例操作。LessThan：
expReturn=Expression.LessThan（member，Expression.Convert（constant，member.Type））；
打破
案例操作。LessThanOrEqual：
expReturn=Expression.LessThanOrEqual（member，Expression.Convert（constant，member.Type））；
打破
案例操作。包含：
expReturn=Expression.Call（member，containsMethod，Expression.Convert（constant，member.Type））；
打破
case Operation.StartsWith：
expReturn=Expression.Call（member，startsWithMethod，Expression.Convert（constant，member.Type））；
打破
case Operation.EndsWith：
expReturn=Expression.Call（member，endsWithMethod，Expression.Convert（constant，member.Type））；
打破
}
返回expReturn；
}
私有二进制表达式GetExpression（ParameterExpression param、SearchFilter filter1、SearchFilter filter2）
{
表达式bin1=GetExpression（参数，过滤器1）；
表达式bin2=GetExpression（参数，过滤器2）；
if（filter2.Andor==”和“| | filter2.Andor==null）
{
返回表达式.AndAlso（bin1，bin2）；
}
返回表达式.Or（bin1，bin2）；
}

上面的类构建表达式

下面是我如何使用该表达式从ObservaleCollection进行搜索的：

 ExpressionBuilder ex = new ExpressionBuilder();
 var exp = ex.GetExpression<Employee>(SearchFilters);
 employees = new ObservableCollection<Employee>(EMP.AsQueryable().Where(exp).ToList());

ExpressionBuilder ex=new ExpressionBuilder（）；
var exp=ex.GetExpression（SearchFilters）；
employees=新的ObservableCollection（EMP.AsQueryable（）.Where（exp.ToList（））；