Question

我正在基于字符串数组动态创建一个Linq表达式，我遇到了一个问题。表达式创建和括号的方式导致它在Id 3上抛出一个对象空引用。它创建了这个表达式，如果它是正确的括号，它将不会计算表达式的后半部分而不会抛出错误我假设。任何人都有办法创建表达式，所以它不会像这样括起来吗？

{x => ((True And x.Id.ToString().ToLower().Contains("John")) Or ((x.Name != null) And     x.Name.ToString().ToLower().Contains("John")))}

class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Test
{
    public void someMethod()
    {
        var x = new List<Person>(new Person[] { 
            new Person { Id = 1, Name = "Jerry" },
            new Person { Id = 2, Name = "Mary" },
            new Person { Id = 3, Name = null },
            new Person { Id = 4, Name = "John" },
            new Person { Id = 5, Name = "Amy" }
        });

        var columns = new List<string>(new string[] {
            "Name",
            "Id"
        });
        var searchTerm = "John";

        var searchColumns = columns.Select(a => new { ColName = a });


        var type = typeof(Person);

        ParameterExpression paramExpr = Expression.Parameter(type, "x");
        Expression body = null;

        var piList = new List<PropertyInfo>();

        foreach (var s in searchColumns)
            piList.Add(type.GetProperty(s.ColName));

        if (piList[0].PropertyType.IsPrimitive || piList[0].PropertyType.Equals(typeof(DateTime)))
            body = Expression.Constant(true);
        else
            body = Expression.NotEqual(Expression.Property(paramExpr, piList[0]), Expression.Constant(null, piList[0].PropertyType));

        body = Expression.And(body,
                    Expression.Call(
                            Expression.Call(
                                Expression.Call(
                                    Expression.Property(paramExpr, piList[0]),
                                    typeof(Convert).GetMethod("ToString", Type.EmptyTypes)
                                ),
                                typeof(string).GetMethod("ToLower", new Type[0])
                            ),
                            typeof(string).GetMethod("Contains"),
                            Expression.Constant(searchTerm.ToLower())
                        ));

        for (int i = 1; i < piList.Count; i++)
        {
            Expression body1 = null;

            if (piList[i].PropertyType.IsPrimitive || piList[i].PropertyType.Equals(typeof(DateTime)))
                body1 = Expression.Constant(true);
            else
                body1 = Expression.NotEqual(Expression.Property(paramExpr, piList[i]), Expression.Constant(null, piList[i].PropertyType));

            body =
                Expression.Or(body,
                    Expression.And(body1,
                        Expression.Call(
                            Expression.Call(
                                Expression.Call(
                                    Expression.Property(paramExpr, piList[i]),
                                    typeof(Convert).GetMethod("ToString", Type.EmptyTypes)
                                ),
                                typeof(string).GetMethod("ToLower", new Type[0])
                            ),
                            typeof(string).GetMethod("Contains"),
                            Expression.Constant(searchTerm.ToLower())
                        )
                    ));
        }

        var lambda = Expression.Lambda<Func<Person, bool>>(body, paramExpr);
    }
}

Answer 1

为什么不建立其中一个。它们都避免了Name的空值问题。

(x.Name ?? "").IndexOf("John", StringComparison.CurrentCultureIgnoreCase) >= 0

或者，如果你真的想要相等，那么不要把它包含在子串中

string.Equals(x.Name, "John", StringComparison.CurrentCultureIgnoreCase)

BTW - x.Id永远不会包含“John”，也不会包含小写字符串。

此外，您可能需要考虑使用PredicateBuilder而不是直接构建表达式。

在动态创建linq表达式中处理空值

1 个答案: