c#之Lambda表达式

2021-05-02 03:26

阅读:468

标签:匿名类   sys   bsp   lin   double   方法   因此   ima   大写   

Lambda表达式

前言:我们可以使用 一个新语法把实现的代码赋予委托:Lambda表达式。只要有委托参数类型的地方就可以使用Lambda表达式。我们把我们上一篇博客中的例子改为Lambda表达式。

完整的代码如下:

 

 

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

namespace _15匿名方法
{
    class Program
    {
        static void Main(string[] args)
        {
            string mid = ",我是中间的,";
            Funcstring, string> lambda = param =>
          {
              param += mid;
              param += "我是最后的";
              return param;
          };
            Console.WriteLine(lambda("我是最前面的"));
            Console.ReadKey();
        }
    }
}

代码的显示如下:
技术分享

Lambda表达式有几种定义参数的方式。“=>”的左边列出了需要的参数,Lambda运算符的右边定义了赋予Lambda变量的方法的实现的代码。

一:参数:

Lambda表达式有几种定义参数的方式,如果只有一个参数的话,只写出参数名就可以了。下面的Lambda表达式使用了参数s。因为委托定义了一个string参数,所以s的类型就是string类型。实现代码调用String.Format();方法来返回一个字符串,在调用该委托的时候,就把字符串写在控制台上。

Funcstring, string> oneParam = s => string.Format("转换为大写的形式 :{0}", s.ToUpper());
Console.WriteLine(oneParam("hao"));

截图如下:

技术分享

如果使用多个参数的时候,就把参数名放在花括号中,这里参数x和y都是double类型,由Func委托定义:

private static Funcdouble, double, double> _twoParams = (x, y) => x * y;

方法的调用:

Console.WriteLine(_twoParams(3, 2));

我们可以不在花括号中添加参数的类型,因为编译器会自动的帮助我们匹配参数的类型。

二:多行代码:

如果Lambda表达式中只有一条语句的话,在方法块内就不需要花括号和return语句,因为编译器会添加一条隐式的return语句。比如我们看下面的一行代码:

private static Funcdouble, double> squate = x => x * x;

但是添加或括号和return语句也是完全合法的,但是添加这些符号不容易阅读,添加之后如下:

private static Funcdouble, double> squate = x => { return x * x; };

但是在Lambda表达式中如果想实现多条语句的时候,就必须加上花括号和return;

           Funcstring, string> anonDel = param =>
            {
                param += mid;
                param += "and this was added to the string";
                return param;
            };

三:闭包:

通过Lambda表达式可以访问Lambda表达式外部的变量。这称为闭包. 闭包是一个非常好的功能,但是如果使用不当的话,也会非常的危险,我们首先看一个例子:

 

int someVal = 5;
Funcint, int> f = x => x + someVal;

 

 

假设不假设在调用f时,Lambda表达式创建了一个以后使用的新方法,这似乎没有什么问题,我们看看我们上面写的代码,调用f的返回值应该是x+5的结果。但似乎不是这样,假定我们要修改someVal,于是调用Lambda表达式时,会使用someVal的新值。调用f(3)的结果是10;

特别是,当通过另一个线程调用Lambda表达式的时候,我们可能不知道进行了这个调用,也不知道外部的变量的当前值是什么?那我们Lambda表达式在访问外部的变量的时候,对于Lambda :x=>x + someVal ,编译器会创建一个匿名类,它有一个构造函数来传递外部的变量。该构造函数取决于从外部传递进来的变量个数。对于这个简单的例子。构造函数会接收一个int。匿名类包含一个匿名的方法。完整的代码如下:

 

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

namespace _16Lambda表达式
{
    /// 
    /// 匿名类
    /// 
    public class AnonymousClass
    {

        private int _someVal;
        public int SomeVal
        {
            get { return _someVal; }
            set { _someVal = value; }
        }

        /// 
        /// 构造函数初始化赋值操作
        /// 
        /// 外部传递的值
        public AnonymousClass(int someVal)
        {
            this.SomeVal = someVal;
        }

        /// 
        /// 匿名方法
        /// 
        /// 
        /// 
        public int AnonymousMathod(int x)
        {
            return x + _someVal;
        }

    }
}

使用Lambda表达式并调用该方法,会创建一个匿名类的实例,并传递调用该方法时的变量。

四:使用foreach语句的闭包:

我们先看代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace _16Lambda表达式
{
    class Program
    {
        static void Main(string[] args)
        {
            //泛型集合
            Listint> values = new Listint>() { 10, 20, 30 };
            //泛型集合中存储一个委托类型的方法(有返回值无参数)
            Listint>> funcs = new Listint>>();
            //遍历values存储到集合中
            //在集合中添加的对象是没有参数的但是返回values集合中的每一个值
            foreach (var val in values)
            {
                funcs.Add(() => val);
            }
            //遍历集合删除所有的方法  f():无参数有一个int类型的值
            foreach (var f in funcs)
            {
                Console.WriteLine(f());
            }
            Console.ReadKey();
        }
    }
}

在上面的例子中,首先用10 20 30 填充了一个名为values的列表,变量funcs引用了一个泛型列表,其中的每一个对象都引用Func类型的委托。第一条foreach语句添加了funcs列表中的每一个元素。添加到项中的函数使用Lambda表达式定义。该Lambda表达式使用了一个变量val,该变量在Lambda表达式的外部定义为foreach语句的循环变量。第二条foreach语句迭代func列表,已调用列表中引用的每个函数。结果如下:

技术分享

在c#5.0中,这段代码发生了变化,但是使用c#4或者是更早的版本的时候,会在控制台中输出3次30,在第一个foreach循环中国使用闭包时,所创建的函数是在调用,而不是在迭代是获得val的值。编译器会从foreach语中创建一个while循环。在c#4中,编译器在while循环外部定义循环变量。在每次迭代是重用这个变量。因此,在循环结束的时候,该变量的值就是最后一次迭代的值。要想在使用c#4时,让代码的结果为10 20 30,必须将代码改为使用一个局部的变量。并将这个局部的变量传入Lambda表达式。这样的话,每次迭代的值将保留一个不同的值。完整的代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace _16Lambda表达式
{
    class Program
    {
        static void Main(string[] args)
        {
            //泛型集合
            Listint> values = new Listint>() { 10, 20, 30 };
            //泛型集合中存储一个委托类型的方法(有返回值无参数)
            Listint>> funcs = new Listint>>();
            //遍历values存储到集合中
            //在集合中添加的对象是没有参数的但是返回values集合中的每一个值
            foreach (var val in values)
            {
                var v = val;
                funcs.Add(() => v);
            }
            //遍历集合删除所有的方法  f():无参数有一个int类型
            foreach (var f in funcs)
            {
                Console.WriteLine(f());
            }
            Console.ReadKey();
        }
    }
}

技术分享

在c#5.0中,不在需要做这种代码的修改了(即将代码修改为局部的变量)。在c#5.0会在while循环的代码块中创建一个不同的局部循环变量。所以值会自动的得到保存。这是c#4.0和c#5.0的区别,是我们必须要知道的。

 

 

c#之Lambda表达式

标签:匿名类   sys   bsp   lin   double   方法   因此   ima   大写   

原文地址:http://www.cnblogs.com/MoRanQianXiao/p/7772234.html


评论


亲,登录后才可以留言!