开发的进化史,中的发展
分类:计算机编程

三、查询集合

本文内容

  • 引入
  • 概述
  • 匿名函数
  •     Lambda 表达式
  •     匿名方法
  • 参看资料

    引入

本文在 VS 2008 环境下,阐述自己对 Lambda 表达式、匿名函数、委托和 LINQ 谈谈自己的理解。我对这个问题的思考,始于以下阶段:

  • 毕业刚参加工作时,使用 VS 2005 C#,它还没有 LINQ 特性。那时的主要精力在后台代码,初步掌握了委托、泛型等,以及设计模式,并尝试编写 JavaScript 代码,只是不太重视;
  • 之后,尤其是跳槽后,对 JavaScript、jQuery、Ajax 、DOM、HTML、CSS产生了兴趣,发现它们类似 JSON 的书写方式很有意思,那时已经使用 VS 2008,也有这种方式,因此在实际项目中时不时地采用这种方式书写;
  • 期间,知道了 LINQ,觉得不错,在很大程度上,接近自然语言,简化了代码逻辑和代码量;
  • 但问题是,这种书写方式除了跟之前(VS 2005 前)完全不同外,无论是 JavaScript,还是 C#,这种方式,可以在不定义变量,不定义函数名、形参和返回值类型等情况下使用,的确让人困惑;
  • 为了更好的理解这种书写方式,我学习了 JSON 的理论,之后是 Lambda 表达式、LINQ。

往往,当你缺少某方面知识时,对一个问题的理解不可能深入。

 

本文内容

  • 委托和泛型委托
    • 委托发展:C# 中委托的发展
    • 泛型委托
  • 委托
    • 声明(定义)委托
    • 实例化委托
    • 调用委托
    • 用 Lambda表达式创建和实例化委托
  • .NET 提供的委托
    • Action 委托
    • Func 委托
    • Predicate 委托
  • 参考资料
  • 修改记录

1、数据类型的进化

1.找出List<Product>列表中符合特定条件的所有元素

概述

我们都知道,定义一个函数,要有名字,也许要有形参列表、返回值类型。即便是现在,也是如此。

而 Lambda 演算(Lambda calculus),告诉程序员们,其实不然,定义函数可以没有名字,没有形参列表,没有返回值类型,什么都没有,只有函数体,一些表达式或是语句(现在知道这是基于 Lambda 的类型推理),这就是匿名函数。

另一方面——委托,委托相当于函数(方法)指针(事件是委托的特例),那么完全可以利用匿名函数简化委托。Lambda 表达式的理论基础是Lambda 演算(Alonzo Church, 1930)。

LINQ 就是基于 Lambda 表达式(匿名函数)、泛型和简化的委托。

本文的重点是从大的方面上了解 Lambda 表达式和其应用,而不是它的语法。

 

下载 Deom

 C#1中实现Product类型代码

C#1.1 查询步骤:循环,if判断,打印

匿名函数

匿名函数是一个“内联(inline)”语句或表达式,可在需要委托类型的任何地方使用。可以使用匿名函数来初始化命名委托,或传递命名委托(而不是命名委托类型)作为方法参数。

有两种匿名函数:

  • Lambda 表达式
  • 匿名方法

下载更多 Demo

图片 1图片 2

product类

C# 中委托的发展

  • C# 1.0 中,通过用其他位置定义的方法显式初始化委托来创建委托的实例。
  • C# 2.0 引入了匿名方法(anonymous method)的概念,用匿名方法初始化委托,在委托中执行未命名的内联语句块。
  • C# 3.0 引入了 Lambda 表达式,与匿名方法的概念类似,但更具表现力并且更简练。匿名方法和Lambda 表达式统称为“匿名函数”。
  • 通常,针对 .NET Framework 3.5 及更高版本应使用 Lambda 表达式。

下面的示例演示了从 C# 1.0 到 C# 3.0 委托创建过程的发展:

图片 3图片 4View Code

class Test
{
    delegate void TestDelegate(string s);
    static void M(string s)
    {
        Console.WriteLine(s);
    }

    static void Main(string[] args)
    {
        // C# 1.0: 最初的委托语法,用一个方法名初始化委托.
        TestDelegate testdelA = new TestDelegate(M);

        // C# 2.0: 用内联代码初始化委托,这个内联代码成为“匿名方法”.
        // 这个方法把一个字符串作为输入参数.
        TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };

        // C# 3.0: 用 Lambda 表达式初始化委托. 
        // Lambda 表达式也把一个字符串(x)作为输入参数.
        // 编译器可以推断 x 的数据类型.
        TestDelegate testDelC = (x) => { Console.WriteLine(x); };

        // 调用委托.
        testdelA("Hello. My name is M and I write lines.");
        testDelB("That's nothing. I'm anonymous and ");
        testDelC("I'm a famous author.");

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

运行结果:

图片 5图片 6View Code

Hello. My name is M and I write lines.
That's nothing. I'm anonymous and
I'm a famous author.
Press any key to exit.

 

委托和泛型委托


委托实现了函数指针,这个函数指针跟 C 的函数指针不同,它是类型安全的,确保被调用的方法签名是正确的。只要方法签名跟委托签名匹配,给委托的实例可以是实例方法,或是静态方法。

为什么要有这个东西?我们对把数据作为函数参数很熟悉,但有时,某个方法的操作不是针对数据,而是针对另一个方法。比如,线程,用线程去执行一个方法,或是代码段;再比如,事件,事件是委托的特例,等等。

 1 public class Product
 2     {
 3         string name;
 4         public string Name
 5         {
 6             get { return name; }
 7         }
 8 
 9         decimal price;
10         public decimal Price
11         {
12             get { return price; }
13         }
14 
15         public Product(string name, decimal price)
16         {
17             this.name = name;
18             this.price = price;
19         }
20      
21         public static ArrayList GetSampleProducts()
22         {
23             ArrayList list = new ArrayList();
24             list.Add(new Product("West Side Story", 9.99m));
25             list.Add(new Product("Assassins", 14.99m));
26             list.Add(new Product("Frogs", 13.99m));
27             list.Add(new Product("Sweeney Todd", 10.99m));
28             return list;
29            
30         }
31 
32         public override string ToString()
33         {
34             return string.Format("{0}: {1}", name, price);
35           
36         }
37       
38 
39     }

图片 7图片 8

Lamda 表达式

“Lambda 表达式”拓展了人们对函数的认识,简化了函数定义。而委托又是一个外部函数(方法)的指针,因此,也就简化了委托。

Lambda 表达式是一个匿名函数,包含表达式或语句,可用于创建委托或表达式树类型。

表达式都使用 Lambda 运算符 =>。运算符左边是输入参数(如果有),右边包含表达式或语句块。

创建委托,如下所示:

图片 9图片 10View Code

delegate int del(int i);
static void Main(string[] args)
{
    del myDelegate = x => x * x;
    int j = myDelegate(5); // j = 25
}

创建表达式树,如下所示:

图片 11图片 12View Code

using System.Linq.Expressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<del> myET = x => x * x; //
        }
    }
}

在基于方法的 LINQ 查询中,如 Where,Lambda 表达式作为标准查询运算符方法的参数。

委托发展:C# 中委托的发展

  • C# 1.0 中,通过用在其他地方定义的方法显式初始化委托来创建委托的实例。
  • C# 2.0 引入了匿名方法(anonymous method)的概念,用匿名方法初始化委托,在委托中执行未命名的内联语句块。
  • C# 3.0 引入了 Lambda 表达式,与匿名方法的概念类似,但更具表现力并且更简练。匿名方法和 Lambda 表达式统称为“匿名函数”,类似闭包(Closure)特性。
  • 通常,针对 .NET Framework 3.5 及更高版本应使用 Lambda 表达式。

下面的示例演示了从 C# 1.0 到 C# 3.0 委托创建过程的发展:

示例1:

图片 13图片 14View Code

namespace MyDelegate
{
    class Program
    {
        delegate void TestDelegate(string s);

        static void M(string s)
        {
            System.Console.WriteLine(s);
        }

        static void Main(string[] args)
        {
            // C# 1.0: 最初的委托语法,用一个方法名初始化委托.
            TestDelegate testdelA = new TestDelegate(M);

            // C# 2.0: 用内联代码初始化委托,这个内联代码成为“匿名方法”.
            // 这个方法把一个字符串作为输入参数.
            TestDelegate testDelB = delegate(string s) { System.Console.WriteLine(s); };

            // C# 3.0: 用 Lambda 表达式初始化委托. 
            // Lambda 表达式也把一个字符串(x)作为输入参数.
            // 编译器可以推断 x 的数据类型.
            TestDelegate testDelC = (x) => { System.Console.WriteLine(x); };

            // 调用委托.
            testdelA("Hello. My name is M and I write lines.");
            testDelB("That's nothing. I'm anonymous and ");
            testDelC("I'm a famous author.");

            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
    }
}

运行结果:

图片 15图片 16View Code

Hello. My name is M and I write lines.
That's nothing. I'm anonymous and
I'm a famous author.
Press any key to exit.

View Code

 1 using System.Collections;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp1
 5 {
 6     [Description("Listing 1.01")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13         }
14 
15         decimal price;
16         public decimal Price
17         {
18             get { return price; }
19         }
20 
21         public Product(string name, decimal price)
22         {
23             this.name = name;
24             this.price = price;
25         }
26 
27         public static ArrayList GetSampleProducts()
28         {
29             ArrayList list = new ArrayList();
30             list.Add(new Product("West Side Story", 9.99m));
31             list.Add(new Product("Assassins", 14.99m));
32             list.Add(new Product("Frogs", 13.99m));
33             list.Add(new Product("Sweeney Todd", 10.99m));
34             return list;
35         }
36 
37         public override string ToString()
38         {
39             return string.Format("{0}: {1}", name, price);
40         }
41     }
42 }

Lambda 表达式

运算符右边是“Lambda 表达式”。Lambda 表达式在构造表达式树时广泛使用。Lambda 表达式返回表达式的结果,采用以下基本形式:

(input parameters) => expression

如下所示:

(x, y) => x == y

有时,编译器难于或无法推断输入类型。此时可以显式指定类型:

(int x, string s) => s.Length > x

使用空括号指定零个输入参数:

() => SomeMethod()

泛型委托

示例 1 也可改写成泛型形式。如下所示:

示例 2:

图片 17图片 18View Code

namespace MyGenericDelegate
{
    class Program
    {
        delegate void TestGenericDelegate<T>(T s);

        static void GenericM<T>(T s)
        {
            System.Console.WriteLine(s);
        }

        static void Main(string[] args)
        {
            // C# 1.0
            TestGenericDelegate<int> testGenericDelA = new TestGenericDelegate<int>(GenericM);

            // C# 2.0
            TestGenericDelegate<string> testGenericDelB = delegate(string s) { System.Console.WriteLine(s); };

            // C# 3.0
            TestGenericDelegate<double> testGenericDelC = (x) => { System.Console.WriteLine(x); };

            // 调用委托.
            testGenericDelA(123456);
            testGenericDelB("That's nothing. I'm anonymous and ");
            testGenericDelC(123.456);

            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
    }
}

运行结果:

图片 19图片 20View Code

123456
That's nothing. I'm anonymous and
123.456
Press any key to exit.

 

C#2中的强类型集合和私有的赋值方法

View Code

Lambda 语句

Lambda 语句与 Lambda 表达式类似,只是语句括在大括号中:

(input parameters) => {statement;}

Lambda 语句的主体可以包含任意数量的语句。

图片 21图片 22View Code

delegate void TestDelegate(string s);
…
TestDelegate myDel = n => { string s = n   ""   "World"; Console.WriteLine(s); };
myDel("Hello");

像匿名方法一样,Lambda 语句无法用于创建表达式树。

委托


以示例 1 为例:

  • 声明(定义)委托

    delegate void TestDelegate(string s);

每个委托描述了方法签名和返回类型等全部细节。如 TestDelegate 定义方法有一个 string 类型的参数 s,并且返回 void 类型。

可以在任何地方定义委托,跟定义一个类类似。委托也可以有访问修饰符。

  • 实例化委托

    TestDelegate testdelA = new TestDelegate(M);

声明委托后,必须用某个方法实例化这个委托。用方法 M 去实例化委托 testdelA

声明(定义)和实例化委托,有点类似一个类,类也需要定义,并实例化。

委托在语法上,总是带有一个参数的构造函数,这个参数就是委托引用的方法。也就是说,函数指针必须指向一个方法。

  • 调用委托

    testdelA("Hello. My name is M and I write lines.");

实例化委托后,通过委托对象的名称(后面是传递给委托的参数)调用委托对象。

委托也可以组合、移除,如下所示:

namespace MyDelegate

{

    delegate void D(int x);

 

    class C

    {

        public static void M1(int i)

        {

            Console.WriteLine("C.M1: "   i);

        }

        public static void M2(int i)

        {

            Console.WriteLine("C.M2: "   i);

        }

        public void M3(int i)

        {

            Console.WriteLine("C.M3: "   i);

        }

    }

}

用如下代码测试:

D cd1 = new D(C.M1);

cd1(-1);                // call M1

D cd2 = new D(C.M2);

cd2(-2);                // call M2

D cd3 = cd1   cd2;

cd3(10);                // call M1 then M2

cd3  = cd1;

cd3(20);                // call M1, M2, then M1

C c = new C();

D cd4 = new D(c.M3);

cd3  = cd4;

cd3(30);                // call M1, M2, M1, then M3

cd3 -= cd1;             // remove last M1

cd3(40);                // call M1, M2, then M3

cd3 -= cd4;

cd3(50);                // call M1 then M2

cd3 -= cd2;

cd3(60);                // call M1

cd3 -= cd2;                // impossible removal is benign

cd3(60);                // call M1

cd3 -= cd1;                // invocation list is empty so cd3 is null

//        cd3(70);        // System.NullReferenceException thrown

cd3 -= cd1;                // impossible removal is benign
  • 用 Lambda 表达式创建和实例化委托。

    Func myFunc = x => x == 5;

    bool result = myFunc(4); // returns false of course

其中,Func<int, bool> 是.NET 提供的已封装好的委托,用于以参数形式传递的方法,必须返回值。这样,就不用显式声明定义委托。该委托输入参数为 int,返回类型为 bool

 

图片 23图片 24

ArrayListQuery类

带有标准查询运算符的 Lambda

许多标准查询运算符都具有输入参数,其类型是泛型委托的 Func<Of T, TResult> 系列的其中之一。如Enumerable.Count 方法、Enumerable.Max 方法、Enumerable.Min 方法等等。

Func<Of T, TResult> 中的 "Of T" 表示输入参数的数量和类型;"TResult" 表示委托的返回类型。Func 委托对于应用在一组数据中每个元素非常有用。

例如,假设有以下委托类型:

图片 25图片 26View Code

public delegate TResult Func<TArg0, TResult>(TArg0 arg0)

若用 Func<int,bool> myFunc 来实例化这个委托,那么,int 是输入参数,bool 是返回值。始终在最后一个类型参数中指定返回值。若用 Func<int, string, bool> 来实例化,那么两个 int 和 string是输入参数,并且返回类型为 bool。

如下所示,调用下面 Func 委托,将返回 true 或 false 以指示输入参数是否等于 5:

图片 27图片 28View Code

Func<int, bool> myFunc = x => x == 5;
bool result = myFunc(4);

当参数类型为 Expression<Func> 时,也可以提供 Lambda 表达式,例如在 System.Linq.Queryable 内定义的标准查询运算符中。如果指定 Expression<Func> 参数,Lambda 将编译为表达式树。

如下所示,演示一个标准查询运算符 Count 方法,计算整数 (n) 除以 2 余数为 1 的整数:

图片 29图片 30View Code

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int oddNumbers = numbers.Count(n => n % 2 == 1);

编译器可以推断输入参数的类型,或者您也可以显式指定该类型。

如下所示,演示返回数组 9 左边的所有元素,因为 9 是序列中不满足条件的第一个数字:

图片 31图片 32View Code

var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);

.NET 提供的委托


 1  public class Product
 2     {
 3         string name;
 4         public string Name
 5         {
 6             get { return name; }
 7             private set { Name = value; } 私有的赋值方法
 8         }
 9 
10         decimal price;
11         public decimal Price
12         {
13             get { return price; }
14             private set { Price = value; }
15         }
16         //C#3:Product(){}
17         public Product(string name, decimal price)
18         {
19            
20               Name = name;
21               Price = price;
22         }
23       public static List<Product>GetSampleProducts()
24         {
25              List<Product>list= new List<Product>();
26             list.Add(new Product("West Side Story", 9.99m));
27             list.Add(new Product("Assassins", 14.99m));
28             list.Add(new Product("Frogs", 13.99m));
29             list.Add(new Product("Sweeney Todd", 10.99m));
30             return list;
31            
32         }
33 
34         public override string ToString()
35         {
36             return string.Format("{0}: {1}", name, price);
37           
38         }
39 
40     }

图片 33图片 34

Lambda 中的类型推理

在编写 Lambda 时,通常不必为输入参数指定类型,因为编译器可以根据 Lambda 主体、基础委托类型以及 C# 语言规范中描述的其他因素推断类型。

对于大多数标准查询运算符,第一个输入是源序列中元素的类型。因此,如果要查询 IEnumerable<Customer>,则输入变量将被推断为 Customer 对象,因此你可以访问其方法和属性:

图片 35图片 36View Code

customers.Where(c => c.City == "London");

Lambda 的一般规则如下:

  • Lambda 包含的参数数量必须与委托类型包含的参数数量相同。
  • Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。
  • Lambda 的返回值(如果有)必须能够隐式转换为委托的返回类型。

注意,Lambda 表达式本身没有类型,因为常规类型系统没有“Lambda 表达式”这一内部概念。但是,有时会不正式地论及 Lambda 表达式的“类型”。在这些情况下,类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。

Action 委托

该委托以参数形式传递一个执行某操作的方法,不返回值。Action 委托有如下几个重载:

  • Action 委托
  • Action<T> 委托
  • Action<T1, T2> 委托
  • Action<T1, T2, T3> 委托
  • Action<T1, T2, T3, T4> 委托

.NET framework 4.0 提供的重载更多。可提供 16 个输入参数。

示例 3:以 Action<T> 带一个参数的委托为例。

图片 37图片 38View Code

using System;

namespace MyAction
{
    class Program
    {
        // 声明委托
        delegate void DisplayMessage(string message);

        static void Main(string[] args)
        {
            // 用 ShowWindowsMessage,采用命名方法实例化 DisplayMessage 委托
            DisplayMessage messageTargetA = new DisplayMessage(ShowWindowsMessage);
            DisplayMessage messageTargetB = ShowWindowsMessage;
            // 用 ShowWindowsMessage,采用命名方法实例化 Action 委托
            Action<string> messageTargetC = ShowWindowsMessage;
            // 用 ShowWindowsMessage,采用匿名方法实例化 Acton 委托
            Action<string> messageTargetD = delegate(string s) { ShowWindowsMessage(s); };
            // 用 ShowWindowsMessage,采用 Lambda 表达式实例化 Acton 委托
            Action<string> messageTargetE = s => ShowWindowsMessage(s);

            messageTargetA("Hello, World!");
            messageTargetB("Hello, World!");
            messageTargetC("Hello, World!");
            messageTargetD("Hello, World!");
            messageTargetE("Hello, World!");
            System.Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
        private static void ShowWindowsMessage(string message)
        {
            System.Console.WriteLine(message);
        }
    }
}

运行结果:

图片 39图片 40View Code

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Press any key to exit.

该示例最简单的形式也可写成:

图片 41图片 42View Code

Action<string> messageTarget = s => System.Console.WriteLine(s);
messageTarget("Hello, World!");
System.Console.WriteLine("Press any key to exit.");
Console.ReadKey();

View Code

 1 using System;
 2 using System.Collections;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp1
 6 {
 7     [Description("Listing 1.10")]
 8     class ArrayListQuery
 9     {
10         static void Main()
11         {
12             ArrayList products = Product.GetSampleProducts();
13             foreach (Product product in products)
14             {
15                 if (product.Price > 10m)
16                 {
17                     Console.WriteLine(product);
18                 }
19             }
20         }
21     }
22 }

如何:在查询中使用 Lambda 表达式

不会在查询语法中直接用到 Lambda 表达式,但会在方法调用中用到,并且查询表达式(查询语法)可以包含方法调用(方法语法)。事实上,某些查询操作只能用方法语法表示。

如下所示,查询语法与方法语法:

图片 43图片 44View Code

class QueryVMethodSyntax
{
    static void Main()
    {
        int[] numbers = { 5, 10, 8, 3, 6, 12};

        // 查询语法:
        IEnumerable<int> numQuery1 = 
            from num in numbers
            where num % 2 == 0
            orderby num
            select num;

        // 方法语法:
        IEnumerable<int> numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);

        foreach (int i in numQuery1)
        {
            Console.Write(i   "");
        }
        Console.WriteLine(System.Environment.NewLine);
        foreach (int i in numQuery2)
        {
            Console.Write(i   "");
        }

        // Keep the console open in debug mode.
        Console.WriteLine(System.Environment.NewLine);
        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }
}

运行结果:

图片 45图片 46View Code

6 8 10 12
6 8 10 12

示例1:演示使用标准查询运算符 Enumerable.Where,基于方法语法(Lambda 表达式)查询。注意,示例中的 Where 方法具有一个委托类型为 Func<TSource, Boolean> 的输入参数,委托采用整数作为输入,并返回布尔值。可以将 Lambda 表达式转换为该委托。若是 Queryable.Where 方法(LINQ to SQL 查询),则参数类型为 Expression<Func<int,bool>>,但 Lambda 表达式看起来将完全相同。

图片 47图片 48View Code

// Enumerable.Where
// The call to Count forces iteration of the source
int[] scores = { 90, 71, 82, 93, 75, 82 };
int highScoreCount = scores.Where(n => n > 80).Count();
Console.WriteLine("{0} scores are greater than 80", highScoreCount);

// Queryable.Where
// Get all strings whose length is less than 6.
List<string> fruits = new List<string> { "apple", "passionfruit", "banana", "mango", 
           "orange", "blueberry", "grape", "strawberry" };
IEnumerable<string> query = fruits.AsQueryable().Where(fruit => fruit.Length < 6);
foreach (string fruit in query)
    Console.WriteLine(fruit);

Console.ReadKey();

运行结果:

图片 49图片 50View Code

4 scores are greater than 80
apple
mango
grape

示例2:演示在查询语法中使用方法语法(Lambda 表达式)。Lambda 是必需的,因为无法使用查询语法来调用 Sum 标准查询运算符。

查询首先按 GradeLevel 枚举中定义的方式,依据学生的成绩等级分组。然后,对每个组,添加每个学生的总分。这需要两个 Sum 运算。内部的 Sum 计算每名学生的总分,外部的 Sum 保留该组中所有学生的运行合并总计。

图片 51图片 52View Code

// This query retrieves the total scores for First Year students, Second Years, and so on.
// The outer Sum method uses a lambda in order to specify which numbers to add together.
var categories =
from student in students
group student by student.Year into studentGroup
select new { GradeLevel = studentGroup.Key, TotalScore = studentGroup.Sum(s => s.ExamScores.Sum()) };

// Execute the query.
foreach (var cat in categories)
{
      Console.WriteLine("Key = {0} Sum = {1}", cat.GradeLevel, cat.TotalScore);
}

运行结果:

图片 53图片 54View Code

Key = SecondYear Sum = 1014
Key = ThirdYear Sum = 964
Key = FirstYear Sum = 1058
Key = FourthYear Sum = 974

Func 委托

该委托以参数形式传递的方法,必须返回值。Func 委托有如下几个重载:

  • Func<TResult> 委托
  • Func<T, TResult> 委托
  • Func<T1, T2, TResult> 委托
  • Func<T1, T2, T3, TResult> 委托
  • Func(<T1, T2, T3, T4, TResult> 委托

.NET framework 4.0 提供的重载更多。可提供 16 个输入参数。

示例 4:以 Func(T, TResult) 待一个参数的委托为例。

图片 55图片 56View Code

using System;

namespace MyFunc
{
    delegate string ConvertMethod(string inString);

    class Program
    {
        static void Main(string[] args)
        {
            // 用 UppercaseString,以命名方法实例化委托
            ConvertMethod convertMethA = UppercaseString;
            // 用 UppercaseString,以命名方法实例化 Func 委托
            Func<string, string> convertMethB = UppercaseString;
            // 以匿名方法实例化 Func 委托
            Func<string, string> convertMethC = delegate(string s) { return s.ToUpper(); };
            Func<string, string> convertMethD = delegate(string s) { return UppercaseString(s); };
            // 以 Lambda 表达式实例化  Func 委托
            Func<string, string> convertMethE = s => s.ToUpper();

            System.Console.WriteLine(convertMethA("Dakota"));
            System.Console.WriteLine(convertMethB("Dakota"));
            System.Console.WriteLine(convertMethC("Dakota"));
            System.Console.WriteLine(convertMethD("Dakota"));
            System.Console.WriteLine(convertMethE("Dakota"));

            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
        private static string UppercaseString(string inputString)
        {
            return inputString.ToUpper();
        }
    }
}

运行结果:

图片 57图片 58View Code

DAKOTA
DAKOTA
DAKOTA
DAKOTA
DAKOTA
Press any key to exit.

该示例最简单的形式也可写成:

图片 59图片 60View Code

Func<string, string> convertMeth = s => s.ToUpper();
System.Console.WriteLine(convertMeth("Dakota"));
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();

C#3自动实现的属性和更简单的初始化

View Code

如何:在 LINQ 外部使用 Lambda 表达式

Lambda 表达式并不只限于在 LINQ 查询中使用。可以使用在需要委托值的任何地方(也就是在可以使用匿名方法的任何地方)。下面演示如何在 Windows 窗体事件处理程序中使用 Lambda 表达式。注意,输入的类型(Object 和 MouseEventArgs)由编译器推理,因此不必在 Lambda 输入参数中显式给定。

图片 61图片 62View Code

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        // Use a lambda expression to define an event handler.
       this.Click  = (s, e) => { MessageBox.Show(((MouseEventArgs)e).Location.ToString());};
    }
}

Predicate 委托

该委托定义一组条件并确定指定对象是否符合这些条件的方法。此委托由 Array 和 List<T> 类的几种方法使用,用于在集合中搜索元素。

示例 5:演示在数组中查找第一个 X*Y>100000 的点。

图片 63图片 64View Code

using System;
using System.Collections.Generic;

namespace MyPredicate
{
    class Program
    {
        static void Main(string[] args)
        {
            Point[] points = { 
                                 new Point(){X = 100,Y = 200}, new Point(){X = 150,Y = 250}, 
                                 new Point(){X = 250,Y = 375}, new Point(){X = 275,Y = 395}, 
                                 new Point(){X = 295,Y = 450}, new Point(){X = 290,Y = 451}
                             };

            Point first = Array.Find(points, ProductGT10);
            Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
        class Point
        {
            public int X { get; set; }
            public int Y { get; set; }
        }
        private static bool ProductGT10(Point p)
        {
            if (p.X * p.Y > 100000)
                return true;
            else
                return false;
        }
    }
}

也可以这些写:

图片 65图片 66View Code

Point[] points = { 
                     new Point(){X = 100,Y = 200}, new Point(){X = 150,Y = 250}, 
                     new Point(){X = 250,Y = 375}, new Point(){X = 275,Y = 395}, 
                     new Point(){X = 295,Y = 450}, new Point(){X = 290,Y = 451}
                 };

Point first = Array.Find(points,
    (p) =>
    {
        if (p.X * p.Y > 100000)
            return true;
        else
            return false;
    });
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();

说明:无需显示创建委托,或是指定泛型方法的参数类型,因为编译器会根据上下文自己确定。

 

图片 67图片 68

2.测试和打印分开

 

参考资料

 


  • MSDN 声明、实例化和使用委托.aspx) 
  • MSDN 提供的委托 
  • 事件(C# 编程指南).aspx)
  • 委托(C# 编程指南).aspx)
  • C# 3.0 Cookbook, Third Edition: More than 250 solutions for C# 3.0 programmers-Delegates, Events, and Lambda Expressions
  • C# 3.0: Master the fundamentals of C# 3.0-Delegates and Events
  • 程序设计_猫老鼠主人

 

 1  public class Product
 2     {
 3         public string Name { get; private set; }
 4         public string Price { get; private set; }
 5 
 6         public Product(string name, decimal price)
 7         {
 8            
 9               Name = name;
10               Price = price;
11         }
12 
13         private Product()
14         {
15         }
16 
17         public static List<Product> GetSampleProducts()
18         {
19             return new List<Product>
20             {
21                 new Product {Name = "West Side Story", Price = 9.99m},
22                 new Product {Name = "Assassins", Price = 14.99m},
23                 new Product {Name = "Frogs", Price = 13.99m},
24                 new Product {Name = "Sweeney Todd", Price = 10.99m}
25             };
26         }
27 
28         public override string ToString()
29         {
30             return string.Format("{0}: {1}", Name, Price);
31         }
32       
33     }

C#2.0

匿名方法

虽然先有的匿名方法,后有的 Lambda 表达式,但仍然在 Lambda 后说明匿名方法。

在 2.0 之前的 C# 版本中,声明委托的唯一方法是使用命名方法(也就是用方法名初始化委托)。C# 2.0 引入了匿名方法,而在 C# 3.0 及更高版本中,Lambda 表达式取代了匿名方法,作为编写内联代码的首选方式。

不过,本节有关匿名方法的信息同样适用于 Lambda 表达式。有一种情况,匿名方法提供了 Lambda 表达式中所没有的功能。匿名方法使您能够省略参数列表,这意味着可以将匿名方法转换为带有各种签名的委托。这对于 Lambda 表达式来说是不可能的。

下面演示实例化委托的两种方法,都会在调用委托时显示一条消息:

  • 使委托与匿名方法关联。
  • 使委托与命名方法 (DoWork) 关联。

图片 69图片 70View Code

// Declare a delegate
delegate void Printer(string s);

class TestClass
{
    static void Main()
    {
        // Instatiate the delegate type using an anonymous method:
        Printer p = delegate(string j)
        {
            System.Console.WriteLine(j);
        };

        // Results from the anonymous delegate call:
        p("The delegate using the anonymous method is called.");

        // The delegate instantiation using a named method "DoWork":
        p = new Printer(TestClass.DoWork);

        // Results from the old style delegate call:
        p("The delegate using the named method is called.");
    }

    // The method associated with the named delegate:
    static void DoWork(string k)
    {
        System.Console.WriteLine(k);
    }
}

运行结果:

图片 71图片 72View Code

The delegate using the anonymous method is called.
The delegate using the named method is called.

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

例如,如果创建方法所需的系统开销是不必要的,则指定代码块(而不是委托)可能非常有用。启动新线程即是一个很好的示例。无需为委托创建更多方法,线程类即可创建一个线程并且包含该线程执行的代码。

图片 73图片 74View Code

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

 

修改记录


  • 2015年1月29日 【UPDATE】

 

下载 Deom

下载更多 Demo

View Code

product类

参考资料

Wiki Lambda 表达式

MSDN 匿名函数

MSDN 委托Func<Of T, TResult>

MSDN 表达式树Expression<Func>

System.Linq.Enumerable 类

System.Linq.Queryable 类

Good Math, Bad Math 关于Lambda 阐述

 

Alonzo Church 1936 论文下载

C#4中命名实参

图片 75图片 76

图片 77图片 78

 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp2
 5 {
 6     [Description("Listing 1.02")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13             private set { name = value; }
14         }
15 
16         decimal price;
17         public decimal Price
18         {
19             get { return price; }
20             private set { price = value; }
21         }
22 
23         public Product(string name, decimal price)
24         {
25             Name = name;
26             Price = price;
27         }
28 
29         public static List<Product> GetSampleProducts()
30         {
31             List<Product> list = new List<Product>();
32             list.Add(new Product("West Side Story", 9.99m));
33             list.Add(new Product("Assassins", 14.99m));
34             list.Add(new Product("Frogs", 13.99m));
35             list.Add(new Product("Sweeney Todd", 10.99m));
36             return list;
37         }
38 
39         public override string ToString()
40         {
41             return string.Format("{0}: {1}", name, price);
42         }
43     }
44 }
 1 public class Product
 2     {
 3      
 4         public override string ToString()
 5         {
 6             return string.Format("{0}: {1}", name, price);
 7         }
 8         //C#4中的参数:尽管私有赋值不能被公共的改变,但如果要求它也不能被私有的改变,将会更加的清晰,在C#4中,我们用调用构造函数时指定实参的名称
 9         readonly string name;
10         public string Name { get { return name; } }
11         return new List<Product>
12         {
13             new Product {name = "West Side Story", price = 9.99m},
14             new Product {name = "Assassins", price = 14.99m},
15             new Product {name = "Frogs", price = 13.99m},
16             new Product {name = "Sweeney Todd", price = 10.99m},
17         };
18 
19 
20     }

View Code

View Code

ListQueryWithDelegates类

2、排序和过滤的演化

图片 79图片 80

 1、排序

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.11")]
 8     class ListQueryWithDelegates
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             Predicate<Product> test = delegate(Product p)
14                 { return p.Price > 10m; };
15             List<Product> matches = products.FindAll(test);
16 
17             Action<Product> print = Console.WriteLine;
18             matches.ForEach(print);
19         }
20     }
21 }

C#1中使用IComparer对ArrayList进行排序

View Code

图片 81图片 82

变量test的初始化使用了匿名方法,而print变量的初始化使用了方法组转换,它简化了从现有方法创建委托的过程。不仅简单而且强大!

 1 class ProductNameComparer : IComparer
 2         {
 3             public int Compare(object x, object y)
 4             {
 5                 Product first = (Product)x;
 6                 Product second = (Product)y;
 7                 return first.Name.CompareTo(second.Name);
 8             }
 9         }
10  static void Main()
11         {
12             ArrayList products = Product.GetSampleProducts();
13             products.Sort(new ProductNameComparer());
14             foreach (Product product in products)
15             {
16                 Console.WriteLine(product);
17             }
18         }

ListQueryWithDelegatesCompact类

View Code

图片 83图片 84

C#2中使用IComparer<product>对List<Product>进行排序

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.12")]
 8     class ListQueryWithDelegatesCompact
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             products.FindAll(delegate(Product p) { return p.Price > 10; })
14                     .ForEach(delegate(Product p) { Console.WriteLine(p); });
15         }
16     }
17 }

图片 85图片 86

View Code

 1  class ProductNameComparer : IComparer<Product>
 2         {
 3             public int Compare(Product x, Product y)
 4             {
 5                 return x.Name.CompareTo(y.Name);
 6             }
 7         }
 8 static void Main()
 9 {
10  List<Product> products = Product.GetSampleProducts();
11  products.Sort(new ProductNameComparer());
12             foreach (Product product in products)
13             {
14                 Console.WriteLine(product);
15             }
16 }

3.用lambda表达式来测试

View Code

C#3.0

C#2中使用委托进行比较

product

图片 87图片 88

图片 89图片 90

1  /* 
2          * C#2的方法1确实有了一定的改进,但是我们希望能直接指定要进行的标胶,就能开始对产品进行排序,而不需要实现一个接口来做这件事
3          * 下面它告诉sort方法如何用一个委托来比较俩个产品.省略了接口实现的代码和products.Sort(new ProductNameComparer());
4          * List<Product> products = Product.GetSampleProducts();
5          * products.Sort(delegate (Product x,Product y)
6          * {return x.Name.CompareTo(y.Name);}
7          * );
8          */
 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp3
 5 {
 6     [Description("Listing 1.3")]
 7     class Product
 8     {
 9         public string Name { get; private set; }
10         public decimal Price { get; private set; }
11 
12         public Product(string name, decimal price)
13         {
14             Name = name;
15             Price = price;
16         }
17 
18         Product()
19         {
20         }
21 
22         public static List<Product> GetSampleProducts()
23         {
24             return new List<Product>
25             {
26                 new Product { Name="West Side Story", Price = 9.99m },
27                 new Product { Name="Assassins", Price=14.99m },
28                 new Product { Name="Frogs", Price=13.99m },
29                 new Product { Name="Sweeney Todd", Price=10.99m}
30             };
31         }
32 
33         public override string ToString()
34         {
35             return string.Format("{0}: {1}", Name, Price);
36         }
37     }
38 }

View Code

View Code

C#3中使用lambda表达式进行比较

ListQueryWithLambdaExpression类

图片 91图片 92

图片 93图片 94

 1  List<Product> products = Product.GetSampleProducts();
 2 products.Sort((x,y)=>x.Name.CompareTo(y.Name));
 3 foreach(Product product in products)
 4 {
 5          console.writeline(product);
 6 }
 7 C#3还有另一种写法排序
 8 foreach(Product product in product.OrderBy(p=>p.Name))
 9 {
10          console.writeline(product);//通知轻松的按顺序打印名称,同时不必修改原产品列表
11 }
 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 using System.Linq;
 5 
 6 namespace Chapter01.CSharp3
 7 {
 8     [Description("Listing 1.13")]
 9     class ListQueryWithLambdaExpression
10     {
11         static void Main()
12         {
13             List<Product> products = Product.GetSampleProducts();
14             foreach (Product product in products.Where(p => p.Price > 10))
15             {
16                 Console.WriteLine(product);
17             }
18         }
19     }
20 }

View Code

View Code

  2、查询

总结:

   循环、测试和打印(C#1)

→C#1,条件和操作紧密耦合两者都是硬编码的

图片 95图片 96

→C#2,条件和操作分开,匿名方法使委托变得简单(匿名方法有助于问题的可分离性)

1  ArrayList products = Product.GetSampleProducts();
2             foreach (Product product in products.Cast<Product>().Where(product => product.Price > 10m))
3             {
4                 Console.WriteLine(product);
5             }

→C#3Lambda表达式使条件变得更容易阅读(Lambda表达式增强了可读性)。

View Code

  测试和打印分开进行(C#2)

图片 97图片 98

1 List<Product> products =Product.GetSampleProducts();
2           Predicate<Product> test = delegate(Product p){ return p.Price > 10m;};
3            List<Product>  matches=products.FindAll(test);
4           Action<Product> print=console.writeLine;
5           matches.ForEach(print);

View Code

测试和打印分开进行的另一个版本(C#2)

List<Product> products =Product.GetSampleProducts();
products.FindAll(delegate (Product p){ return p.Price >10;}).ForEach(Console.WriteLine);

用lambda表达式来进行测试(c#3)

List<Product> products =Product.GetSampleProducts();
foreach(Product product in products.Where(p=>p.price>10))
{
    Console.WriteLine(product);
}

C#中使用Linq表达式

foreach (Product product in products.Cast<Product>().Where(product => product.Price > 10m))
{
Console.WriteLine(product);
}

 

本文由pc28.am发布于计算机编程,转载请注明出处:开发的进化史,中的发展

上一篇:求大神指点,一种将文本编码为图片格式的方法 下一篇:没有了
猜你喜欢
热门排行
精彩图文