码迷,mamicode.com
首页 > 其他好文 > 详细

C#委托

时间:2014-06-25 18:37:01      阅读:217      评论:0      收藏:0      [点我收藏+]

标签:class   blog   code   http   tar   ext   

委托的定义与方法的定义类似,只是返回值类型的前面多了个delegate。如:public delegate void PrientDelegate(string content),其实委托就是一个能够将方法封装成一个引用类型,能和普通对象一样传递。

一、委托声明的注意点

  1、和类一样,委托的声明可以再类的外部声明,委托也可以再类的内部声明。

  2、委托的声明虽然形式上与方法很像,但是它没有方法主体,而是直接以分号结尾。

  3、修饰符可以是new、public、protected、internal、private。

  4、delegate关键字后是本委托类型可以匹配的方法签名,尤其需要注意的是,它还包括方法的返回类型,但并非与方法名完全匹配。

二、给委托绑定方法时,要符合的两点要求

  1、方法的签名要与委托一样,方法参数的个数和类型。

  2、方法的返回值类型要与委托一样。

调用委托就相当于调用委托所绑定的方法, 一个委托可以绑定多个方法。委托是引用类型,因此它就可以到处传递,没有它,C#能够将方法到处传递吗?

先附上一个基础的例子

bubuko.com,布布扣
    public delegate void Print(string str);  //声明一个委托

    class Program
    {
        public static void PrintString(string str)
        {
            Console.WriteLine(str);
        }

        static void Main(string[] args)
        {
            //创建一个委托对象,并将方法PrintString赋给该委托
            Print p = new Print(Program.PrintString);
            //Print p = Program.PrintString;    //直接用=号也可以让委托绑定方法。

            p("调用委托实际等于调用了委托所绑定的方法!");  //输出调用委托实际等于调用了委托所绑定的方法!
            Console.ReadKey();
        }
    }
bubuko.com,布布扣

三、委托的组合(多个委托之间的关系)

  "+"可以将两个委托组合起来,"-"可以从一个委托组合中删除其中一个成员。

bubuko.com,布布扣
    public delegate void Print();

    class Program
    {
        public static void PrintString1()
        {
            Console.WriteLine("我是第一个方法");
        }

        public static void PrintString2()
        {
            Console.WriteLine("我是第二个方法");
        }

        static void Main(string[] args)
        {
            //创建一个委托对象并绑定方法
            Print p1 = Program.PrintString1;    //委托p1绑定方法1
            Print p2 = Program.PrintString2;    //委托p2绑定方法2

            Print p3 = p1 + p2; //将p1委托和p2委托组合成一个新委托p3
            p3();       //调用委托p3,相当于调用p3所有已经绑定的方法,此时是方法1与方法2,此时输出 我是第一个方法 "换行" 我是第二个方法
            Print p4 = p3 - p1;    //创建一个新的委托对象,其绑定的方法为p3委托组合去除委托p1,实际就只剩下p2
            p4();       //调用委托p4,相当于调用所有p4绑定的方法 输出 我是第二个方法

            Console.ReadKey();
        }
    }
bubuko.com,布布扣

四、委托的添加方法与删除方法(一个委托的事情)

  通过"+="符可以像已有委托新添加绑定一个方法,通过"-="可以从委托中删除一个已绑定的方法。

bubuko.com,布布扣
    public delegate void Print();

    class Program
    {
        public static void PrintString1()
        {
            Console.WriteLine("我是第一个方法");
        }

        public static void PrintString2()
        {
            Console.WriteLine("我是第二个方法");
        }

        static void Main(string[] args)
        {
            Print p = PrintString1; //声明一个委托并绑定第一个方法
            p();    //调用委托p  输出 我是第一个方法
            p += PrintString2;  //再为p多绑定一个方法
            p();    //调用委托p 输出我是第一个方法 "换行" 我是第二个方法,看到现在p委托一经是绑定两个方法的了
            p -= PrintString1;  //从委托p中删除一个已经绑定的方法p1;
            p();    //调用委托p 输出 我是第二个方法  看到p现在已经是只绑定第二个方法了

            Console.ReadKey();
        }
    }
bubuko.com,布布扣

 

五、委托在回调中的应用

  委托在回调函数中的调用:

bubuko.com,布布扣
    public delegate void PrintCompleteCallback(string message);

    class Program
    {
        public static void PrintMessage(string message)
        {
            Console.WriteLine(message);
        }

        static void Main(string[] args)
        {
            PrintCompleteCallback CompleteCallback = Program.PrintMessage;  //创建一个委托,并绑定PrintMessage方法
            Printer printer = new Printer("我是一个打印机");
            printer.Print(CompleteCallback);  //调用p对象的Print方法,要求传入一个委托作为参数,相当于传入一个方法作为参数

            Console.ReadKey();
        }
    }

    public class Printer
    {
        private string _name;
        public Printer(string name)
        {
            _name = name;
        }

        public void Print(PrintCompleteCallback callback)  //委托对象作为方法参数
        {
            callback(_name + "打印完毕");   //调用委托,相当于调用callback委托所绑定的对象
        }
    }
bubuko.com,布布扣

 

六、匿名方法

  匿名方法最大的优势在于其减少了系统开销,方法仅在委托使用时才定义。直接给委托传递一段代码比先创建一个方法再绑定到委托要简单。

  匿名方法的使用规则:

  1、匿名方法中不能使用跳转语句跳至此匿名方法的外部,反之亦然;匿名方法外部的跳转语句也不能跳到此匿名方法的内部。

  2、在匿名方法内部不能访问不安全的代码。另外,也不能访问在匿名方法外部定义的ref与out参数。但可以使用在匿名方法外部定义的其它变量。

bubuko.com,布布扣
    public delegate void Print();   //定义一个委托

    public delegate int GetLength(string str);  //定义一个带参数的委托
    class Program
    {
        static void Main(string[] args)
        {
            Print p = delegate      //不带参数的匿名方法
            {
                Console.WriteLine("你在他乡还好吗?");
            };
            p();

            GetLength g = delegate(string str)  //带参数的匿名方法,注意方法的参数要与委托一致
            {
                return str.Length;
            };

            int length = g("你还好吗?");    //调用委托,注意要传入参数
            Console.WriteLine(length);

            Console.ReadKey();
        }
    }
bubuko.com,布布扣

 

七、Lambda表达式

  Lambda表达式和匿名方法基本相同,只是语法不同而已,可以说,Lambda表达式就是匿名方法。必须要记住,Lambda就是一个匿名方法,是给委托赋值用的,也就是说,使用Lambda的场景只有给委托赋值。

  Lambda表达式的语法更加简洁:

  (param)=>expr  //其中param是一个输出参数列表,说白了就是给委托的参数,expr是一个表达式或一系列语句,说白了就是输出或执行的操作

  Lambda表达式具有以下特性:

  1、在一个具有唯一的显式类型参数的Lambda表达式中,圆括号可以从参数列表中删除。例如:param=>expr

  2、当输入参数不唯一时,括号不能省略。

  3、输入参数列表中的各参数可以显式指定类型,也可以省略掉参数类型,具体类型通过类型推断机制判断。

  4、expr可以只包含一个计算表达式,也可以包含一系列语句,只是如果是一系列语句必须包括在大括号内。

 一个委托参数的Lambda表达式

bubuko.com,布布扣
    public delegate string Print(string content);   //定义一个委托,该委托接受一个字符串输入,用于Lambda的左边

    class Program
    {
        static void Main(string[] args)
        {
            Print p = (str) => str += "-输出参数";  //(str) 输入参数,也就是委托参数中的content,箭头后的是输出,最简单的理解就是,箭头左边是输入,箭头左边是输出,当然语句就不同了。
            string outstr = p("输入参数");
            Console.WriteLine(outstr);  //输出 输入参数-输出参数

            Console.ReadKey();
        }
    }
bubuko.com,布布扣

  两个委托参数的Lambda表达式的调用:

bubuko.com,布布扣
    public delegate string Print(string content1,string content2);   //定义一个委托

    class Program
    {
        static void Main(string[] args)
        {
            Print p = (str1,str2) => str1 += "左边-右边" + str2;  //多个输入参数,括号不能省略
            string outstr = p("张飞","关羽");   //输出    张飞左边-右边关羽
            Console.WriteLine(outstr);  //输出 输入参数-输出参数

            Console.ReadKey();
        }
    }
bubuko.com,布布扣

  带语句的Lambda表达式

bubuko.com,布布扣
    public delegate void Print(string content);   //定义一个委托

    class Program
    {
        static void Main(string[] args)
        {
            Print p = str =>  //带语句的Lambda表达式,由于只有一个参数,所以小括号可以省略
            {
                Console.WriteLine(str);
            };
            p("你好");    //你好

            Console.ReadKey();
        }
    }
bubuko.com,布布扣

   2014-04-08-----------------------------

  现在学完了Lambda表达式了,可以结合扩展方法来瞧瞧Linq是怎么实现的了。下面写个模仿Linq的Where实现的示例:

bubuko.com,布布扣
namespace ConsoleApplication3
{
    public delegate bool Compare(int i);

    class Program
    {
        static void Main(string[] args)
        {
            //.Net的Linq扩展的是IEnumerable<TSource>(底层,范围广),而我是Calculate类
            Calculate c = new Calculate();

            int[] intArr = new int[] { 10, 20 };
            int[] intArrReturn = c.Where(m => m > 18, intArr);
            foreach (int i in intArrReturn)
            {
                Console.WriteLine(i);
            }
            Console.ReadKey();
        }
    }

    public static class Exten
    {
        //技术点1:扩展方法,扩展的是Calculate类(第一个参数)
        //技术点2:以委托作为参数,在方法内部会调用(第二个参数)
        public static int[] Where(this Calculate c, Compare compare, int[] intArr)
        {
            int[] returnArr = new int[2];  //示例定长数组
            int count = 0;
            foreach (int i in intArr)
            {
                if (compare(i))   
                { 
                    returnArr[count] = i;
                    count++;
                }
            }
            return returnArr;
        }
    }

    //计算类
    public class Calculate
    {
        
    }
}
bubuko.com,布布扣

  有那么点像了,Linq是泛型+Lambda,所以它的名字比较帅,如果我们把委托(参数名)改一下:Compare改为Func<T>

  public delegate bool Func<T>(int i);

  看下代码提示,是不是更像Linq了?

  bubuko.com,布布扣

  很遗憾,到目前为止,我们扩展的Calculate类不支持链式操作,因为返回的结果是一个int[]数组。而链式操作的原理是,返回的结果又能继续,如IEnumerable<int>的Where(m => m.xx)之后返回的又是IEnumerable<int>,所以能够无限下去。

  2014-04-08-----------------------------------

八、委托中的协变与逆变

  协变:委托方法的返回值类型直接或间接地继承自委托签名的返回值类型,称为协变。

  逆变:委托签名中的参数类型继承自委托方法的参数类型,称为逆变。

  注意:协变强调的是返回类型,逆变强调的则是方法参数。

   协变Demo:

bubuko.com,布布扣
  delegate People getSon(string name);

    class Program
    {
        static void Main(string[] args)
        {
            getSon g = sons;
            People p = g("张飞");     //注意虽然委托方法返回的是Son,但是委托本身返回的是父类People
            Console.WriteLine(p.Name);  //输出    张飞
            Console.ReadKey();
        }

        public static Son sons(string name)     //委托方法的返回值类型继承自委托签名的返回值类型  逆变
        {
            Son m = new Son();
            m.Name = name;
            return m;
        }

    }

    public class People
    {
        public People() { }

        public int Id { get; set; }

        public string Name { get; set; }
    }

    public class Son : People
    {
        public int Age { get; set; }
    }
bubuko.com,布布扣

  逆变Demo:

bubuko.com,布布扣
  delegate string getSonName(Son s);

    class Program
    {
        static void Main(string[] args)
        {
            getSonName g = sons;
            Son s = new Son();
            s.Name = "关羽";
            string str = g(s);
            Console.WriteLine(str);     //输出    关羽

            Console.ReadKey();
        }

        public static string sons(People p)     //委托签名的参数类型继承自委托方法的参数类型 此People为委托签名参数Son的父类
        {
            return p.Name;
        }
    }

    public class People
    {
        public People() { }

        public int Id { get; set; }

        public string Name { get; set; }
    }

    public class Son : People
    {
        public int Age { get; set; }
    }
bubuko.com,布布扣

C#委托,布布扣,bubuko.com

C#委托

标签:class   blog   code   http   tar   ext   

原文地址:http://www.cnblogs.com/mingxuantongxue/p/3805949.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!