Implement a hook to intercept CompileAccessorExpression (#273)

Author: AlekseyMartynov

…t.Data.Tests/CustomAggregatorsBarrier.cs …spNet.Data.Tests.Common/StaticBarrier.csnet/DevExtreme.AspNet.Data.Tests/CustomAggregatorsBarrier.cs renamed to net/DevExtreme.AspNet.Data.Tests.Common/StaticBarrier.cs net/DevExtreme.AspNet.Data.Tests/CustomAggregatorsBarrier.cs renamed to net/DevExtreme.AspNet.Data.Tests.Common/StaticBarrier.cs

@@ -1,10 +1,11 @@
 using DevExtreme.AspNet.Data.Aggregation;
+using DevExtreme.AspNet.Data.Helpers;
 using System;
 using System.Linq;
 
 namespace DevExtreme.AspNet.Data.Tests {
 
-    static class CustomAggregatorsBarrier {
+    public class StaticBarrier {
         static readonly object SYNC = new object();
 
         public static void Run(Action action) {
@@ -13,6 +14,7 @@ public static void Run(Action action) {
                     action();
                 } finally {
                     CustomAggregators.Clear();
+                    CustomAccessorCompilers.Clear();
                 }
             }
 

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

@@ -0,0 +1,92 @@
+using DevExpress.Xpo;
+using DevExtreme.AspNet.Data.Helpers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.Xpo {
+
+    public class XafDomainComponents {
+
+        public abstract class DCBaseObject : XPCustomObject {
+            public DCBaseObject(Session session)
+                : base(session) {
+            }
+
+            [Key]
+            public Guid Oid { get; set; }
+        }
+
+        interface IMyComponent {
+            int Value { get; set; }
+        }
+
+        [Persistent(nameof(XafDomainComponents) + "_" + nameof(MyComponentImpl))]
+        public class MyComponentImpl : DCBaseObject, IMyComponent {
+
+            public MyComponentImpl(Session session)
+                : base(session) {
+            }
+
+            public int Value { get; set; }
+        }
+
+        const string
+            OID = "Oid",
+            LOCK_FILED = "OptimisticLockFieldInDataLayer";
+
+        [Fact]
+        public void Scenario() {
+            StaticBarrier.Run(delegate {
+                CustomAccessorCompilers.Register((target, accessorText) => {
+                    if(accessorText == OID) {
+                        return Expression.Property(
+                            Expression.Convert(target, typeof(DCBaseObject)),
+                            OID
+                        );
+                    }
+
+                    if(accessorText == LOCK_FILED) {
+                        return Expression.Call(
+                            Expression.Convert(target, typeof(PersistentBase)),
+                            "GetPropertyValue",
+                            null,
+                            Expression.Constant(LOCK_FILED)
+                        );
+                    }
+
+                    return null;
+                });
+
+                var key = Guid.NewGuid();
+
+                UnitOfWorkHelper.Exec(uow => {
+                    uow.Save(new MyComponentImpl(uow) {
+                        Oid = key,
+                        Value = 123
+                    });
+
+                    uow.CommitChanges();
+
+                    IQueryable<IMyComponent> interfaceQuery = uow.Query<MyComponentImpl>();
+
+                    var loadResult = DataSourceLoader.Load(interfaceQuery, new SampleLoadOptions {
+                        PrimaryKey = new[] { OID },
+                        RemoteSelect = false,
+                        PreSelect = new[] { OID, "Value", LOCK_FILED }
+                    });
+
+                    var item = loadResult.data.Cast<IDictionary<string, object>>().First();
+
+                    Assert.Equal(key, item[OID]);
+                    Assert.Equal(123, item["Value"]);
+                    Assert.Equal(0, item[LOCK_FILED]);
+                });
+            });
+        }
+
+    }
+
+}

net/DevExtreme.AspNet.Data.Tests/AggregateCalculatorTests.cs

@@ -281,7 +281,7 @@ class SumFixItem {
 
         [Fact]
         public void CustomAggregator() {
-            CustomAggregatorsBarrier.Run(delegate {
+            StaticBarrier.Run(delegate {
                 CustomAggregators.RegisterAggregator("comma", typeof(CommaAggregator<>));
 
                 var data = new[] {

net/DevExtreme.AspNet.Data.Tests/CustomAggregatorsTests.cs

@@ -8,14 +8,14 @@ public class CustomAggregatorsTests {
 
         [Fact]
         public void ShouldNotReturnUnexistingAggregator() {
-            CustomAggregatorsBarrier.Run(delegate {
+            StaticBarrier.Run(delegate {
                 Assert.Null(CustomAggregators.CreateAggregator("custom", new DefaultAccessor<int>()));
             });
         }
 
         [Fact]
         public void ShouldCreateRegisteredAggregator() {
-            CustomAggregatorsBarrier.Run(delegate {
+            StaticBarrier.Run(delegate {
                 CustomAggregators.RegisterAggregator(AggregateName.SUM, typeof(SumAggregator<>));
                 var aggregator = CustomAggregators.CreateAggregator(AggregateName.SUM, new DefaultAccessor<int>());
                 Assert.NotNull(aggregator);
@@ -25,7 +25,7 @@ public void ShouldCreateRegisteredAggregator() {
 
         [Fact]
         public void ShouldSupportMultipleAggregatorRegistrations() {
-            CustomAggregatorsBarrier.Run(delegate {
+            StaticBarrier.Run(delegate {
                 CustomAggregators.RegisterAggregator("any", typeof(SumAggregator<>));
                 CustomAggregators.RegisterAggregator("any", typeof(MinAggregator<>));
                 var aggregator = CustomAggregators.CreateAggregator("any", new DefaultAccessor<int>());

net/DevExtreme.AspNet.Data/ExpressionCompiler.cs

@@ -1,4 +1,5 @@
-using System;
+using DevExtreme.AspNet.Data.Helpers;
+using System;
 using System.Collections.Generic;
 using System.Dynamic;
 using System.Linq;
@@ -20,6 +21,10 @@ protected bool GuardNulls {
         }
 
         protected internal Expression CompileAccessorExpression(Expression target, string clientExpr, Action<List<Expression>> customizeProgression = null, bool liftToNullable = false) {
+            var customResult = CustomAccessorCompilers.TryCompile(target, clientExpr);
+            if(customResult != null)
+                return customResult;
+
             var progression = new List<Expression> { target };
 
             var clientExprItems = clientExpr.Split('.');

net/DevExtreme.AspNet.Data/Helpers/CustomAccessorCompilers.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace DevExtreme.AspNet.Data.Helpers {
+
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static class CustomAccessorCompilers {
+        public delegate Expression CompilerFunc(Expression target, string accessorText);
+
+        static readonly ICollection<CompilerFunc> _compilers = new List<CompilerFunc>();
+
+        public static void Register(CompilerFunc compilerFunc) {
+            _compilers.Add(compilerFunc);
+        }
+
+        public static Expression TryCompile(Expression target, string accessorText) {
+            if(_compilers.Count < 1)
+                return null;
+
+            foreach(var compiler in _compilers) {
+                var result = compiler(target, accessorText);
+                if(result != null)
+                    return result;
+            }
+
+            return null;
+        }
+
+#if DEBUG
+        internal static void Clear() {
+            _compilers.Clear();
+        }
+#endif
+
+    }
+
+}

net/docfx/filterConfig.yml

@@ -1,6 +1,8 @@
 apiRules:
 - exclude:
     uidRegex: ^DevExtreme\.AspNet\.Data\.Helpers\.Compat$
+- exclude:
+    uidRegex: ^DevExtreme\.AspNet\.Data\.Helpers\.CustomAccessorCompilers(\.|$)
 - exclude:
     uidRegex: ^DevExtreme\.AspNet\.Data\.DataSourceLoadOptionsBase\.(Pre|Remote)Select$
 - exclude: