C#中的委托

最新推荐文章于 2024-08-19 08:44:06 发布
最新推荐文章于 2024-08-19 08:44:06 发布
阅读量335 收藏 5
点赞数 5
分类专栏： C# 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wy2458984254/article/details/141185919
版权

参考资源

刘铁猛老师《C#入门详解》

1 什么是委托？

类似于C和C++中的函数指针，实现间接调用函数的功能。委托是函数指针的“升级版”

1.1 函数指针的示例

#include <iostream>
using namespace std;

typedef int(*Calc)(int a, int b);

int Add(int a, int b)
{
    int result = a + b;
    return result;
}

int Sub(int a, int b)
{
    int result = a - b;
    return result;
}

int main()
{
    int x = 100;
    int y = 200;
    int z = 0;

    Calc funcPoint1 = &Add;
    Calc funcPoint2 = &Sub;

    cout << "Call directly with the function name:" << endl;
    z = Add(x, y);
    cout << "x + y = " << z << endl;
    z = Sub(x, y);
    cout << "x - y = " << z << endl;

    cout << "Call indirectly using function Pointers:" << endl;
    z = funcPoint1(x, y);
    cout << "x + y = " << z << endl;
    z = funcPoint2(x, y);
    cout << "x - y = " << z << endl;

输出结果：

Call directly with the function name:
x + y = 300
x - y = -100
Call indirectly using function Pointers:
x + y = 300
x - y = -100

1.2 委托的示例

C#中常见的两种委托：

  1. action：接收没有返回值的委托
  2. func：接收有返回值的委托
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelegateExample
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Action action = new Action(calculator.Report);
            calculator.Report();
            action.Invoke();
            action();

            Func<int, int, int> func1 = new Func<int, int, int> (calculator.Add);
            Func<int, int, int> func2 = new Func<int, int, int> (calculator.Sub);

            int x = 100;
            int y = 200;
            int z = 0;

            z = func1.Invoke(x, y);
            Console.WriteLine(z);
            z = func2.Invoke(x, y);
            Console.WriteLine(z);
            Console.ReadKey();
        }
    }

    internal class Calculator
    {
        public void Report()
        {
            Console.WriteLine("I have 3 methods.");
        }
        public int Add(int a, int b)
        {
            int result = a + b;
            return result;
        }
        public int Sub(int a, int b)
        {
            int result = a - b;
            return result;
        }
    }
}

输出结果

I have 3 methods.
I have 3 methods.
I have 3 methods.
300
-100

2 委托的声明(自定义委托)

  1. 委托是一种类

  2. 委托声明方式是仿照C和C++函数指针的方式

  3. 注意声明的位置

    • 不要写错位置变成嵌套类

  4. 委托和所封装的方法必须“类型兼容”

    • 返回值的数据类型一致
    • 参数列表在个数和数据类型上一致（参数名不需要一样）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelegateExample
{
    public delegate double Calc(double x, double y);
    internal class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Calc calc1 = new Calc(calculator.Add);
            Calc calc2 = new Calc(calculator.Sub);
            Calc calc3 = new Calc(calculator.Mul);
            Calc calc4 = new Calc(calculator.Div);

            double a = 100;
            double b = 200;
            double c = 0;

            c = calc1.Invoke(a, b);
            Console.WriteLine(c);
            c = calc2.Invoke(a, b);
            Console.WriteLine(c);
            c = calc3.Invoke(a, b);
            Console.WriteLine(c);
            c = calc4.Invoke(a, b);
            Console.WriteLine(c);

            Console.ReadKey();
        }
    }

    internal class Calculator
    {
        public double Add(double x, double y)
        {
            return x + y;
        }
        public double Sub(double x, double y)
        {
            return x - y;
        }
        public double Mul(double x, double y)
        {
            return x * y;
        }
        public double Div(double x, double y)
        {
            return x / y;
        }
    }
}

输出结果

300
-100
20000
0.5

3 委托的一般使用

3.1 实例

3.1.1 正确使用1：模板方法 ，“借用”指定的外部方法来产生结果

using System;
using System.Collections.Generic;

namespace DelegateExample
{
  
    internal class Program
    {
        static void Main(string[] args)
        {
            ProductFactory productFactory = new ProductFactory();
            WrapFactory wrapFactory = new WrapFactory();

            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
            Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);

            Box box1 = wrapFactory.wrapProduct(func1);
            Box box2 = wrapFactory.wrapProduct(func2);

            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);

            Console.ReadKey();
        }
    }

    class Product
    {
        public string Name { get; set; }
    }

    class Box
    {
        public Product Product { get; set; }
    }

    class WrapFactory
    {
        public Box wrapProduct(Func<Product> getProduct)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            box.Product = product;
            return box;
        }
    }

    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
        public Product MakeToyCar()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            return product;
        }
    }
}

输出结果

Pizza
Toy Car

3.1.2 正确使用2：回调方法，调用指定的外部方法

using System;
using System.Collections.Generic;

namespace DelegateExample
{
  
    internal class Program
    {
        static void Main(string[] args)
        {
            ProductFactory productFactory = new ProductFactory();
            WrapFactory wrapFactory = new WrapFactory();

            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
            Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);

            Logger logger = new Logger();
            Action<Product> log = new Action<Product>(logger.Log);

            Box box1 = wrapFactory.wrapProduct(func1, log);
            Box box2 = wrapFactory.wrapProduct(func2, log);

            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);

            Console.ReadKey();
        }
    }

    class Logger
    {
        public void Log(Product product)
        {
            Console.WriteLine("Product {0} created at {1}. Price is {2}.", 
                product.Name, DateTime.UtcNow,product.Price);
        }
    }

    class Product
    {
        public string Name { get; set; }
        public double Price { get; set; }
    }

    class Box
    {
        public Product Product { get; set; }
    }

    class WrapFactory
    {
        public Box wrapProduct(Func<Product> getProduct, Action<Product> logCallback)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            box.Product = product;
            if (product.Price >= 50)
            {
                logCallback(product);
            }
            return box;
        }
    }

    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            product.Price = 12;
            return product;
        }
        public Product MakeToyCar()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            product.Price = 100;
            return product;
        }
    }
}

输出结果

Product Toy Car created at 2024/8/14 3:18:42. Price is 100.
Pizza
Toy Car

3.2 注意：慎重使用委托

  1. 方法级别的耦合，现实工作中慎重使用
  2. 使得可读性下降、debug的难度增加
  3. 把委托回调、异步调用和多线程纠缠在一起，会让代码变得难以阅读和维护
  4. 委托使用不当有可能造成内存泄漏和程序性能下降

4 委托的高级使用

4.1 多播委托

将多个委托合并起来

using System;
using System.Collections.Generic;
using System.Threading;

namespace MulticastDelegateExample
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };
            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

			// Multicast delegate
            action1 += action2;
            action1 += action3;

            action1.Invoke();

			Console.ReadKey();
        }

        class Student
        {
            public int ID { get; set; }
            public ConsoleColor PenColor { get; set; }
            public void DoHomework()
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.ForegroundColor = this.PenColor;
                    Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

输出结果

Student 1 doing homework 0 hour(s).
Student 1 doing homework 1 hour(s).
Student 1 doing homework 2 hour(s).
Student 1 doing homework 3 hour(s).
Student 1 doing homework 4 hour(s).
Student 2 doing homework 0 hour(s).
Student 2 doing homework 1 hour(s).
Student 2 doing homework 2 hour(s).
Student 2 doing homework 3 hour(s).
Student 2 doing homework 4 hour(s).
Student 3 doing homework 0 hour(s).
Student 3 doing homework 1 hour(s).
Student 3 doing homework 2 hour(s).
Student 3 doing homework 3 hour(s).
Student 3 doing homework 4 hour(s).

4.2 隐式异步调用

4.2.1 同步和异步

串行=同步=单线程，并行=异步=多线程

4.2.2 隐式多线程和显式多线程

1. 直接同步调用：使用方法名
using System;
using System.Collections.Generic;
using System.Threading;

namespace MulticastDelegateExample
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            stu1.DoHomework();
            stu2.DoHomework();
            stu3.DoHomework();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread {0}.", i);
                Thread.Sleep(1000);
            }
        }

        class Student
        {
            public int ID { get; set; }
            public ConsoleColor PenColor { get; set; }
            public void DoHomework()
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.ForegroundColor = this.PenColor;
                    Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

输出结果

Student 1 doing homework 0 hour(s).
Student 1 doing homework 1 hour(s).
Student 1 doing homework 2 hour(s).
Student 1 doing homework 3 hour(s).
Student 1 doing homework 4 hour(s).
Student 2 doing homework 0 hour(s).
Student 2 doing homework 1 hour(s).
Student 2 doing homework 2 hour(s).
Student 2 doing homework 3 hour(s).
Student 2 doing homework 4 hour(s).
Student 3 doing homework 0 hour(s).
Student 3 doing homework 1 hour(s).
Student 3 doing homework 2 hour(s).
Student 3 doing homework 3 hour(s).
Student 3 doing homework 4 hour(s).
Main thread 0.
Main thread 1.
Main thread 2.
Main thread 3.
Main thread 4.
Main thread 5.
Main thread 6.
Main thread 7.
Main thread 8.
Main thread 9.
2. 间接同步调用：使用单播/多播委托
using System;
using System.Collections.Generic;
using System.Threading;

namespace MulticastDelegateExample
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1.Invoke();
            action2.Invoke();
            action3.Invoke();

			// action1 += action2;
			// action1 += action3;
			// action1.Invoke();
            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread {0}.", i);
                Thread.Sleep(1000);
            }
			
			Console.ReadKey();
        }

        class Student
        {
            public int ID { get; set; }
            public ConsoleColor PenColor { get; set; }
            public void DoHomework()
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.ForegroundColor = this.PenColor;
                    Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

输出结果

Student 1 doing homework 0 hour(s).
Student 1 doing homework 1 hour(s).
Student 1 doing homework 2 hour(s).
Student 1 doing homework 3 hour(s).
Student 1 doing homework 4 hour(s).
Student 2 doing homework 0 hour(s).
Student 2 doing homework 1 hour(s).
Student 2 doing homework 2 hour(s).
Student 2 doing homework 3 hour(s).
Student 2 doing homework 4 hour(s).
Student 3 doing homework 0 hour(s).
Student 3 doing homework 1 hour(s).
Student 3 doing homework 2 hour(s).
Student 3 doing homework 3 hour(s).
Student 3 doing homework 4 hour(s).
Main thread 0.
Main thread 1.
Main thread 2.
Main thread 3.
Main thread 4.
Main thread 5.
Main thread 6.
Main thread 7.
Main thread 8.
Main thread 9.
3. 隐式同步调用：使用委托的BeginInvoke
using System;
using System.Collections.Generic;
using System.Threading;

namespace MulticastDelegateExample
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1.BeginInvoke(null, null);
            action2.BeginInvoke(null, null);
            action3.BeginInvoke(null, null);

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread {0}.", i);
                Thread.Sleep(1000);
            }

			Console.ReadKey();
        }

        class Student
        {
            public int ID { get; set; }
            public ConsoleColor PenColor { get; set; }
            public void DoHomework()
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.ForegroundColor = this.PenColor;
                    Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

输出结果

Main thread 0.
Student 3 doing homework 0 hour(s).
Student 1 doing homework 0 hour(s).
Student 2 doing homework 0 hour(s).
Main thread 1.
Student 2 doing homework 1 hour(s).
Student 3 doing homework 1 hour(s).
Student 1 doing homework 1 hour(s).
Student 1 doing homework 2 hour(s).
Student 3 doing homework 2 hour(s).
Student 2 doing homework 2 hour(s).
Main thread 2.
Student 2 doing homework 3 hour(s).
Student 3 doing homework 3 hour(s).
Student 1 doing homework 3 hour(s).
Main thread 3.
Student 2 doing homework 4 hour(s).
Student 3 doing homework 4 hour(s).
Main thread 4.
Student 1 doing homework 4 hour(s).
Main thread 5.
Main thread 6.
Main thread 7.
Main thread 8.
Main thread 9.
4. 显示同步调用：使用Thread或Task
using System;
using System.Collections.Generic;
using System.Threading;

namespace MulticastDelegateExample
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Thread thread1 = new Thread(new ThreadStart(stu1.DoHomework));
            Thread thread2 = new Thread(new ThreadStart(stu2.DoHomework));
            Thread thread3 = new Thread(new ThreadStart(stu3.DoHomework));

            thread1.Start();
            thread2.Start();
            thread3.Start();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread {0}.", i);
                Thread.Sleep(1000);
            }
        }

        class Student
        {
            public int ID { get; set; }
            public ConsoleColor PenColor { get; set; }
            public void DoHomework()
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.ForegroundColor = this.PenColor;
                    Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

输出结果

Student 2 doing homework 0 hour(s).
Student 3 doing homework 0 hour(s).
Student 1 doing homework 0 hour(s).
Main thread 0.
Student 3 doing homework 1 hour(s).
Student 2 doing homework 1 hour(s).
Student 1 doing homework 1 hour(s).
Main thread 1.
Student 3 doing homework 2 hour(s).
Student 1 doing homework 2 hour(s).
Student 2 doing homework 2 hour(s).
Main thread 2.
Student 3 doing homework 3 hour(s).
Student 1 doing homework 3 hour(s).
Main thread 3.
Student 2 doing homework 3 hour(s).
Student 2 doing homework 4 hour(s).
Student 3 doing homework 4 hour(s).
Student 1 doing homework 4 hour(s).
Main thread 4.
Main thread 5.
Main thread 6.
Main thread 7.
Main thread 8.
Main thread 9.

4.2.3 应该适时地使用接口取代一些对委托的使用

using System;
using System.Collections.Generic;

namespace DelegateExample
{

    internal class Program
    {
        static void Main(string[] args)
        {
            IProductFactory pizzaFactory = new PizzaFactory();
            IProductFactory toycarFactory = new ToyCarFactory();

            WrapFactory wrapFactory = new WrapFactory();

            Box box1 = wrapFactory.wrapProduct(pizzaFactory);
            Box box2 = wrapFactory.wrapProduct(toycarFactory);

            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);

            Console.ReadKey();
        }
    }

    interface IProductFactory
    {
        Product Make();

    }

    class PizzaFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
    }

    class ToyCarFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            return product;
        }
    }

    class Product
    {
        public string Name { get; set; }
    }

    class Box
    {
        public Product Product { get; set; }
    }

    class WrapFactory
    {
        public Box wrapProduct(IProductFactory productFactory)
        {
            Box box = new Box();
            Product product = productFactory.Make();
            box.Product = product;
            return box;
        }
    }
}

输出结果

Pizza
Toy Car
况之嘉禾
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中委托用法
09-03
在C#编程语言中，委托（Delegate）是一种强大的特性，它允许我们将方法作为参数传递给其他方法，或者存储和调用方法。这种功能使得代码更加灵活，能够更好地处理回调、事件处理以及策略模式等场景。下面我们将深入...
C#中委托的+=和-=深入研究
09-04
`-=` 操作符则用于从委托中移除指定的方法。例如，如果我们想取消`ShowHello`的注册，我们可以这样做： ```csharp showMsg -= ShowHello; ``` 这样，`showMsg`在后续调用时只会执行`ShowHello1`方法。 在IL（中间...
C#中委托
weixin_46596213的博客
01-30 3980
文章目录一、C#委托二、隐式类型与匿名类型三、C#扩展方法与yield关键字四、Lambda表达式 一、C#委托 举例1： 创建控制台应用程序 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace TheOne { //声明委托 public delegate string Translatio
C#中委托的用法
讲述工作、生活、技术中的日常与感悟。
01-30 3848
前言 大家好，我是阿辉。 昨天大家和我一起学习了，C#中的委托，了解了什么是委托，也简单写了一个委托的完整实例。那么为什么会出现委托！委托该如何使用！ 委托有如下好处： 委托实现了将方法当作参数使用。 在两个不能直接调用的方法中作为桥梁。比如在多线程中的跨线程的方法调用就得用委托。 当不知道方法具体实现什么时使用委托。如事件中使用委托。 委托的用法 给委托赋值 由于委托是引用类型，可通过给它赋值来改变包含在委托变量中的引用，旧的委托将被GC回收处理。 //给委托赋值 testOne
C#中委托和事件的区别详解
u011555996的博客
04-29 1205
事件可以被看作一个委托类型的变量，通过事件注册、取消多个委托或方法。○ 在CLR运行时，委托DoSth实际上就一个类，该类有一个参数类型为方法的构造函数，并且提供了一个Invoke实例方法，用来触发委托的执行。○ 触发委托有2种方式: 委托实例.Invoke(参数列表)，委托实例(参数列表)以上，通过+=为事件注册1个或多个委托实例，实际上，还可以为事件直接注册方法。○ 委托就是一个类，也可以实例化，通过委托的构造函数来把方法赋值给委托实例。而实际上，委托变量(参数列表)，事件就是采用这种形式执行方法的。
C#中委托和匿名方法
wenchm的博客
11-22 929
为了实现方法的参数化，提出了委托的概念，委托是一种引用方法的类型，即委托是方法的引用，一旦为委托分配了方法，委托将与该方法具有完全相同的行为；另外，.NET中为了简化委托方法的定义，提出了匿名方法的概念。
C#之委托
热门推荐
互联网底层民工的博客
07-22 1万+
C#中的委托是一个类型，它描述了一个方法的签名，即方法的参数类型和返回类型。委托可以看作是一个指向方法的引用，使得我们可以像使用函数指针一样调用这些方法。 将一个或多个方法作为参数传递给另一个方法，从而在需要时调用这些方法。 实现事件处理程序。 实现回调方法。 实现异步编程等功能。 委托和类一样，是一种用户定义类型。但类表示的是数据和方法的集合，而委托则持有一个或多个方法，以及一系列预定义操作。可以通过一下操作步骤来使用委托。
C#中委托(中)
cloproad的博客
01-24 1879
一、Action 与Func  除了使用自定义的委托之外，还可以使用 Action 与Func 委托，Action 定义了一个无返回值，参数是T类型的委托，非泛型Action表示无参数无返回值。Func表示有返回值的委托。使用时，返回值的类型在最后声明。 下面给出示例： public class TestDele { // 声明了有一个无参数无返回值的委托引用 public Actio
C#——委托
m0_51743362的博客
11-01 9878
Action是.NET Framework内置的泛型委托，可以使用Action委托以参数形式传递方法，而不用显示声明自定义的委托。使用多播委托就可以按照顺序调用多个方法，多播委托只能得到调用的最后一个方法的结果，一般我们把多播委托的返回类型声明为void。引用可在运行时被改变。定义了一个委托叫做 IntMethodInvoker ，这个委托可以指向带有一个int类型的参数，并且返回值是void的一个方法。在定义好委托后就可以实例化委托，命名方法委托在实例化委托时必须带入方法的具体名称或者是null。
C# 委托详解
ellis1970的博客
07-22 1512
C#中委托也叫代理，委托提供了后期绑定机制(官方解释)，功能类似于C++中的函数指针，它存储的就是一系列具有相同签名和返回类型的方法的地址，调用委托的时候，它所包含的所有方法都会被执行。
C# 中委托和事件的区别
程序员思维的博客
11-14 1280
C# 中委托和事件的区别
对c#中委托的理解
09-05
在C#编程语言中，委托是类型安全的函数指针，它允许我们将方法作为参数传递给其他方法，或者将一组方法绑定到一个事件处理程序。在本文中，我们将深入探讨C#中的委托及其用途。 首先，让我们通过一个简单的例子来...
C#中委托的进一步理解
09-03
在C#编程语言中，委托是一种强大的特性，它允许我们将方法作为参数传递给其他方法，或者将多个方法链接在一起形成事件处理链。本文将进一步探讨C#中的委托，重点关注委托类型、建立委托链以及移除委托链。 首先，...
C#中委托的基本用法总结
09-05
在C#编程语言中，委托（Delegate）是一种强大的特性，它允许我们把方法作为参数传递，或者实现事件处理。下面是对C#中委托基本用法的深入解析。 1. **委托的本质** 委托在C#中实际上是一个类型安全的函数指针，它...
C#学习总结
weixin_43284350的博客
08-08 1761
用追马的时间种草吧
C＃与其它编程语言有什么区别，以及相关优势有哪些
最新发布
probably121的博客
08-19 440
C#编程语言的主要特性包括**面向对象、统一的类型系统、自动内存管理等**。与其它编程语言相比，C#的优势体现在**跨平台开发支持、强大的语言集成查询（LINQ）功能、高效的性能**这几个方面。通过.NET Core，C#可以实现真正的跨平台开发，这是其相对于许多其他语言的重要优势。LINQ提供了强大的数据查询能力，使得处理数据变得简单而高效。该语言拥有一个统一的类型系统，可以进行无缝的类型转换。尽管C#是一种安全的编程语言，但它仍能提供高效的性能。C#的语言集成查询提供了强大的数据查询能力。
C#中的S7协议
weixin_64532720的博客
08-16 828
S7协议-S7COMM CTOP->PDU type已知枚举值 0X0E 连接请求 0x0d 连接确认 0x08 断开请求 0x0c 断开确认 0x05 拒绝访问 0x01 加急数据 0x02 加急数据确认 0x04 用户数据 0x07 TPDU错误 0x0f 数据传输 S7Header->ROSCTR已知枚举值 0X01 JOB REQUEST。主站发送请求 0x02
c#相关基础知识
prisoneradvance的博客
08-15 142
值参：像Java的正常数据的传输ref：对参数的指向是参数本身的地址，而不是数据的副本，所以可以对数据进行直接操作out:绑定控件，控件传输值赋值给类中的内部类。
C#中委托的具体使用
03-20
在C#中，委托是一种类型，它可以用来引用一个或多个方法，并允许将方法作为参数传递给其他方法。委托的具体使用如下： 1. 定义委托类型：首先需要定义一个委托类型，可以使用`delegate`关键字来定义。例如，定义一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值