c#中匿名函数lamb表达式

c#中匿名函数lamb表达式

实例一：（其实，这样都是些语法糖）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    //c#中的匿名函数
    //申明一委托
    delegate void Del();
    class Program
    {

        static void show()
        {
            Console.WriteLine("show ......");
        }

        static void Test()
        {
            Del d = new Del(show);
            d();
        }
        static void Test2()
        {
            //你可以这么写....
            Del d = delegate()
            {
                Console.WriteLine("show......");
            };
            d();

            //你也可以这么写
            Del d1 = delegate
            {
                Console.WriteLine("show.....");
            };

            d1();
            //你还可以这么写;这就是lamb表达式；
            Del d2 = () =>
            {
                Console.WriteLine("show.....");
            };
            d2();

        }
        static void Main(string[] args)
        {

            Test2();
            Console.ReadLine();

        }
    }
}

有参数的lamb表达式:

 static void Test()
        {
            //你可以这么写
            Dele d = delegate(int j)
            {
                Console.WriteLine(j);
            };
            d();

            Dele d1 = (j) => { Console.WriteLine(j); };
            d1();
            //这个就是有参参的lamb表达式；
        }

        static void Main(string[] args)
        {
            Test();
            Console.ReadLine();

        }

顺便提一下c#中的Action Func Predicate；

Delegate至少0个参数，至多32个参数，可以无返回值，也可以指定返回值类型。

Action是无返回值的泛型委托。

Action 表示无参，无返回值的委托

Action<int,string> 表示有传入参数int,string无返回值的委托

Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托

Action<int,int,int,int> 表示有传入4个int型参数，无返回值的委托

Action至少0个参数，至多16个参数，无返回值。

Func是有返回值的泛型委托

　　 Func<int> 表示无参，返回值为int的委托

　　 Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

　　 Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

　　 Func<T1,T2,,T3,int> 表示传入参数为T1,T2,,T3(泛型)返回值为int的委托

　　 Func至少0个参数，至多16个参数，根据返回值泛型返回。必须有返回值，不可void

 (4) predicate

　　 predicate 是返回bool型的泛型委托

　　 predicate<int> 表示传入参数为int 返回bool的委托

　　 Predicate有且只有一个参数，返回值固定为bool

实例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication2
{

    delegate void Dele(int i);
    class Program
    {
        static void add(int i,int j)
        {
            Console.WriteLine(i+j);
        }
        static int sub(int i, int j)
        {
            return i - j;
        }

        static bool  isTrue(int i)
        {
            if (i > )
                return true;
            else
                return false;
        }

        static void Test()
        {

            List<Action<int,int>> list = new List<Action<int,int>>();
            list.Add(add);
            //调用方式一
            list[](,);
            //最后一个参数是返回值；
            Func<int,int,int> func=sub;
            int result=func(,);
            Console.WriteLine(result);

            Predicate<int> p = isTrue;
            bool re = p();
            Console.WriteLine(re);

        }
        static void Test2()
        {
            //当然我们可以换一种方式写滴呀
            Action<int, int> action = delegate(int i, int j)
            {
                Console.WriteLine(i+j);
            };
            action(,);

            Func<int, int, int> func = delegate(int i, int j)
            {
                return i - j;
            };
            int result = func(,);

            Predicate<int> pre = delegate(int i)
            {
                bool re=
                i==?true: false;
                return re;
            };

        }
        static void Test3()
        {
            //当然我们也可以这样写滴呀
            Action<int, int> action = (i, j) => { Console.WriteLine(i + j); };
            action(,);

            Func<int,int,int> func=(i,j)=>{return i-j;};
            int result=func(,);

            Predicate<int> pre = (i) => { if (i == )return true; else return false; };
            bool val = pre();

        }

        static void Test4()
        {
            Thread thread = new Thread(delegate()
            {
                Console.WriteLine("hahhahah....");
            });
            thread.Start();

            Thread thread2 = new Thread(() =>
            {
                Console.WriteLine("hahah......");
            });
            thread2.Start();

        }

        static void Main(string[] args)
        {
            //其实，就相当于这样滴呀:   public delegate void Action<T>(T arg);
            Test();
            Console.ReadLine();

        }
    }
}