C#知识点整理（1）-委托

1.概念：

–委托-一种特殊类型的对象，我们以前定义的所有对象都包含数据，而委托包含的是一个或多个方法的地址。

–定义委托基本上是定义一个新类，所以可以在定义类的任何地方定义委托。

–即“定义一个委托”是指“定义一个新类”。

–实例：

public delegate string GetAString();//定义委托

int x=0;
GetAString stringMethod=new GetAString(x.ToString);//声明并初始化委托的实例
//stringMethod=x.ToString;//委托推断
stringMethod();//调用委托
GetAString AnonymousMethod = delegate () { return "a string"; };//用匿名方法初始化委托实例
GetAString lambdaMethod = （）=>{ return "a string"; };//用Lambda表达式初始化带有参数的委托

2.注意点：

–委托的实例可以引用任何类型的任何对象上的实例方法或静态方法，只要方法的签名匹配于委托的签名的即可。

–两个泛型委托的使用：

//Action<T>和Func<T>
public static void WriteAString()
{
Console.WriteLine("A String");
}
Action a=WriteAString;

public static bool StringIsEmpty(string str)
{
if(str==null)
return false;
if(str=="")
return true;
return true;
}
Func<string,bool> f=StringIsEmpty;//Func<in T,out TResult>

–委托数组和多播委托

public delegate void aDelegate();

class program
{
private static void WriteAString()
{
Console.WriteLine("A String");
}
aDelegate[] delegateArr=new aDelegate[5];//委托数组
Action operations=WriteAString;
operations+=WriteAString;
operations();//多播委托，包含多个方法，此时会调用两次WriteAString（）
}

3.使用案例：

–用于给特定类型的对象进行排序。这里使用的是冒泡排序算法，算法的思路是固定的，问题在于只有int类型的对象才能使用比较运算符进行大小比较，而对于其它类型的对象，必须得指定相应的比较方法，这里就可以用委托来传递这个比较方法，从而实现适用于任何类型的冒泡排序方法。

//使用int类型的冒泡排序;
public static void BubbleSorter(int[] intArr)
{
bool swapped = true;
do
{
swapped = false;
for (int i = 0; i < intArr.Length - 1; i++)
{
if (intArr[i] > intArr[i + 1])
{
int temp = intArr[i];
intArr[i] = intArr[i + 1];
intArr[i + 1] = temp;
swapped = true;
}
}
} while (swapped);
}

//可用于通用类型的冒泡排序
public static void BubbleSorterCom<T>(IList<T> list, Func<T, T, bool> comparison)
{
bool swapped = true;
do
{
swapped = false;
for (int i = 0; i < list.Count - 1; i++)
{
if (comparison(list[i], list[i + 1]))
{
T temp = list[i];
list[i] = list[i + 1];
list[i + 1] = temp;
swapped = true;
}
}
} while (swapped);
}

–事件，事件由委托来实现，为委托提供了一种发布/订阅机制。

示例代码中，定义了两个类，

一个是CarDealer–汽车处理商，用于声明事件NewCarInfo，该事件在新车到达时触发，属于事件发布器。

另一个是Consumer–消费者，用于包含消费者信息，并声明当新车到达时的动作，即事件侦听器，包含事件处理程序。

一个完整的事件是需要多方协同才能完成的，CarDealer发布了事件，Consumer订阅了该事件，当事件触发时，Consumer侦听到了该事件，并获得了事件触发时传递来的相应信息，Consumer处理这些信息，然后这个事件完成。

//用于给特定事件传递数据，必须得继承于EventArgs
public class CarInfoEventArgs:EventArgs
{
public CarInfoEventArgs(string car)
{
this.Car = car;
}
public string
4000
Car { get; private set; }
}

//汽车处理商类
public class CarDealer
{
public event EventHandler<CarInfoEventArgs> NewCarInfo;
public void NewCar(string car)
{
Console.WriteLine("CarDealer,new car {0}", car);
NewCarInfo.Invoke(this, new CarInfoEventArgs(car));
}
}

//消费者类
public class Consumer
{
private string name;

public Consumer(string name)
{
this.name = name;
}

public void NewCarIsHere(object sender, CarInfoEventArgs e)
{
Console.WriteLine("{0} : car {1} is new", name, e.Car);
}
}

//示例
class Program
{
static void Main(string[] args)
{
var dealer = new CarDealer();

var michael = new Consumer("Michael");
dealer.NewCarInfo += michael.NewCarIsHere;//michael订阅了事件

dealer.NewCar("Ferrari");//触发事件
Console.WriteLine();
Console.ReadKey();
}
}

4.结尾：

在设计大型应用程序时，使用委托和事件可以减少依赖性和层的耦合，并能开发出具有更高重用性的组件。

耦合性：是一种软件度量，是指一程序中，模块及模块之间信息或参数依赖的程度。

内聚性：是一个和耦合性相对的概念，一般而言低耦合性代表高内聚性，反之亦然。

耦合性和内聚性都是由提出结构化设计概念的赖瑞·康斯坦丁所提出。低耦合性是结构良好程序的特性，低耦合性程序的可读性及可维护性会比较好。

理解：使用委托和事件，可以使得事件发布器不直接调用事件侦听器中方法，而是通过订阅的方式，也就是传递方法地址的形式进行调用。这样事件发布器可以始终是固定的，面对不同的事件需要不同的事件处理程序，此时只要给出相应的事件侦听器就可。在有效的分离了事件发布器和事件侦听器之后，可以减少依赖性和层的耦合，如Button中的Click事件。