コード例 #1
0
    public override void SetUp ()
    {
      base.SetUp ();

      var selector = ExpressionHelper.CreateLambdaExpression<int, bool> (i => i > 5);
      _node = new SelectExpressionNode (CreateParseInfo (), selector);
    }
コード例 #2
0
        protected ResultOperatorExpressionNodeBase(
            MethodCallExpressionParseInfo parseInfo, LambdaExpression optionalPredicate, LambdaExpression optionalSelector)
            : base(parseInfo)
        {
            if (optionalPredicate != null && optionalPredicate.Parameters.Count != 1)
            {
                throw new ArgumentException("OptionalPredicate must have exactly one parameter.", "optionalPredicate");
            }

            if (optionalSelector != null && optionalSelector.Parameters.Count != 1)
            {
                throw new ArgumentException("OptionalSelector must have exactly one parameter.", "optionalSelector");
            }

            if (optionalPredicate != null)
            {
                Source = new WhereExpressionNode(parseInfo, optionalPredicate);
            }

            if (optionalSelector != null)
            {
                var newParseInfo = new MethodCallExpressionParseInfo(parseInfo.AssociatedIdentifier, Source, parseInfo.ParsedExpression);
                Source = new SelectExpressionNode(newParseInfo, optionalSelector);
            }

            ParsedExpression = parseInfo.ParsedExpression;
        }
コード例 #3
0
    public void GetResolvedSelector ()
    {
      var selector = ExpressionHelper.CreateLambdaExpression<int, bool> (i => i > 5);
      var node = new SelectExpressionNode (CreateParseInfo (), selector);

      var expectedResult = Expression.MakeBinary (ExpressionType.GreaterThan, SourceReference, Expression.Constant (5));

      var result = node.GetResolvedSelector(ClauseGenerationContext);

      ExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
    }
コード例 #4
0
    public void Resolve_ReplacesParameter_WithProjection ()
    {
      var node = new SelectExpressionNode (CreateParseInfo (), ExpressionHelper.CreateLambdaExpression<int, int> (j => j * j));
      var expression = ExpressionHelper.CreateLambdaExpression<int, bool> (i => i > 5);

      var result = node.Resolve (expression.Parameters[0], expression.Body, ClauseGenerationContext);

      var expectedResult = Expression.MakeBinary (
          ExpressionType.GreaterThan,
          Expression.MakeBinary (ExpressionType.Multiply, SourceReference, SourceReference),
          Expression.Constant (5));
      ExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
    }
コード例 #5
0
        public GroupByWithResultSelectorExpressionNode(
            MethodCallExpressionParseInfo parseInfo,
            LambdaExpression keySelector,
            LambdaExpression elementSelectorOrResultSelector,
            LambdaExpression resultSelectorOrNull)
        {
            ArgumentUtility.CheckNotNull("keySelector", keySelector);
            ArgumentUtility.CheckNotNull("elementSelectorOrResultSelector", elementSelectorOrResultSelector);

            _selectExpressionNode = new SelectExpressionNode(
                CreateParseInfoWithGroupNode(parseInfo, keySelector, elementSelectorOrResultSelector, resultSelectorOrNull),
                CreateSelectorForSelectNode(keySelector, elementSelectorOrResultSelector, resultSelectorOrNull));
        }
コード例 #6
0
    public GroupByWithResultSelectorExpressionNode (
        MethodCallExpressionParseInfo parseInfo, 
        LambdaExpression keySelector, 
        LambdaExpression elementSelectorOrResultSelector, 
        LambdaExpression resultSelectorOrNull)
    {
      ArgumentUtility.CheckNotNull ("keySelector", keySelector);
      ArgumentUtility.CheckNotNull ("elementSelectorOrResultSelector", elementSelectorOrResultSelector);

      _selectExpressionNode = new SelectExpressionNode (
          CreateParseInfoWithGroupNode (parseInfo, keySelector, elementSelectorOrResultSelector, resultSelectorOrNull),
          CreateSelectorForSelectNode (keySelector, elementSelectorOrResultSelector, resultSelectorOrNull));
    }
コード例 #7
0
    private static MethodCallExpressionParseInfo TransformParseInfo (
        MethodCallExpressionParseInfo parseInfo,
        LambdaExpression optionalPredicate,
        LambdaExpression optionalSelector)
    {
      var source = parseInfo.Source;

      if (optionalPredicate != null)
        source = new WhereExpressionNode (parseInfo, optionalPredicate);

      if (optionalSelector != null)
      {
        var newParseInfo = new MethodCallExpressionParseInfo (parseInfo.AssociatedIdentifier, source, parseInfo.ParsedExpression);
        source = new SelectExpressionNode (newParseInfo, optionalSelector);
      }

      return new MethodCallExpressionParseInfo (parseInfo.AssociatedIdentifier, source, parseInfo.ParsedExpression);
    }
コード例 #8
0
        private static MethodCallExpressionParseInfo TransformParseInfo(
            MethodCallExpressionParseInfo parseInfo,
            LambdaExpression optionalPredicate,
            LambdaExpression optionalSelector)
        {
            var source = parseInfo.Source;

            if (optionalPredicate != null)
            {
                source = new WhereExpressionNode(parseInfo, optionalPredicate);
            }

            if (optionalSelector != null)
            {
                var newParseInfo = new MethodCallExpressionParseInfo(parseInfo.AssociatedIdentifier, source, parseInfo.ParsedExpression);
                source = new SelectExpressionNode(newParseInfo, optionalSelector);
            }

            return(new MethodCallExpressionParseInfo(parseInfo.AssociatedIdentifier, source, parseInfo.ParsedExpression));
        }
コード例 #9
0
        protected ResultOperatorExpressionNodeBase(
        MethodCallExpressionParseInfo parseInfo, LambdaExpression optionalPredicate, LambdaExpression optionalSelector)
            : base(parseInfo)
        {
            if (optionalPredicate != null && optionalPredicate.Parameters.Count != 1)
            throw new ArgumentException ("OptionalPredicate must have exactly one parameter.", "optionalPredicate");

              if (optionalSelector != null && optionalSelector.Parameters.Count != 1)
            throw new ArgumentException ("OptionalSelector must have exactly one parameter.", "optionalSelector");

              if (optionalPredicate != null)
            Source = new WhereExpressionNode (parseInfo, optionalPredicate);

              if (optionalSelector != null)
              {
            var newParseInfo = new MethodCallExpressionParseInfo (parseInfo.AssociatedIdentifier, Source, parseInfo.ParsedExpression);
            Source = new SelectExpressionNode (newParseInfo, optionalSelector);
              }

              ParsedExpression = parseInfo.ParsedExpression;
        }