C#:为什么在多线程环境中操作委托是线程安全的? 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#的委托出现

csharp 复制代码
 	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.委托和类一样.但类是数据和方法的集合,委托只是方法集合,所以委托的声明应该放在命名空间中,与类同级别.

csharp 复制代码
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关键字开头,跟想用使用的方法有相同的参数和返回类型.(参数名不需要相同).

csharp 复制代码
delegate int Cal(int a, int b);
public int Sum(int a, int b)

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

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

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

csharp 复制代码
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.快捷语法

csharp 复制代码
Cal cal1 = new Cal(calculator.Sum);
Cal cal2 = calculator.Su

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

csharp 复制代码
cal1 = Calculator.Sub;

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

组合委托

csharp 复制代码
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);
        }
    }
}

委托变量+=方法,会把方法添加到调用列表里面.

如果委托变量-=方法,会把方法踢出到调用列表,如果有多份(踢掉列表最后的那份)

组合委托在调用时,会执行多个方法(委托的调用列表里面的方法).

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

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

调用带有返回值的委托

csharp 复制代码
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));
        }
    }

}

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

调用带引用的委托

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

csharp 复制代码
    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));
        }
    }

总结

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

相关推荐
薰衣草23333 小时前
滑动窗口(2)——不定长
python·算法·leetcode
房屋安全鉴定检测5 小时前
房屋安全鉴定注意事项
安全·网络安全
房屋安全鉴定检测5 小时前
房屋安全鉴定机构服务内容
安全·网络安全
金融小师妹5 小时前
基于哈塞特独立性表态的AI量化研究:美联储政策独立性的多维验证
大数据·人工智能·算法
碳水加碳水8 小时前
Java代码审计实战:XML外部实体注入(XXE)深度解析
java·安全·web安全·代码审计
纪元A梦8 小时前
贪心算法应用:化工反应器调度问题详解
算法·贪心算法
阿让啊9 小时前
C语言strtol 函数使用方法
c语言·数据结构·c++·单片机·嵌入式硬件
深圳市快瞳科技有限公司9 小时前
小场景大市场:猫狗识别算法在宠物智能设备中的应用
算法·计算机视觉·宠物
liulilittle9 小时前
OPENPPP2 —— IP标准校验和算法深度剖析:从原理到SSE2优化实现
网络·c++·网络协议·tcp/ip·算法·ip·通信
Haven-11 小时前
Java-面试八股文-JVM篇
java·jvm·面试