lambda表达式

            #region
            //一个SQL TO LINQ 的CONTEXT对像
            MYDCSDataContext myContext = new MYDCSDataContext();
            //正常的LINQ语法，找出部门ID为1的部门信息
            var dept = (from d in myContext.Departments where d.DepartmentId == 1 select d).First();
            //定义一个泛型委托(输入一个参数--Employee,返回bool),给他的是一个Lambda表达式(其实就是一个匿名方法)
            //=>左边是方法的输入参数，右边是方法的返回值
            Func<Employee, bool> fdelegate = p => p.EmployeeId == 1;
            //这里可以看到ORM的好处之一：员工和部门之间建立关系后，通过部门可以直接取到该部门下所有员工
            var emps = dept.Employees;
            //根据上面的泛型委托来找出符合条件的员工
            var emp = emps.First(fdelegate);
            #endregion  
       
            #region
            var nimingtype = dept.Employees.Where(p => p.EmployeeId == 1).Select(p => new     {p.EmployeeId,p.EmployeeNO,p.EmployeeName});
            var istrue = dept.Employees.Select(p => p.EmployeeId == 2);
            #endregion

 

            #region
            Expression<Func<int, bool>> exprTree = num => num < 5;
            ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];
            BinaryExpression operation = (BinaryExpression)exprTree.Body;
            ParameterExpression left = (ParameterExpression)operation.Left;
            ConstantExpression right = (ConstantExpression)operation.Right;
            Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
                              param.Name, left.Name, operation.NodeType, right.Value);
            #endregion

 

            var actionAssembly = System.Reflection.Assembly.GetExecutingAssembly();
            var MyClass = actionAssembly.GetType("MyClass");
            var newexpression = System.Linq.Expressions.Expression.New(MyClass);
            LambdaExpression.Lambda(newexpression).Compile();
            //Activator.CreateInstance(MyClass);

 

            #region

            //这里主要体现Func委托与Action委托的区别

            //其中Func参数数量在0-5之间，必须要有一个返回值，Action参数个数同Func，但它可以没有返回值
            Func<int, int, int> myexprx = (int i, int j) =>
            {
                i++;
                return (i + j);
            };   
            Func<bool> myexpr = () => 3 < 4;
            Action newaction = () => Console.Write("这里是ACTION的定义");
            newaction();
            Action xx = () => new contact().prinf();
            #endregion

 

            #region
            var parameteri = Expression.Parameter(typeof(int), "i");
            var parameterj = Expression.Parameter(typeof(int), "j");
            var expressionBir = Expression.Subtract(parameteri, parameterj);
            var expr = Expression.Lambda<Func<int, int, int>>(expressionBir, parameteri, parameterj);
            var mydelegate = expr.Compile();
            var result = mydelegate(5, 6);
            #endregion    
     
            #region
            LambdaExpression.Parameter(typeof(int), "x");
            LambdaExpression.Parameter(typeof(int), "y");
            var mye = LambdaExpression.LessThan(parameteri, parameterj);
            LambdaExpression lam = LambdaExpression.Lambda(mye, parameteri, parameterj);

            var str0 = lam.Body.ToString();
            var stroperator = lam.Body.NodeType.ToString();
            var str1 = lam.Parameters[0].ToString();
            var str2 = lam.Parameters[1].ToString();
           
            var autodelegate = lam.Compile();
            #endregion