Expression 学习 [1]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Collections;

namespace ConsoleApp
{
    /// <summary>
    ///  By Rhythmk  Expression 学习
    ///  参考：http://rednaxelafx.iteye.com/blog/247270
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Constant();
            Method1();
            int[] array = new int[] { 12, 12, 35, 5, 3, 4, 4, 35, 3, 4, 3, 0 };
            // Lambda 
            DefaultExpress(array);
            // 通过表达树创建
            CreateExpress(array);

            Console.Read();
        }


        static void DefaultExpress(int[] _array)
        {
            Expression<Func<int[], int>> exp = array => (array != null && array.Length > 0) ? 2 * (array[0] + 5) : -1;
            var expCompile = exp.Compile();
            Console.Write(expCompile(_array));
        }

        static void CreateExpress(int[] _array)
        {
            ParameterExpression parameterExp = Expression.Parameter(typeof(int[]), "array");
            Expression<Func<int[], int>> exp = Expression.Lambda<Func<int[], int>>(
                            Expression.Condition(
                               Expression.AndAlso(
                                  Expression.NotEqual(
                                  parameterExp,
                                  Expression.Constant(null)
                                  ),
                                  Expression.GreaterThan(
                                    Expression.ArrayLength(parameterExp),
                                    Expression.Constant(0, typeof(int))
                                  )
                             ),
                            Expression.Multiply(
                                  Expression.Constant(2, typeof(int)),
                                  Expression.Add(
                                                 Expression.Constant(5, typeof(int)),
                                                 Expression.ArrayIndex(
                                                     parameterExp,
                                                     Expression.Constant(0, typeof(int)))
                                                )
                            ),
                            Expression.Constant(-1, typeof(int))
                ), new ParameterExpression[] { parameterExp });
            var result = exp.Compile();
            Console.Write(result(_array));
        }

        static void Constant()
        {
            Expression<Func<int>> exp = Expression.Lambda<Func<int>>(
                Expression.Constant(
                   1,
                   typeof(int)
                ),
                new ParameterExpression[] { }
              );
            var q = exp.Compile();
            Console.Write("Result:"+q());

        }


        #region
        static void Method1()
        {
            ParameterExpression _param=Expression.Parameter(typeof(int),"a");
            Expression<Func<int,int>> exp=Expression.Lambda<Func<int,int>>(
   
                 Expression.Add(_param,
                                Expression.Constant(2,typeof(int))
                  ),
                  new ParameterExpression[] { _param }
            );

            var q = exp.Compile();
            Console.Write("Result:"+ q(12)); //  Result : 14

            ConstantExpression exp1 = Expression.Constant(2, typeof(int));
            BinaryExpression binaryExp= Expression.Add(exp1, _param);
            Expression<Func<int, int>> exp2 = Expression.Lambda<Func<int, int>>(binaryExp,_param);
            var q2=exp2.Compile();
            Console.Write("Result:"+q2(12)); // Result : 14
        }
        #endregion

    }
}