một cây biểu thức lambda có thể không chứa một toán tử lan truyền rỗng

Câu hỏi : Dòng price = co?.price ?? 0,trong đoạn mã sau cho tôi lỗi ở trên. nhưng nếu tôi loại bỏ ?từ co.?nó hoạt động tốt. Tôi đã cố gắng làm theo ví dụ MSDN này mà họ đang sử dụng ?trực tuyến select new { person.FirstName, PetName = subpet?.Name ?? String.Empty };Vì vậy, có vẻ như tôi cần hiểu khi nào thì nên sử dụng ?với ??và khi nào thì không.

Lỗi :

một cây biểu thức lambda có thể không chứa một toán tử lan truyền rỗng

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,
                  ....
                  ....
              };
    ....
    ....
 }

Ví dụ bạn đang trích dẫn từ sử dụng LINQ thành Đối tượng, trong đó các biểu thức lambda ngầm định trong truy vấn được chuyển đổi thành các đại biểu ... trong khi bạn đang sử dụng EF hoặc tương tự, với các IQueryable<T>truy vấn, trong đó các biểu thức lambda được chuyển đổi thành cây biểu thức . Cây biểu thức không hỗ trợ toán tử điều kiện null (hoặc bộ giá trị).

Chỉ cần làm theo cách cũ:

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

(Tôi tin rằng toán tử kết hợp rỗng là tốt trong cây biểu thức.)

Mã bạn liên kết để sử dụng List<T>. List<T>nông cụ IEnumerable<T>nhưng không IQueryable<T>. Trong trường hợp đó, phép chiếu được thực thi trong bộ nhớ và ?.hoạt động.

Bạn đang sử dụng một số IQueryable<T>, hoạt động rất khác. Đối với IQueryable<T>, một bản trình bày của phép chiếu được tạo và nhà cung cấp LINQ của bạn quyết định phải làm gì với nó trong thời gian chạy. Vì lý do tương thích ngược, ?.không thể sử dụng ở đây.

Tùy thuộc vào nhà cung cấp LINQ của bạn, bạn có thể sử dụng đơn giản .mà vẫn không nhận được bất kỳ NullReferenceException.

Câu trả lời của Jon Skeet là đúng, trong trường hợp của tôi, tôi đang sử dụng DateTimecho lớp Thực thể của mình. Khi tôi cố gắng sử dụng like

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

Tôi đã có lỗi

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

Vì vậy, tôi cần thay đổi DateTime?cho lớp thực thể của mình và

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

Trong khi cây biểu thức không hỗ trợ việc truyền null trong C # 6.0, những gì chúng ta có thể làm là tạo một khách truy cập sửa đổi cây biểu thức để truyền null an toàn, giống như toán tử làm!

Đây là của tôi:

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);
        }
    }
}

Nó vượt qua các bài kiểm tra sau:

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");
    }
}