Fix NRE in a filter by an associated object (#487)

Author: JaleChaki

net/DevExtreme.AspNet.Data.Tests.Xpo/Bug486.cs

@@ -0,0 +1,60 @@
+using DevExpress.Xpo;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.Xpo {
+    public class Bug486 {
+
+        [Persistent(nameof(Bug486) + "_" + nameof(Department))]
+        public class Department {
+            [Key]
+            public Guid ID { get; set; }
+        }
+
+        [Persistent(nameof(Bug486) + "_" + nameof(Employee))]
+        public class Employee {
+            [Key]
+            public Guid ID { get; set; }
+
+            [Association("Department-Employees")]
+            public Department Department { get; set; }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await UnitOfWorkHelper.ExecAsync(uow => {
+                {
+                    var department = new Department();
+                    var employee = new Employee {
+                        Department = department
+                    };
+
+                    uow.Save(department);
+                    uow.Save(employee);
+
+                    uow.CommitChanges();
+                }
+                {
+                    var employees = uow.Query<Employee>();
+                    var department = uow.Query<Department>().First();
+
+                    var loadOptions = new SampleLoadOptions {
+                        Filter = new object[] {
+                            nameof(Employee.Department),
+                            department
+                        }
+                    };
+
+                    var exception = Record.Exception(() => DataSourceLoader.Load(employees, loadOptions));
+
+                    Assert.Null(exception);
+                }
+            });
+        }
+
+    }
+}

net/DevExtreme.AspNet.Data/DataSourceExpressionBuilder.cs

@@ -51,7 +51,7 @@ void AddFilter(IList filterOverride = null) {
             if(filterOverride != null || Context.HasFilter) {
                 var filterExpr = filterOverride != null && filterOverride.Count < 1
                     ? Expression.Lambda(Expression.Constant(false), Expression.Parameter(GetItemType()))
-                    : new FilterExpressionCompiler(GetItemType(), Context.GuardNulls, Context.UseStringToLower).Compile(filterOverride ?? Context.Filter);
+                    : new FilterExpressionCompiler(GetItemType(), Context.GuardNulls, Context.UseStringToLower, Context.SupportsEqualsMethod).Compile(filterOverride ?? Context.Filter);
 
                 Expr = QueryableCall(nameof(Queryable.Where), Expression.Quote(filterExpr));
             }

net/DevExtreme.AspNet.Data/DataSourceLoadContext.cs

@@ -76,6 +76,7 @@ partial class DataSourceLoadContext {
         public IList Filter => _options.Filter;
         public bool HasFilter => !IsEmptyList(_options.Filter);
         public bool UseStringToLower => _options.StringToLower ?? DataSourceLoadOptionsBase.StringToLowerDefault ?? _providerInfo.IsLinqToObjects;
+        public bool SupportsEqualsMethod => !_providerInfo.IsXPO;
     }
 
     // Grouping

net/DevExtreme.AspNet.Data/FilterExpressionCompiler.cs

@@ -19,9 +19,12 @@ const string
 
         bool _stringToLower;
 
-        public FilterExpressionCompiler(Type itemType, bool guardNulls, bool stringToLower = false)
+        readonly bool _supportsEqualsMethod;
+
+        public FilterExpressionCompiler(Type itemType, bool guardNulls, bool stringToLower = false, bool supportsEqualsMethod = true)
             : base(itemType, guardNulls) {
             _stringToLower = stringToLower;
+            _supportsEqualsMethod = supportsEqualsMethod;
         }
 
         public LambdaExpression Compile(IList criteriaJson) {
@@ -115,7 +118,7 @@ Expression CompileBinary(ParameterExpression dataItemExpr, IList criteriaJson) {
 
                 if(expressionType == ExpressionType.Equal || expressionType == ExpressionType.NotEqual) {
                     var type = Utils.StripNullableType(accessorExpr.Type);
-                    if(!HasEqualityOperator(type)) {
+                    if(_supportsEqualsMethod && !HasEqualityOperator(type)) {
                         if(type.IsValueType) {
                             accessorExpr = Expression.Convert(accessorExpr, typeof(Object));
                             valueExpr = Expression.Convert(valueExpr, typeof(Object));