• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C#匿名方法

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

上一节我们谈到了匿名变量,本节我们学习匿名方法。

来自MSDN上的说法是这样的

Lambda 表达式(C# 编程指南)。 

根据MSDN上的说法,我们知道先有委托,再有匿名方法,最后到Lanbda表达式。因此,在讲解C#匿名方法之前,我们有必要说说C#委托这个东东。

 

委托是一个类型安全的对象,它指向程序中另一个以后会被调用的方法(或多个方法)。通俗的说,委托是一个可以引用方法的对象,当创建一个委托,也就创建一个引用方法的对象,进而就可以调用那个方法,即委托可以调用它所指的方法。

  • 如何使用委托?

1、定义委托类型

[访问修饰符]delegate 返回类型 委托名(形参);

2、声明委托对象

委托名 委托实例名;

3、创建委托对象(确定与哪些方法进行绑定)

委托实例名=new 委托名(某个类的方法)

4、使用委托调用方法

委托实例名(实参)

  • 委托注意事项:

1、委托和方法必须具有相同的参数。

2、委托可以调用多个方法,即一个委托对象可以维护一个可调用方法的列表而不是单独的一个方法,称为多路广播(多播)。

3、使用+=和-=运算实现方法的增加和减少

     下面我们通过一个小例子来讲解下委托,其代码如下(本事例通过计算器(+-*/)讲解简单的委托):

delegate int calculator(int x, int y); //委托类型
        static void Main(string[] args)
        {
            //创建委托对象(确定与哪些方法进行绑定),委托实例名=new 委托名(某个类的方法,本例与加法向绑定
            calculator MYAdd = new calculator(Adding);
            //创建委托对象(确定与哪些方法进行绑定),委托实例名=new 委托名(某个类的方法,本例与减法向绑定
            calculator MYMove = new calculator(Moveing);
            //创建委托对象(确定与哪些方法进行绑定),委托实例名=new 委托名(某个类的方法,本例与乘法向绑定
            calculator MYMultiply = new calculator(Multiply);
            //创建委托对象(确定与哪些方法进行绑定),委托实例名=new 委托名(某个类的方法,本例与除法向绑定
            calculator MYDivide = new calculator(Divide);
            //通过委托执行方法
            int A = MYAdd(4, 4);//8
            int B = MYMove(4, 4);//0
            int C = MYMultiply(4, 4);//16
            int D = MYDivide(4, 4);//1
        }

        /// <summary>
        /// 加法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static int Adding(int x,int y)
        {
            return x + y;
        }
        /// <summary>
        /// 减法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static int Moveing(int x, int y)
        {
            return x - y;
        }
        /// <summary>
        /// 乘法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static int Multiply(int x, int y)
        {
            return x * y;
        }
        /// <summary>
        /// 除法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static int Divide(int x, int y)
        {
            return x / y;
        }

根据上述的事例,大家应该了解简单委托的使用了。

那么,我们更近一步,来说说泛型委托。泛型应该是大家比较熟悉的一种数据类型,泛型委托又是如何和泛型向结合的呢?

再讲泛型委托之前,先说说微软引入泛型的目的及使用泛型的好处。

  •                  为什么要有泛型
  •       假设你是一个方法的设计者,
  •       这个方法有一个传入参数,有一个返回值。
  •       但你并不知道这个参数和返回值是什么类型的,
  •       如果没有泛型,你可能把参数和返回值的类型都设定为Object了
  •       那时,你心里肯定在想:反正一切都是对象,一切的基类都是Object
  •       没错!你是对的!
  •       这个方法的消费者,会把他的对象传进来(有可能会做一次装箱操作)
  •       并且得到一个Object的返回值,他再把这个返回值强制类型转化为他需要的类型
  •       那么这个过程涉及到的装箱拆箱会损耗系统的性能。
  •       那么我们如何把损耗性能避免掉呢?
  •       有泛型之后就可以了!

微软已经为我们事先定义好了三个泛型委托(Predicate,Action,Func),下面我们探讨下这三个委托的不同。

1、Predicate 泛型委托定义如下:

public delegate bool Predicate<in T>(T obj);
这个委托表示的方法需要传入一个T类型的参数,并且需要返回一个bool类型的返回值
代码实例如下:、
static void Main(string[] args)
        {
            //Predicate 泛型委托代表一类具有 一个T类型(通用类型)作为参数并返回BOOL类型的方法
            var B = new Predicate<int>(isbol);
 bool BB=isbol(1);//true } /// <summary> /// Predicate 泛型委托 /// </summary> /// <typeparam name="?"></typeparam> /// <param name="x"></param> /// <returns></returns> public static bool isbol(int x) { return x > 0; }

2、Action委托定义如下:

   public delegate void Action<T>(T obj,T obj2,...,obj16);      --最多16个参数

 他代表了一类方法,可以有0个到16个输入参数,输入参数的类型是不确定的。此类方法不能有返回值,也就是返回VOID类型的方法。

   代码实例如下:

static void Main(string[] args)
        {
            //Action 他代表了一类方法,可以有0个到16个输入参数,输入参数的类型是不确定的。此类方法不能有返回值,也就是返回VOID类型的方法。
            var B = new Action<int,string,string>(Action_d);
            B(-1,"true","flase");
            Console.ReadKey();
        }

       /// <summary>
        /// Action 泛型委托
       /// </summary>
       /// <typeparam name="?"></typeparam>
       /// <param name="x"></param>
       /// <returns></returns>
        public static void Action_d(int x,string y,string z)
        {
            if (x > 0)
            {
                Console.WriteLine(y);
            }
            else
            {
                Console.WriteLine(z);
            }
        }

3、Func泛型委托 定义如下:

    public delegate T Func<T>(T obj,T obj2,...,obj16);   --最多16个参数

   为了弥补Action泛型委托,不能返回值的不足,.net提供了Func泛型委托,相同的是它也是最多0到16个输入参数,参数类型由使用者确定,不同的是它规定要有一个返回值,返回值的类型也由使用者确定,说白了,就是ACtion委托没有返回值,而FUNC委托具有了返回值,他们都是最多16个参数。

    代码实例如下:

    

static void Main(string[] args)
        {
            //Func 他代表了一类方法,可以有0个到16个输入参数,输入参数的类型是不确定的。此类方法有返回值。
            var B = new Func<int, string,string,string>(Func_d);//注意:<>中最后一个string代表输出类型 
            Console.WriteLine(B(1,"True","False"));
            Console.ReadKey();
        }

       /// <summary>
        /// Predicate 泛型委托
       /// </summary>
       /// <typeparam name="?"></typeparam>
       /// <param name="x"></param>
       /// <returns></returns>
        public static string Func_d(int x,string y,string z)
        {
            if (x > 0)
            {
                return y;
            }
            else
            {
                return z;
            }
        }

学会了C#委托,那么C#匿名方法就显得很简单了!下面和小伙伴们探讨下C#匿名方法的使用!

还记得本篇上述的计算器吧!就是那个加减乘除委托。我们知道,我们在定义好委托后,还需要在定义加减乘数方法,C#引入匿名方法后,我们就不需要在单独写这些方法了,我们只需在匿名方法体内实现我们的业务逻辑即可!

  

delegate int calculator(int x, int y); //委托类型
        static void Main(string[] args)
        {
            //创建委托对象(确定与哪些方法进行绑定),委托实例名=new 委托名(某个类的方法,本例与加法向绑定
            calculator Adding =delegate( int x, int y)
            {
               return x+y;
            };

            calculator Moveing = delegate(int x, int y)
            {
                return x - y;
            };

            calculator Multiply = delegate(int x, int y)
            {
                return x * y;
            };

            calculator Divide = delegate(int x, int y)
            {
                return x / y;
            };
            Adding(4, 4);//8
            Moveing(4, 4);//0
            Multiply(4, 4);//16
            Divide(4, 4);//1
        }

讲解到现在,想必大家对匿名方法有一定的了解了!

下面是参考MSDN上的一些资料如下:

通过使用匿名方法,由于您不必创建单独的方法,因此减少了实例化委托所需的编码系统开销。

无需为委托创建更多方法,线程类即可创建一个线程并且包含该线程执行的代码。  

 
void StartThread()
{
    System.Threading.Thread t1 = new System.Threading.Thread
      (delegate()
            {
                System.Console.Write("Hello, ");
                System.Console.WriteLine("World!");
            });
    t1.Start();
}
备注
 
 

匿名方法的参数的范围是“匿名方法块”。

如果目标在块内部,在匿名方法块外部使用跳转语句(如 gotobreak 或 continue)也是错误的。  

n 即是一个外部变量:  

 
int n = 0;
Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n); };

与本地变量不同,捕获的变量的生存期内扩展,直到引用该匿名方法委托被垃圾回收。  

out 参数。

在“匿名方法块”中不能访问任何不安全代码。

is 运算符的左侧不允许使用匿名方法。

 好了,截止到现在,匿名方法讲解完毕,如果需要更深入的了解匿名方法,可以找度娘哈!这里仅仅只是简单的介绍!

下一节,我们共同学习拉姆达表达式!lambda说: 一步一个脚印,学好C#基础很重要!


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C#对象与JSON字符串互相转换的三种方式发布时间:2022-07-13
下一篇:
C#汉字转拼音(支持GB2312字符集中所有汉字)发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap