表达式树lambda不得包含空传播运算符

90

问题：price = co?.price ?? 0,以下代码中的行给了我上面的错误。但是如果我?从中删除，co.?效果很好。我试图按照此MSDN例如，他们使用的是?上线select new { person.FirstName, PetName = subpet?.Name ?? String.Empty };所以，看来我需要了解什么时候使用?与??和何时不。

错误：

表达式树lambda不得包含空传播运算符

public class CustomerOrdersModelView
{
    public string CustomerID { get; set; }
    public int FY { get; set; }
    public float? price { get; set; }
    ....
    ....
}
public async Task<IActionResult> ProductAnnualReport(string rpt)
{
    var qry = from c in _context.Customers
              join ord in _context.Orders
                on c.CustomerID equals ord.CustomerID into co
              from m in co.DefaultIfEmpty()
              select new CustomerOrdersModelView
              {
                  CustomerID = c.CustomerID,
                  FY = c.FY,
                  price = co?.price ?? 0,
                  ....
                  ....
              };
    ....
    ....
 }
c#  linq  null-coalescing-operator 
— 南
source
请发布错误...
— Willem Van Onsem
3
老兄，我希望C＃支持这一点！
— nawfal

Answers:

141

您引用的示例使用LINQ to Objects，其中查询中的隐式lambda表达式将转换为委托...而您正在使用EF或类似IQueryable<T>查询，将lambda表达式转换为表达式树。表达式树不支持空条件运算符（或元组）。

用旧的方法做：

price = co == null ? 0 : (co.price ?? 0)

（我相信在表达式树中可以使用null-coalescing运算符。）

— 乔恩·斯基特
source
如果您使用的是Dynamic LINQ（System.Linq.Dynamic.Core），则可以使用该np()方法。见github.com/StefH/System.Linq.Dynamic.Core/wiki/NullPropagation
— Stef Heyenrath'Aug
10

您链接到的代码使用List<T>。List<T>实现IEnumerable<T>但不实现IQueryable<T>。在这种情况下，投影将在内存中执行并?.起作用。

您正在使用some IQueryable<T>，它们的工作方式非常不同。对于IQueryable<T>，将创建投影的表示形式，并且LINQ提供程序将在运行时决定如何处理它。由于向后兼容的原因，?.此处不能使用。

根据您的LINQ提供程序，您可能可以使用plain .，但仍然无法获取任何内容NullReferenceException。

@hvd您能解释一下为什么向后兼容吗？
— jag
1
@jag在引入之前已经创建的所有LINQ提供程序?.都不会准备以?.任何合理的方式进行处理。
1
但是，?.是新操作员吗？因此旧代码将不会使用?.，因此不会被破坏。Linq提供程序不准备处理许多其他事情，例如CLR方法。
— jag
2
@jag对，将旧代码与旧LINQ提供程序结合使用不会受到影响。旧代码将不会使用?.。新的代码可能会使用旧的LINQ提供程序，它都准备好如何处理他们不承认的CLR方法（通过抛出异常），因为这些很好地融入现有的表达式树的对象模型。全新的表达式树的节点类型不适合英寸
3
考虑到LINQ提供者已经抛出的异常数量，似乎几乎不值得进行权衡取舍-“我们过去不支持，所以我们宁愿永远也不能”
— NetMage
1

乔恩·斯凯特（Jon Skeet）的回答是正确的，就我而言，我在DateTime实体类中使用的答案是正确的。当我尝试使用像

(a.DateProperty == null ? default : a.DateProperty.Date)

我有错误

Property 'System.DateTime Date' is not defined for type 'System.Nullable`1[System.DateTime]' (Parameter 'property')

所以我需要更改DateTime?我的实体类，

(a.DateProperty == null ? default : a.DateProperty.Value.Date)
— 乌古尔·奥斯图克（Ugur Ozturk）
source
这与空传播算子无关。
— Gert Arnold
我喜欢您提到乔恩·斯基特（Jon Skeet）是对的，暗示他有可能错了。好一个！
— 克利克
0

尽管表达式树不支持C＃6.0 null传播，但是我们可以做的是创建一个访问者，该访问者修改表达式树以实现安全的null传播，就像运算符一样！

这是我的：

public class NullPropagationVisitor : ExpressionVisitor
{
    private readonly bool _recursive;

    public NullPropagationVisitor(bool recursive)
    {
        _recursive = recursive;
    }

    protected override Expression VisitUnary(UnaryExpression propertyAccess)
    {
        if (propertyAccess.Operand is MemberExpression mem)
            return VisitMember(mem);

        if (propertyAccess.Operand is MethodCallExpression met)
            return VisitMethodCall(met);

        if (propertyAccess.Operand is ConditionalExpression cond)
            return Expression.Condition(
                    test: cond.Test,
                    ifTrue: MakeNullable(Visit(cond.IfTrue)),
                    ifFalse: MakeNullable(Visit(cond.IfFalse)));

        return base.VisitUnary(propertyAccess);
    }

    protected override Expression VisitMember(MemberExpression propertyAccess)
    {
        return Common(propertyAccess.Expression, propertyAccess);
    }

    protected override Expression VisitMethodCall(MethodCallExpression propertyAccess)
    {
        if (propertyAccess.Object == null)
            return base.VisitMethodCall(propertyAccess);

        return Common(propertyAccess.Object, propertyAccess);
    }

    private BlockExpression Common(Expression instance, Expression propertyAccess)
    {
        var safe = _recursive ? base.Visit(instance) : instance;
        var caller = Expression.Variable(safe.Type, "caller");
        var assign = Expression.Assign(caller, safe);
        var acess = MakeNullable(new ExpressionReplacer(instance,
            IsNullableStruct(instance) ? caller : RemoveNullable(caller)).Visit(propertyAccess));
        var ternary = Expression.Condition(
                    test: Expression.Equal(caller, Expression.Constant(null)),
                    ifTrue: Expression.Constant(null, acess.Type),
                    ifFalse: acess);

        return Expression.Block(
            type: acess.Type,
            variables: new[]
            {
                caller,
            },
            expressions: new Expression[]
            {
                assign,
                ternary,
            });
    }

    private static Expression MakeNullable(Expression ex)
    {
        if (IsNullable(ex))
            return ex;

        return Expression.Convert(ex, typeof(Nullable<>).MakeGenericType(ex.Type));
    }

    private static bool IsNullable(Expression ex)
    {
        return !ex.Type.IsValueType || (Nullable.GetUnderlyingType(ex.Type) != null);
    }

    private static bool IsNullableStruct(Expression ex)
    {
        return ex.Type.IsValueType && (Nullable.GetUnderlyingType(ex.Type) != null);
    }

    private static Expression RemoveNullable(Expression ex)
    {
        if (IsNullableStruct(ex))
            return Expression.Convert(ex, ex.Type.GenericTypeArguments[0]);

        return ex;
    }

    private class ExpressionReplacer : ExpressionVisitor
    {
        private readonly Expression _oldEx;
        private readonly Expression _newEx;

        internal ExpressionReplacer(Expression oldEx, Expression newEx)
        {
            _oldEx = oldEx;
            _newEx = newEx;
        }

        public override Expression Visit(Expression node)
        {
            if (node == _oldEx)
                return _newEx;

            return base.Visit(node);
        }
    }
}

它通过了以下测试：

private static string Foo(string s) => s;

static void Main(string[] _)
{
    var visitor = new NullPropagationVisitor(recursive: true);

    Test1();
    Test2();
    Test3();

    void Test1()
    {
        Expression<Func<string, char?>> f = s => s == "foo" ? 'X' : Foo(s).Length.ToString()[0];

        var fBody = (Expression<Func<string, char?>>)visitor.Visit(f);

        var fFunc = fBody.Compile();

        Debug.Assert(fFunc(null) == null);
        Debug.Assert(fFunc("bar") == '3');
        Debug.Assert(fFunc("foo") == 'X');
    }

    void Test2()
    {
        Expression<Func<string, int>> y = s => s.Length;

        var yBody = visitor.Visit(y.Body);
        var yFunc = Expression.Lambda<Func<string, int?>>(
                                    body: yBody,
                                    parameters: y.Parameters)
                            .Compile();

        Debug.Assert(yFunc(null) == null);
        Debug.Assert(yFunc("bar") == 3);
    }

    void Test3()
    {
        Expression<Func<char?, string>> y = s => s.Value.ToString()[0].ToString();

        var yBody = visitor.Visit(y.Body);
        var yFunc = Expression.Lambda<Func<char?, string>>(
                                    body: yBody,
                                    parameters: y.Parameters)
                            .Compile();

        Debug.Assert(yFunc(null) == null);
        Debug.Assert(yFunc('A') == "A");
    }
}
— Leandromoh
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.