Ejemplo n.º 1
0
        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('.');
            var currentTarget   = target;

            for (var i = 0; i < clientExprItems.Length; i++)
            {
                var clientExprItem = clientExprItems[i];

                if (i == 0 && clientExprItem == "this")
                {
                    continue;
                }

                if (Utils.IsNullable(currentTarget.Type))
                {
                    clientExprItem = "Value";
                    i--;
                }

                if (currentTarget.Type == typeof(ExpandoObject))
                {
                    currentTarget = ReadExpando(currentTarget, clientExprItem);
                }
                //denglf
                //else if(DynamicBindingHelper.ShouldUseDynamicBinding(currentTarget.Type))
                //    currentTarget = DynamicBindingHelper.CompileGetMember(currentTarget, clientExprItem);
                else
                {
                    currentTarget = FixReflectedType(Expression.PropertyOrField(currentTarget, clientExprItem));
                }

                progression.Add(currentTarget);
            }

            customizeProgression?.Invoke(progression);

            if (_guardNulls && progression.Count > 1 || liftToNullable && progression.Count > 2)
            {
                var lastIndex = progression.Count - 1;
                var last      = progression[lastIndex];
                if (Utils.CanAssignNull(target.Type) && !Utils.CanAssignNull(last.Type))
                {
                    progression[lastIndex] = Expression.Convert(last, Utils.MakeNullable(last.Type));
                }
            }

            return(CompileNullGuard(progression));
        }
Ejemplo n.º 2
0
        public async Task Scenario()
        {
            try {
                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();

                await UnitOfWorkHelper.ExecAsync(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]);
                });
            } finally {
                CustomAccessorCompilers.Clear();
            }
        }
 public static void Run(Action action)
 {
     lock (SYNC) {
         try {
             action();
         } finally {
             CustomAggregators.Clear();
             CustomAccessorCompilers.Clear();
         }
     }
 }
Ejemplo n.º 4
0
 public static void Run(Action action)
 {
     lock (SYNC) {
         try {
             action();
         } finally {
             CustomAggregators.Clear();
             CustomAccessorCompilers.Clear();
             DataSourceLoadOptionsBase.StringToLowerDefault = null;
         }
     }
 }