【C#】委托

1.委托 delegate

委托是一种引用类型，能封装一个或者多个方法。类似于C++中的函数指针，但是比指针更灵活、安全。

C++中函数指针通常用于：

1.动态调用函数：在编译时不调用，而是在运行时。

2.回调机制：异步操作中

3.实现策略模式：允许在运行时选择算法或策略

4.简化代码：将函数作为参数传入，封装好只用一个函数调用。

简单的委托代码：

using System;
namespace DelegateExample
{
    // 定义一个委托类型，用于封装数学操作
    public delegate double MathOperation(double a, double b);
    class Program
    {
        static void Main(string[] args)
        {
            // 创建委托实例并指向不同的数学操作方法
            // 两种写法，都可以
            MathOperation add = new MathOperation(Add);
            MathOperation subtract = new MathOperation(Subtract);
            MathOperation multiply = Multiply;
            MathOperation divide = Divide;
            // 使用委托调用方法
            double x = 10;
            double y = 5;
            Console.WriteLine($"Adding {x} and {y}: {add(x, y)}");
            Console.WriteLine($"Subtracting {y} from {x}: {subtract(x, y)}");
            Console.WriteLine($"Multiplying {x} and {y}: {multiply(x, y)}");
            Console.WriteLine($"Dividing {x} by {y}: {divide(x, y)}");
            Console.ReadKey();
        }
        // 加法
        public static double Add(double a, double b)
        {
            return a + b;
        }
        // 减法
        public static double Subtract(double a, double b)
        {
            return a - b;
        }
        // 乘法
        public static double Multiply(double a, double b)
        {
            return a * b;
        }
        // 除法
        public static double Divide(double a, double b)
        {
            if (b == 0)
            {
                throw new DivideByZeroException("Divider cannot be zero.");
            }
            return a / b;
        }
    }
}

上述代码可能感受不直观，下面是两组对比：

前者是正常的函数实现，可以发现代码重复量很多，方法结构、传参方式很相似。

using System;
using System.Collections.Generic;
class Program
{
    static double Sum(List values)
    {
        double result = 0;
        foreach (double value in values)
        {
            result += value;
        }
        return result;
    }
    static double Average(List values)
    {
        if (values.Count == 0) return 0;
        return Sum(values) / values.Count;
    }
    static double Max(List values)
    {
        if (values.Count == 0) return 0;
        double result = values[0];
        foreach (double value in values)
        {
            if (value > result)
            {
                result = value;
            }
        }
        return result;
    }
    static double Min(List values)
    {
        if (values.Count == 0) return 0;
        double result = values[0];
        foreach (double value in values)
        {
            if (value  
下面是用函数委托来实现：
 
using System;
using System.Collections.Generic;
class Program
{
    // 定义一个委托类型，用于封装数学操作
    public delegate double MathOperation(double a, double b);
    // 定义一个通用的操作方法
    static double ApplyOperation(List values, MathOperation operation, double initialValue)
    {
        double result = initialValue;
        foreach (double value in values)
        {
            result = operation(result, value);
        }
        return result;
    }
    // 各种具体的操作方法
    static double SumOperation(double a, double b) => a + b;
    static double MaxOperation(double a, double b) => (a > b) ? a : b;
    static double MinOperation(double a, double b) => (a  ApplyOperation(values, SumOperation, 0);
    static double Average(List values) => values.Count == 0 ? 0 : Sum(values) / values.Count;
    static double Max(List values) => values.Count == 0 ? 0 : ApplyOperation(values, MaxOperation, values[0]);
    static double Min(List values) => values.Count == 0 ? 0 : ApplyOperation(values, MinOperation, values[0]);
    static void Main()
    {
        List values = new List { 1.5, 2.5, 3.5, 4.5 };
        Console.WriteLine("Sum: " + Sum(values));
        Console.WriteLine("Average: " + Average(values));
        Console.WriteLine("Max: " + Max(values));
        Console.WriteLine("Min: " + Min(values));
    }
}
 
2.Lambda表达式
 
本质为匿名函数，现代C#已经用lambda表达式逐步代替匿名函数了。
语法格式：
（参数列表）=> {语句序列}；
 
因为lambda依附于委托，所以也要遵循委托的限制。
 
 
 
1.参数列表中的参数个数应该由相应的委托限制。
2.参数列表中限制只有一个参数时，参数列表（）括号可以省略。
3.当编译器能自动推断参数类型时，参数列表中可以不写类型。
4.委托声明中对参数加入了ref和out限制，lambda中也要加上。
5.当右侧语句序列中只有一条语句，{}花括号可以省略。
6.有返回值，必须用return；如果语句序列中只有一个时，return可以省略。
7.如果委托有返回值类型，则lambda也必须有同类型返回值。