private static ProcessingResult PerformUnaryOperation(UnaryExpression expression, List <NodeReference> references, DataContext context, Func <dynamic, dynamic> operationResolver) { var operandResult = ExpressionProcessingHelper.ProcessExpression(expression.Operand, references, context); if (!operandResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (operandResult.IsSingleItem) { var value = operandResult.GetLoadedItem(expression.Operand.Type); return(new ProcessingResult(true, operationResolver(value), true)); } var values = operandResult.GetLoadedItems(expression.Operand.Type); var resultList = new List <object>(); foreach (var value in values) { resultList.Add(operationResolver(value)); } return(new ProcessingResult(true, resultList)); }
protected ProcessingResult GetKeys(LambdaExpression keySelector, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { var keys = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(keySelector.ReturnType)); var compiledSelector = CompiledExpressionStorage.GetOrAddCompiledLambda(keySelector); foreach (var item in parentResult.GetItems()) { keys.Add(compiledSelector.DynamicInvoke(item)); } return(new ProcessingResult(true, keys)); } var nodeReferences = parentResult.GetDeferredList(); var keysResult = ExpressionProcessingHelper.ProcessExpression(keySelector.Body, nodeReferences, context); if (!keysResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (keysResult.IsSingleItem) { keysResult = ExpressionProcessingHelper.CopyInstances(keysResult, nodeReferences.Count, () => ExpressionProcessingHelper.ProcessExpression(keySelector.Body, nodeReferences, context).Result); } keysResult = new ProcessingResult(true, keysResult.GetLoadedItems(keySelector.ReturnType)); return(QueryProcessingHelper.NormalizeMultipleResult(keysResult, keySelector.ReturnType)); }
private static void EvaluateMemeberAssignment(EvaluatedMemberBinding result, MemberAssignment assignment, List <NodeReference> references, DataContext context) { var processingResult = ExpressionProcessingHelper.ProcessExpression(assignment.Expression, references, context); result.AddResult(LoadData(processingResult, assignment.Expression.Type)); }
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context) { var invocationExpression = expression as InvocationExpression; if (invocationExpression == null) { return(ProcessingResult.Unsuccessful); } var argumentsResults = CallProcessingHelper.ProcessArguments(invocationExpression.Arguments, references, context); if (!argumentsResults.All(r => r.IsSuccess)) { return(ProcessingResult.Unsuccessful); } var delegateResult = ExpressionProcessingHelper.ProcessExpression(invocationExpression.Expression, references, context); if (!delegateResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } return(CallProcessingHelper.ProcessCall(argumentsResults, delegateResult, (del, arguments) => { var delegateInstance = del as Delegate; return delegateInstance != null ? new ProcessingResult(true, delegateInstance.DynamicInvoke(arguments)) : ProcessingResult.Unsuccessful; })); }
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context) { var memberInitExpression = expression as MemberInitExpression; if (memberInitExpression == null) { return(ProcessingResult.Unsuccessful); } var instanceResult = ExpressionProcessingHelper.ProcessExpression(memberInitExpression.NewExpression, references, context); if (!instanceResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var evaluatedBindings = MemberBindingEvaluator.EvaluateBindings(memberInitExpression.Bindings.ToList(), references, context); if (evaluatedBindings.Any(b => !b.IsSuccess)) { return(ProcessingResult.Unsuccessful); } if (instanceResult.IsSingleItem && evaluatedBindings.Any(b => !b.IsSingle)) { instanceResult = ExpressionProcessingHelper.CopyInstances(instanceResult, references.Count, () => ExpressionProcessingHelper.ProcessExpression(memberInitExpression.NewExpression, references, context).Result); } return(MemberBindingProcessingHelper.ProcessBindings(evaluatedBindings, instanceResult)); }
private static ProcessingResult ProcessArrayIndexExpression(BinaryExpression expression, List <NodeReference> references, DataContext context) { var arrayResult = ExpressionProcessingHelper.ProcessExpression(expression.Left, references, context); if (!arrayResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var indexResult = ExpressionProcessingHelper.ProcessExpression(expression.Right, references, context); if (!indexResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var processingResult = IterateNodesItems(arrayResult, indexResult, ApplyArrayIndex); var resultData = processingResult.Result; if (!arrayResult.IsDeferred()) { return(new ProcessingResult(processingResult.IsSuccess, resultData, processingResult.IsSingleItem)); } var deferredList = processingResult.GetItems(); if (deferredList != null) { resultData = deferredList.Cast <NodeReference>().ToList(); } return(new ProcessingResult(processingResult.IsSuccess, resultData, processingResult.IsSingleItem)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { return(ProcessingResult.Unsuccessful); } var predicateResult = ExpressionProcessingHelper.ProcessPredicate(query.Arguments[1], parentResult.GetDeferredItems(), context); return(predicateResult.IsSuccess ? predicateResult : ProcessingResult.Unsuccessful); }
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context) { var memberExpression = expression as MemberExpression; if (memberExpression == null) { return(ProcessingResult.Unsuccessful); } //getting static member if (memberExpression.Expression == null) { var propertyInfo = memberExpression.Member as PropertyInfo; if (propertyInfo != null) { return(new ProcessingResult(true, propertyInfo.GetValue(null), true)); } var fieldInfo = memberExpression.Member as FieldInfo; if (fieldInfo != null) { return(new ProcessingResult(true, fieldInfo.GetValue(null), true)); } return(ProcessingResult.Unsuccessful); } var parentResult = ExpressionProcessingHelper.ProcessExpression(memberExpression.Expression, references, context); if (!parentResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (parentResult.IsSingleItem) { var item = parentResult.GetLoadedItem(memberExpression.Type); return(new ProcessingResult(true, ProcessLoadedEntityMember(item, memberExpression), true)); } var nodes = parentResult.GetDeferredItems(); if (nodes != null) { var columnAttribute = memberExpression.Member.GetCustomAttribute <ColumnAttribute>(); return(new ProcessingResult(true, ResolveColumn(columnAttribute, memberExpression, nodes))); } var values = parentResult.GetItems(); return(new ProcessingResult(true, ProcessLoadedEntityMembers(values, memberExpression))); }
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context) { var conditionalExpression = expression as ConditionalExpression; if (conditionalExpression == null) { return(ProcessingResult.Unsuccessful); } var testResult = ExpressionProcessingHelper.ProcessExpression(conditionalExpression.Test, references, context); if (!testResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (testResult.IsSingleItem) { var testValue = (bool)testResult.GetLoadedItem(typeof(bool)); var resultExpression = testValue ? conditionalExpression.IfTrue : conditionalExpression.IfFalse; return(ExpressionProcessingHelper.ProcessExpression(resultExpression, references, context)); } var resultValues = testResult.GetLoadedItems(typeof(bool)); var results = new List <object>(); var index = 0; foreach (var resultValue in resultValues) { var resultExpression = (bool)resultValue ? conditionalExpression.IfTrue : conditionalExpression.IfFalse; var processingResult = ExpressionProcessingHelper.ProcessExpression(resultExpression, new List <NodeReference>(1) { references[index] }, context); if (!processingResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } results.Add(ResolveValue(processingResult, resultExpression.Type)); index++; } return(new ProcessingResult(true, results)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { return(ProcessingResult.Unsuccessful); } var predicateExpression = query.Arguments[1]; var items = parentResult.GetItems(); var enumerator = items.GetEnumerator(); var resultList = new List <NodeReference>(); while (enumerator.MoveNext()) { var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicateExpression, new List <NodeReference>(1) { (NodeReference)enumerator.Current }, context); if (!predicateResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var predicateValue = ((IList <NodeReference>)predicateResult.Result).Any(); if (predicateValue) { ConditionTrueCallback(resultList, enumerator.Current); continue; } ConditionFalseCallback(resultList, enumerator.Current); break; } while (enumerator.MoveNext()) { ConditionFalseCallback(resultList, enumerator.Current); } return(new ProcessingResult(true, resultList)); }
private static void EvaluateListBinding(EvaluatedMemberBinding result, MemberListBinding listBinding, List <NodeReference> references, DataContext context) { foreach (var initializer in listBinding.Initializers) { var processingResults = initializer.Arguments .Select(a => LoadData(ExpressionProcessingHelper.ProcessExpression(a, references, context), a.Type)) .ToList(); if (processingResults.Any(r => !r.IsSuccess)) { result.MarkUnsuccessful(); return; } result.AddInitializer(initializer.AddMethod, processingResults); } }
private static ProcessingResult ProcessObjectExpression(Expression objectExpression, List <NodeReference> references, DataContext context) { if (objectExpression == null) { return(new ProcessingResult(true, null, true)); } var objectResult = ExpressionProcessingHelper.ProcessExpression(objectExpression, references, context); if (!objectResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var value = objectResult.IsSingleItem ? objectResult.GetLoadedItem(objectExpression.Type) : objectResult.GetLoadedItems(objectExpression.Type); return(new ProcessingResult(true, value, objectResult.IsSingleItem)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var hasPredicate = query.Arguments.Count == 2; if (!hasPredicate) { return(ProcessQuery(parentResult.GetItems().GetEnumerator(), QueryProcessingHelper.GetReturnParameterType(query))); } if (!parentResult.IsDeferred()) { return(ProcessingResult.Unsuccessful); } var predicate = query.Arguments[1]; var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicate, parentResult.GetDeferredItems(), context); return(predicateResult.IsSuccess ? ProcessQuery(predicateResult.GetItems().GetEnumerator(), QueryProcessingHelper.GetReturnParameterType(query)) : ProcessingResult.Unsuccessful); }
private static List <EvaluatedListInitializer> EvaluateInitializers(IEnumerable <ElementInit> initializers, List <NodeReference> references, DataContext context) { var result = new List <EvaluatedListInitializer>(); foreach (var initializer in initializers) { var processingResults = initializer.Arguments .Select(a => LoadData(ExpressionProcessingHelper.ProcessExpression(a, references, context), a.Type)) .ToList(); result.Add(new EvaluatedListInitializer(initializer.AddMethod, processingResults)); if (processingResults.Any(r => !r.IsSuccess)) { break; } } return(result); }
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context) { var typeBinaryExpression = expression as TypeBinaryExpression; if (typeBinaryExpression == null) { return(ProcessingResult.Unsuccessful); } var result = ExpressionProcessingHelper.ProcessExpression(typeBinaryExpression.Expression, references, context); if (!result.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (result.IsSingleItem) { var objectType = result.GetLoadedItem(typeBinaryExpression.Expression.Type).GetType(); return(new ProcessingResult(true, TypeIs(objectType, typeBinaryExpression.TypeOperand), true)); } if (result.IsDeferred()) { var objectType = typeBinaryExpression.Expression.Type; var typeIsResult = TypeIs(objectType, typeBinaryExpression.TypeOperand); return(new ProcessingResult(true, Enumerable.Repeat(typeIsResult, references.Count).ToList())); } var resultList = new List <bool>(); var loadedItems = result.GetLoadedItems(typeBinaryExpression.Expression.Type); foreach (var loadedItem in loadedItems) { resultList.Add(TypeIs(loadedItem.GetType(), typeBinaryExpression.TypeOperand)); } return(new ProcessingResult(true, resultList)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { return(ProcessingResult.Unsuccessful); } var predicate = query.Arguments[1]; var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicate, parentResult.GetDeferredItems(), context); if (!predicateResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var parentResultCount = parentResult.GetDeferredItems().Count(); var predicateResultCount = predicateResult.GetDeferredItems().Count(); var result = (parentResultCount == predicateResultCount); return(new ProcessingResult(true, result, true)); }
private static ProcessingResult ProcessExpressionByDefault(BinaryExpression expression, List <NodeReference> references, DataContext context) { var leftResult = ExpressionProcessingHelper.ProcessExpression(expression.Left, references, context); if (!leftResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var rightResult = ExpressionProcessingHelper.ProcessExpression(expression.Right, references, context); if (!rightResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var leftDataType = expression.Left.Type; var rightDataType = expression.Right.Type; return(IterateNodesItems(leftResult, rightResult, (left, right) => PerformBinaryOperation(left, leftDataType, right, rightDataType, expression.NodeType))); }
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context) { var listInitExpression = expression as ListInitExpression; if (listInitExpression == null) { return(ProcessingResult.Unsuccessful); } var instanceResult = ExpressionProcessingHelper.ProcessExpression(listInitExpression.NewExpression, references, context); if (instanceResult == null) { return(ProcessingResult.Unsuccessful); } var evaluatedInitializers = EvaluateInitializers(listInitExpression.Initializers, references, context); var isSuccess = evaluatedInitializers.All(i => i.Arguments.All(a => a.IsSuccess)); if (!isSuccess) { return(ProcessingResult.Unsuccessful); } var isSingleInitializers = evaluatedInitializers.All(i => i.Arguments.All(a => a.IsSingleItem)); if (instanceResult.IsSingleItem && !isSingleInitializers) { instanceResult = ExpressionProcessingHelper.CopyInstances(instanceResult, references.Count, () => ExpressionProcessingHelper.ProcessExpression(listInitExpression.NewExpression, references, context).Result); } instanceResult = evaluatedInitializers.Aggregate(instanceResult, (current, initializer) => MemberBindingProcessingHelper.ProcessListInitializer(initializer, current)); return(instanceResult); }
private static ProcessingResult PerformShortCircuitingOperation(bool left, Expression rightExpression, NodeReference reference, ExpressionType operationType, DataContext context) { if ((operationType == ExpressionType.AndAlso) && (!left)) { return(new ProcessingResult(true, false, true)); } if ((operationType == ExpressionType.OrElse) && (left)) { return(new ProcessingResult(true, true, true)); } var rightResult = ExpressionProcessingHelper.ProcessExpression(rightExpression, new List <NodeReference>(1) { reference }, context); if (!rightResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (rightResult.IsSingleItem) { return(new ProcessingResult(true, (bool)rightResult.Result, true)); } var rightValues = rightResult.GetLoadedItems(typeof(bool)); foreach (var rightValue in rightValues) { return(new ProcessingResult(true, (bool)rightValue, true)); } return(ProcessingResult.Unsuccessful); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { return(ProcessingResult.Unsuccessful); } var unaryExpression = (UnaryExpression)query.Arguments[1]; var lambdaExpression = (LambdaExpression)unaryExpression.Operand; if (lambdaExpression.Parameters.Count > 1) { return(ProcessingResult.Unsuccessful); } var memberExpression = lambdaExpression.Body; var nodeReferences = parentResult.GetDeferredList(); var result = ExpressionProcessingHelper.ProcessExpression(memberExpression, nodeReferences, context); if (!result.IsSuccess) { return(ProcessingResult.Unsuccessful); } var targetItemType = QueryProcessingHelper.GetReturnParameterType(query); if (!result.IsSingleItem) { return(QueryProcessingHelper.NormalizeMultipleResult(result, targetItemType)); } var multipleResult = ExpressionProcessingHelper.CopyInstances(result, nodeReferences.Count, () => ExpressionProcessingHelper.ProcessExpression(memberExpression, nodeReferences, context).Result); return(new ProcessingResult(true, QueryProcessingHelper.NormalizeMultipleResult(multipleResult, targetItemType).Result)); }
private static ProcessingResult ProcessShortCircuitingExpression(BinaryExpression expression, List <NodeReference> references, ExpressionType operationType, DataContext context) { if (!(expression.Left.Type == typeof(bool) && expression.Right.Type == typeof(bool))) { return(ProcessExpressionByDefault(expression, references, context)); } var leftResult = ExpressionProcessingHelper.ProcessExpression(expression.Left, references, context); if (!leftResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } var operationResult = IterateNodesItems(leftResult, new ProcessingResult(true, references), (left, right) => PerformShortCircuitingOperation((bool)left, expression.Right, (NodeReference)right, operationType, context)); var resultList = new List <object>(); if (operationResult.IsSingleItem) { return(new ProcessingResult(true, (bool)operationResult.Result, true)); } foreach (ProcessingResult item in operationResult.GetItems()) { if (!item.IsSuccess) { return(ProcessingResult.Unsuccessful); } resultList.Add((bool)item.Result); } return(new ProcessingResult(true, resultList)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { return(ProcessingResult.Unsuccessful); } var hasSelector = query.Arguments.Count > 1; var elementType = QueryProcessingHelper.GetReturnParameterType(query); if (!hasSelector) { var items = parentResult.GetLoadedItems(elementType); return(new ProcessingResult(true, ProcessQuery(items), true)); } var unaryExpression = (UnaryExpression)query.Arguments[1]; var selectorLambda = (LambdaExpression)unaryExpression.Operand; var selectorResult = ExpressionProcessingHelper.ProcessExpression(selectorLambda.Body, parentResult.GetDeferredList(), context); if (!selectorResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (selectorResult.IsSingleItem) { var result = Convert.ChangeType(selectorResult.Result, elementType); return(new ProcessingResult(true, result, true)); } var loadedItems = selectorResult.GetLoadedItems(elementType); return(new ProcessingResult(true, ProcessQuery(loadedItems), true)); }
private static ProcessingResult ProcessArrayLengthExpression(UnaryExpression expression, List <NodeReference> references, DataContext context) { var parentResult = ExpressionProcessingHelper.ProcessExpression(expression.Operand, references, context); if (!parentResult.IsSuccess) { return(ProcessingResult.Unsuccessful); } if (parentResult.IsSingleItem) { var deferredResult = parentResult.GetDeferredItem(); return(deferredResult != null ? new ProcessingResult(true, DatabaseManager.GetEnumerableCount(deferredResult), true) : new ProcessingResult(true, ((Array)parentResult.Result).Length, true)); } var deferredItems = parentResult.GetDeferredItems(); if (deferredItems != null) { var resultList = deferredItems.Select(DatabaseManager.GetEnumerableCount).ToList(); return(new ProcessingResult(true, resultList)); } var resultItems = parentResult.GetItems(); var result = new List <object>(); foreach (var resultItem in resultItems) { var array = (Array)resultItem; result.Add(array.Length); } return(new ProcessingResult(true, result)); }