c#

2.2 有关委托
委托的实际其实就是一个函数指针，在.NET中有相当多现成的委托方法可直接使用，这些委托被应用在了很多常用类型的方法当中。灵活应用这些.NET委托可以实现回调机制、事件机制等等，这些机制都为代码设计的解耦和、减轻代码量提供了很好的解决方案。

以下是几个常用官方委托：

委托名称 说明 场景举例
Func<……> 自由功能，包含一个或多个入参，返回一个制定类型的委托 Func<string, int>：入参为string类型，返回了一个int类型结果
Predicate 是否符合条件，包含一个入参，返回一个bool类型 一般用于判断入参是否符合某个条件，例如List.FindAll(Predicate)
Action 执行动作，包含一个入参，没有返回值，即直接利用入参执行某项操作 一般用于不需要返回结果直接执行动作场景，例如List.ForEach(Action)
举个例子体会一下
在很多最为基础的BCL类型当中，比如List容器类型，都会大量的使用到委托，可以据一个例子体验一下委托的用法：

比如FindAll方法：在容器当中寻找符合特定条件的对象。而这种条件是需要程序员自定义的，而这个定义就是一个委托（即程序员“委托”List的FindAll方法，帮我找出符合我提出条件的对象）

可以使用至少三种的委托方法去实现这个委托功能：
-----实现方法一：自定义委托或框架提供的委托(例子来自MSDN)

// 声明一个Predicate委托，实现容器FindAll方法的回调机制
Predicate predicate = FindSomething;
List FindPoint = PointList.FindAll(predicate);
foreach(Point obj in FindPoint)
{
// Do Something;
}
……

// 在其他某个地方定义的委托(函数指针)对应的函数：寻找X乘以Y大于10000的点
private static bool FindSomething(Point obj)
{
return obj.X * obj.Y > 100000;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
-----实现方法二：匿名函数
这种实现方法与普通委托一样，但是更加便捷，不用单独声明

Predicate predicate = delegate(Point obj) { return obj.X * obj.Y > 100000; };
List FindPoint = PointList.FindAll(predicate);
foreach(Point obj in FindPoint)
{
// Do Something;
}
1
2
3
4
5
6
-----实现方法三：lambda表达式

C#3.0引入了lambda表达式，Lambda表达式实际上也是一个委托

下边这个例子可以看出，lambda表达式又减少了一部分代码量，且可读性也更加清晰，但并没有体现出跨越式的优点

Predicate FindFunc2 = p => p.X * p.Y > 100000;
List FindRet2 = list4.FindAll(FindFunc2);
foreach(Point obj in FindPoint)
{
// Do Something;
}
1
2
3
4
5
6
以下例子是直接使用lambda表达式到迭代器中，更加直接的体现出lambda表达式的优势，也减少了没有必要的代码量

foreach(Point listobj in list.Where( p => p.X * p.Y > 100000 ))
{
// Do Something
}
1
2
3
4
2.3 有关泛型
泛型在使用上像极了C++当中的模板，在C#当中，泛型有以下几点好处

避免了强制类型转换带来的装箱拆箱。在BCL中，微软也提供了大量现成的泛型类，比如使用最为广泛的List
可以实现一种代码重用机制：“算法重用”，比如开发人员定义的排序算法并不需要指定某种类型，而是让调用这个算法的开发人员去指定类型

泛型的种类：

泛型类型
泛型接口
泛型委托
泛型方法
一个有关于泛型的典型例子就是有利用泛型定义一个链表，这个链表可以存储任意类型的数据：

///
/// 抽象出链表指向Next的节点;
/// 这样就可以保证一串链表中的每一个数据都可以是不同的类型了;
/// 原因：TypeLNode都被看做是LNode;
///
public class LNode
{
protected LNode m_Next;

public LNode(LNode next_node)
{
    m_Next = next_node;
}

}

///
/// 一个泛型类型的链表;
/// 他的好处是：不限制链表中类型的种类，可以在数据中填充任意类型;
///
///
public class TypeLNode : LNode
{
public T m_data;
public TypeLNode(T data) : this(data, null)
{

}

/// <summary>
/// 创建一个链表中的一个节点，需要它本身的数据和它的下一条数据;
/// </summary>
/// <param name="data"></param>
/// <param name="next_node"></param>
public TypeLNode(T data, LNode next_node) : base(next_node)
{
    m_data = data;
}

}