C#:为什么在多线程环境中操作委托是线程安全的? c的函数指针=＞C#委托进化过程详解

---

---

函数指针=>委托

typedef int (*Cal)(int, int);  //定义函数指针
int Sum(int a, int b)
{
	return a + b;
}
int main()
{
	int a = 9, b = 2, c = 0;
	c = Sum(a, b);
	printf("%d\n", c);

	Cal cal = ∑  //创建Sum的函数指针变量cal
	c = cal(a, b);
	printf("%d\n", c);
	return 0;
}

//都输出11

Sum(a, b):直接调用==>CPU通过函数名直接获得函数地址并开始执行.
cal(a, b):间接调用==>通过函数指针来调用函数,CPU通过函数指针指向的值找到函数的地址并开始执行.
上面两者的实现效果一样.

那么问题来了,大家不觉得上面的函数指针实现语法*typedef int (Cal)(int, int); 太复杂了?感觉功能也比较单一,用起来太麻烦.所以就有了C#的委托出现

 	delegate int Cal(int a,int b);
    class Program
    {
        static void Main(string[] args)
        {
            int a = 9, b = 2;
            Console.WriteLine(Sum(a,b));

            Cal cal = new Cal(Sum);
            Console.WriteLine(cal(a,b));
        }
        static int Sum(int a,int b)
        { return a + b; }
    }

C#中委托的声明和像函数的声明,只需要在前面加delegate关键字.
用上面的代码就可以实现C语言函数指针同样的效果.但使用起来更加方便.且委托的用处远不止于此.

使用委托

1.委托和类一样.但类是数据和方法的集合,委托只是方法集合,所以委托的声明应该放在命名空间中,与类同级别.

namespace shh
{
    delegate int Cal(int a, int b);

    class Calculator
    {
        public int Sum(int a, int b)
        { return a + b; }
        public int Sub(int a, int b)
        { return a - b; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Cal cal = new Cal(calculator.Sum);
            Console.WriteLine(cal(9,2));
        }
    }
}

2.委托以delegate关键字开头,跟想用使用的方法有相同的参数和返回类型.(参数名不需要相同).

delegate int Cal(int a, int b);
public int Sum(int a, int b)

3.创建委托类型变量和创建委托对象不同

 Cal cal ;//创建委托类型变量,没有在堆上开空间
 cal = new Cal(calculator.Sum);//创建委托对象,在堆上开空间

4.创建委托对象可以使用实例方法和静态方法

namespace shh
{
    delegate int Cal(int a, int b);

    class Calculator
    {
        public int Sum(int a, int b)
        { return a + b; }
        public static int Sub(int a, int b)
        { return a - b; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Cal cal1 = new Cal(calculator.Sum);
            Cal cal2 = new Cal(Calculator.Sub);
        }
    }

}

这里需要注意的是静态方法得用类名.方法(Calculator.Sub)

5.快捷语法

Cal cal1 = new Cal(calculator.Sum);
Cal cal2 = calculator.Su

两条语句等价,系统会自动识别并进行类型转换.
6.给委托赋值
改变委托变量的引用.赋值会创建新的委托,旧的委托会被回收

cal1 = Calculator.Sub;

创建新的委托除了为委托分配内存,还会把第一个方法(Sub)添加到委托的调用列表里面.

组合委托

namespace shh
{
    delegate void Cal(int a, int b);

    class Calculator
    {
        public void  Sum(int a, int b)
        { Console.WriteLine(a+b); }
        public void Sub(int a, int b)
        { Console.WriteLine(a-b); }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Cal cal1 = new Cal(calculator.Sum);
            cal1 += calculator.Sub;
            cal1(9, 2);
        }
    }
}

委托变量+=方法,会把方法添加到调用列表里面.
如果委托变量-=方法,会把方法踢出到调用列表,如果有多份(踢掉列表最后的那份)
组合委托在调用时,会执行多个方法(委托的调用列表里面的方法).

为什么在多线程环境中操作委托是线程安全的

这个运算会创建一个新的委托,旧的委托会被垃圾回收器回收.这也是为什么在多线程环境中，操作委托是线程安全的，因为每次修改都会创建一个新的对象，不会影响其他线程对旧对象的使用。

调用带有返回值的委托

namespace shh
{
    delegate int Cal(int a, int b);

    class Calculator
    {
        public int Sum(int a, int b)
        { return a + b; }
        public int Sub(int a, int b)
        { return a - b; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Cal cal1 = new Cal(calculator.Sum);
            cal1 += calculator.Sub;
            Console.WriteLine(cal1(9,2));
        }
    }

}

只会返回最后一个方法返回的值,其他值都会被忽略.

调用带引用的委托

这个也很好理解,因为我们调用委托时是按照他参数列表的顺序进行的,使用引用的值会被不断地加.

    delegate int MyDel(ref int a);

    class Test
    {
        public int Add1(ref int a)
        { return a += 5; }
        public int Add2(ref int a)
        { return a += 10; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Test test = new Test();
            MyDel mydel = test.Add1;
            mydel += test.Add2;
            int a = 0;
            Console.WriteLine(mydel(ref a));
        }
    }

总结

委托其实很好理解,使用也很简单.就是一个函数指针的进化体,不要被他的名字吓住了.无非就是功能和使用体验上会优于函数指针.