C语言中的函数指针、函数的直接/间接调用、C# 委托(自定义委托、内置泛型委托、委托的实例化、委托的一般使用(模板方法、回调方法)、泛型委托、多播委托、同步/异步使用委托）

已于 2023-02-27 17:16:50 修改
阅读量792 收藏 7
点赞数 1
分类专栏： 笔记 文章标签： c#
于 2022-08-17 23:25:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43809550/article/details/126395628
版权

文章目录

C语言中的函数指针

#include<stdio.h>
 
// 声明函数指针,定义为一种数据类型。
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, y = 200, z = 0;
	
	// 直接调用
	z = Add(x, y);
	printf("%d+%d=%d\n", x, y, z);
	
	z = Sub(x, y);
	printf("%d-%d=%d\n", x, y, z);
	
	// 声明函数指针类型的变量，并将函数的首地址赋给指针
	Calc funcPointer1 = &Add;
	Calc funcPointer2 = &Sub;
	//通过函数指针来间接调用函数
	z = funcPointer1(x, y);
	printf("%d+%d=%d\n", x, y, z);
	z = funcPointer2(x, y);
	printf("%d-%d=%d\n", x, y, z);
	
	system("pause");
	return 0;
}

看完代码觉得好多余呀，绕来绕去，直接用不好吗？我也有此感触：Python中都是直接把函数作为变量传递的。

def Add(a, b): return a+b
a = Add
print(a(2,3))

函数的直接调用与间接调用

  • 直接调用：通过函数名来调用函数（CPU通过函数名直接获得函数所在地址并开始执行——>返回调用者）
  • 间接调用：通过函数指针来调用函数（CPU通过读取指向某个函数的函数指针存储的值获得函数所在地址并开始执行——>返回调用者）
  • 直接调用和间接调用，效果是完全一样的。

Java中没有与委托对应的功能实体

  • 为了提高应用程序的安全性，java语言禁止程序员直接去访问地址，也就是说java语言把C++语言中所有与指针相关的内容都舍弃掉了
  • C#通过委托这种数据类型，保留了函数指针的功能

C# 委托

  • C#委托是C++函数指针的升级版，具有更高的安全性。
  • 按照字面意思：一件事情，我不亲自去做，而是让别人去代办，替我去做。
  • 从数据结构来讲，委托是一种类，类是引用类型的数据类型，所以委托也是一种数据类型。
  • ，它存储的就是 “一系列” 具有相同签名和返回回类型的方法的地址。调用委托的时候，委托包含的所有方法“都”将被执行。
  • 注意声明委托的位置，避免写错地方声明称嵌套类型(编译和运行都可以通过，但是不合理)

C# 自定义委托类型

最初使用委托时，均需要先自定义委托类型，然后定义一个符合委托类型签名的函数，在调用前，需声明并创建委托对象，将指定函数与委托进行关联。

委托的声明：delegate <函数返回类型> <委托名> (<函数参数>)

public delegate int Math(int param1, int param2);    //声明委托类型
Public int Add(int param1,int param2)    //定义同签名函数
{
　　Return param1+param2;
}
Math math;   //声明委托变量
math=new Math(Add);    //创建委托对象，与指定进行关联
math(3,4);    //调用委托函数

C# 内置泛型委托类型

在写程序时，如果需要三个、四个参数的委托类型，则需要再次自定义委托类型。简单的委托调用，却需要根据签名不断改变多次定义委托类型，而微软推出了对此进行简化的内置委托类型：Action和Func，简化了这些不必要的操作。

Action 与 Func是.NET类库中增加的内置委托类型，以便更加简洁方便的使用委托。

两种委托类型的区别在于：Action委托签名不提供返回类型，而Func提供返回类型。

Action委托具有Action、Action<T1,T2>、Action<T1,T2,T3>……Action<T1,……T16>多达16个的重载，其中传入参数均采用泛型中的类型参数T，涵盖了几乎所有可能存在的无返回值的委托类型。Func则具有Func、Func<T,Tresult>、Func<T1,T2,T3……,Tresult>17种类型重载，T1……T16为出入参数，Tresult为返回类型。

Func的使用方式：无需使用new实例化，直接和函数进行关联。

Func<int,int,int> math=Add;    //指定委托对象并关联函数
math(3,4);    //调用委托函数

Action的使用如同上面Func的使用一样，只是缺少了返回类型，直接调用委托函数。

Public void Add(int param1,int param2)
{
　　MessageBox.show((param1+param2).ToString());
}
//遇到此类的委托函数调用，那我们就可以直接用Action了：
Action<int,int> math=Add;
math(3,4);

代码示例：

namespace DelegateDemo
{
    class Program
    {
        //声明委托
        delegate int MyDelegate(int x, int y);

        static void Main(string[] args)
        {
            //1、Action<T>只能委托必须是无返回值的方法
            Action<string> _action = new Action<string>(SayHello);
            _action("Hello World");

            //2、Fun<TResult>只是委托必须有返回值的方法
            Func<int, bool> _func = new Func<int, bool>(Check);
            _func(5);

            //3、Predicate:此委托返回一个bool值，该委托通常引用一个"判断条件函数"。
            //需要指出的是，判断条件一般为“外部的硬性条件”,比如“大于50”，而不是由数据自身指定，如“查找数组中最大的元素就不适合”。
            Predicate<int> _predicate = new Predicate<int>(Check);
            //使用Lambda表达式
            Predicate<int> predicate = p => p % 2 == 0;
            _predicate(26);
        }

        static void SayHello(string strMsg)
        {
            Console.WriteLine(strMsg);
        }

        //返回值为bool值
        static bool Check(int i)
        {
            if (i % 2 == 0)
            {
                return true;
            }
            return false;
        }
    }
}

委托的实例化

使用new关键字

//<委托类型> <实例化名>=new <委托类型>(<注册函数>)
MyDelegate _MyDelegate=new MyDelegate(CheckMod);     //用函数CheckMod实例化上面的MyDelegate 委托为_MyDelegate，并进行绑定

直接实例化

//在.net 2.0开始可以直接将匹配的函数注册到实例化委托：<委托类型> <实例化名>=<注册函数>
MyDelegate _myDelegate = CheckMod;    //将函数CheckMod注册到委托实例_myDelegate上

匿名函数

//<委托类型> <实例化名> = delegate(<函数参数>){函数体}
Func<int,int,int> math=delegate(int param1,int param2){ return param1+param2; }

Lambda

Func<int,int,int> math=(param1,param2)=>{ return param1+param2; }

代码示例：

class Program
{
   //声明委托
   delegate int MyDelegate(int x, int y);

   static void Main(string[] args)
   {
       //实例化委托
       //1、使用new关键字
       MyDelegate _myDelegate = new MyDelegate(GetSum);

       //2、使用匿名方法
       MyDelegate myDelegate = delegate(int x, int y)
       {
           return x + y;
       };

       //3、使用Lambda表达式
       MyDelegate myDelegateLambda = (int x, int y) => { return x + y; };
   }

   static int GetSum(int x, int y)
   {
       return x + y;
   }
}

委托也支持泛型的使用

泛型委托定义：delegate <函数返回类型> <委托名><T1,T2,T3…> (T1 t1,T2 t2,T3 t3…)

可以使用in、out来修饰泛型，表明作为参数还是返回值

//定义有两个泛型（T1,T2）的委托，T2作为委托函数返回类型，T1作为委托函数参数类型
delegate T2 DelegateDemo<in T1,out T2>(T1 t);  

static bool Check(int i)
{
     if(i%2==0)
     {
          return true; 
    }
     return false;
}
static void Main(string[] args)
{
      DelegateDemo<int, bool> _delegate =Check;  //将泛型委托委托<T1,T2>实例化为<int,bool>，即表示有一个int类型参数且返回类型是bool的函数.
      Console.WriteLine(_delegate(9));  //false
}

委托的一般使用

  • 实例：把方法当作参数传给另一个方法
    • 正确使用1：模板方法，“借用“指定的外部方法来产生结果
      • 相当于“填空题"
      • 常位于代码中部
      • 委托有返回值
  • 正确使用2：回调（ callback )方法，调用指定的外部方法
    • 相当于“流水线”
    • 常位于代码末尾
    • 委托无返回值
  • 注意：难精通+易使用+功能强大东西，一旦被滥用则后果非常严重
    • 缺点1：这是一种方法级别的紧耦合，现实工作中要慎之又慎
    • 缺点2：使可读性下降、debug的难度增加
    • 缺点3：把委托回调、异步调用和多线程纠缠在一起，会让代码变得难以阅读和维护
    • 缺点4：委托使用不当有可能造成内存泄漏和程序性能下降
      • 例如：对象没有引用变量，但是它的方法有委托的话就会造成内存泄漏

模板方法

参照如下代码，体会使用模板方法的好处是：Product类、Box类、WrapFactory类都不用修改，只需要扩展ProductFactory类中的产品就可以生产不同的产品。不管是生产哪种产品的方法，只要将该方法封装到委托类型的对象里传给模板方法，调用模板方法时就可以将产品包装成箱子再交还回来，这样可以最大限度的实现代码的重复使用。代码的复用不但可以提高工作效率，还可以减少程序Bug的引入，良好的复用结构是所有优秀软件所追求的共同目标之一。

namespace 委托_刘铁猛
{
    public delegate double Calc(double x, double y);    //定义委托
    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);
        }
    }
 
    class Product
    {
        public string Name { get; set; }
    }
 
    class Box
    {
        public Product Product { get; set; }
    }
 
    class WrapFactory
    {
        /// <summary>
        /// 模板方法，委托的调用getProduct是可以修改的地方，传入不同的getProduct可以实现
        /// 不同的产出产品，不同的产品不用再修改WrapProduct中的方法
        /// </summary>
        /// <param name="getProduct"></param>
        /// <returns></returns>
        public Box WrapProduct(Func<Product> getProduct)
        {
            Box box = new Box();                      //准备一个Box
            Product product = getProduct.Invoke();    //获取一个产品
            box.Product = product;                    //把产品装到Box里面
            return box;                               //返回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;
        }
    }
}

回调方法

回调关系是对于某个方法可以调用或者不调用，用的着的时候调用它，用不着得时候不调用它。回调方法给了我们一个机会，可以动态的选择后续将被调用的方法（有多个备选方法）。当以回调方法的形式使用委托时，需将委托类型的变量传进主调方法里面，被传入抓主调方法中的委托的变量它内部会封装一个被回调的方法。主调函数会根据自己的逻辑来决定是否要调用回调方法。一般情况下，主调方法会在主要逻辑执行完之后，决定“是否”需要调用回调方法。

namespace 委托_刘铁猛
{
    public delegate double Calc(double x, double y);    //定义委托
    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);
        }
    }
 
    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
    {
     	//将logCallback作为回调方法使用，也就是说在主方法中根据某些条件决定是否使用到这个方法
        public Box WrapProduct(Func<Product> getProduct, Action<Product> logCallback)    
        {
            Box box = new Box();                      //准备一个Box
            Product product = getProduct.Invoke();    //获取一个产品
             //产品价格大于等于50则打印log信息；根据这个条件来决定是否使用logCallback方法
            if (product.Price >= 50)   
            {
                logCallback(product);
            }
 
            box.Product = product;                    //把产品装到Box里面
            return box;                               //返回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;
        }
    }
}

无论是模板方法还是回调方法，其本质都是用委托类型的对象绑定一个外部的方法，然后将这个委托传入方法的内部来进行间接调用。委托的功能非常强大，但使用不当会造成严重的后果。

多播委托

实例化委托时必须将一个匹配函数注册到委托上来实例化一个委托对象，但是一个实例化委托不仅可以注册一个函数还可以注册多个函数，注册多个函数后，在执行委托的时候会根据注册函数的注册先后顺序依次执行每一个注册函数。

注意：委托必须先实例化以后，才能使用+=注册其他方法。如果对注册了函数的委托实例从新使用=号赋值，相当于是重新实例化了委托，之前在上面注册的函数和委托实例之间也不再产生任何关系。

有+=注册函数到委托，也有-=解除注册

例如：MyDelegate _myDelegate-=CheckMod；

如果在委托注册了多个函数后，如果委托有返回值，那么调用委托时，返回的将是最后一个注册函数的返回值。

namespace DelegateDemo
{
    class Program
    {
        //声明委托
        delegate int MyDelegate(int x, int y);

        static void Main(string[] args)
        {
            MyDelegate _myDelegate = new MyDelegate(fun1);
            _myDelegate += fun2;
            Console.WriteLine(_myDelegate(10,23));

            Console.ReadKey();//输出10，返回最后一个注册函数的返回值
        }

        static int fun1(int x, int y)
        {
            return x + y;
        }

        static int fun2(int x, int y)
        {
            return x;
        }
    }
}

委托的高级用法

  • 同步与异步简介
    • 同步：你先做完，我在你基础上接着做
    • 异步：你我同时做
  • 同步调用与异步调用对比
    • 每个运行的程序是一个进程
    • 每个进程中可以有一个或多个线程
    • 同步调用是在同一个线程内
    • 异步调用底层机理是多线程
  • 同步 串行 单线程，异步 并行 多线程

同步调用 举例：直接同步调用、间接同步调用

//直接同步调用
//用方法的名字调用该方法
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student() { ID = 1,PenColor=ConsoleColor.Red };
        Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
        Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

        //直接调用三个方法，然后主线程还有一些事情要做
        stu1.DoHomework();
        stu2.DoHomework();
        stu3.DoHomework();
        for (int i = 0; i < 10; i++)
        {
            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);
        }
    }
}


//间接同步调用（单播委托）
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student() { ID = 1,PenColor=ConsoleColor.Red };
        Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
        Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

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

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

        for (int i = 0; i < 10; i++)
        {
            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);
        }
    }
}

异步调用 举例：隐式多线程BeginInvoke、显示多线程Thread类和Task类

隐式多线程：委托对象的BeginInvoke方法

//隐式多线程
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student() { ID = 1, PenColor=ConsoleColor.Red };
        Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
        Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

        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.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);
        }
    }
}

显示多线程(自己声明多线程)：使用Thread类和Task类，它们有一个委托类型为形参的构造函数，用来为某一个方法创建线程。

//方法一 使用Thread
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student() { ID = 1,PenColor=ConsoleColor.Red };
        Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
        Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

        //Thread类有public Thread(ThreadStart start)构造函数，ThreadStart是一个委托类型
        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.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);
        }
    }
}

//方法二 Task
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student() { ID = 1,PenColor=ConsoleColor.Red };
        Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
        Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

		//Task类有public Task(Action action)构造函数
        Task task1 = new Task(new Action(stu1.DoHomework));
        Task task2 = new Task(new Action(stu2.DoHomework));
        Task task3 = new Task(new Action(stu3.DoHomework));

        task1.Start();
        task2.Start();
        task3.Start();

        for (int i = 0; i < 10; i++)
        {
            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);
        }
    }
}

多线程的运行结果中其他三个线程颜色会不相同
但是由于多个线程访问同一个资源时，在争抢资源时发生冲突，所以跟理想状态不相同
为解决这个问题，可以“加锁”–高级内容，未来再说吧

适当使用接口取代一些对委托的功能

Java中没有委托照样活的好好的，是因为java完全按照设计模式的思想来开发，设计模式由一个核心思想就是面向接口编程，使用委托写的功能完全可以使用面向接口的思想去实现。

委托具有以下特点

  • 委托是一个引用类型，它保存对方法的引用（存放的是方法的首地址）
  • 因为委托是引用类型，委托允许将方法作为参数进行传递。
  • 委托就是.net用来实现回调机制的技术，而事件又是回调机制的一种应用
  • 委托可以链接在一起(多播委托)；例如，可以对一个事件调用多个方法。
  • 声明的委托和方法的签名和返回值基本一致(因为有协变性和逆变性，所以不需要完全一致)
把当下的事做好
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#知识点整理（2）-高级语言学习模型的建立之深入剖析委托
KingArthur_Tao的博客
10-17 588
1.引言：学习学习再学习，这不是鸡汤，展开了讲是学习了学习的方法论再去学习。这是李笑来先生提倡的一种终身学习思维。面对一个新的知识体系，我们不应仅仅只依赖于感性思维和过去经历所累积下来的经验，而要理性的思考，这门学科是如何建立的、前人是如何探索学习这门学科的等等。理解了这种思维，才能一直保持学习效率上的高效。本篇文章介绍了一种高级语言学习模型，换句话说是我在学习C#的过程中搭建起来的一个知识框架。文
函数指针到委托：C语言到C#的演进之旅
西疆先生
06-26 850
本文从C语言的函数指针讲起，深入探讨C#中的委托机制。介绍了委托的定义、声明、实例化，以及`Action`和`Func`泛型委托的使用。文章还分析了C#语言更新对委托的影响，特别是Lambda表达式的引入，展示了委托在事件处理和异步编程中的应用。通过本文，读者将理解委托的工作原理及其在现代C#编程中的高效使用方式。
懂了委托，才算真正入门C#
微小冷的学习笔记
02-01 4316
委托这个名字取的神乎其神的，但实质是函数式编程，把函数作为参数传递给另一个参数，在图形界面编程中非常常用，是控件绑定动作的基本方法。
我所理解的委托和匿名函数
UWA—简单优化，优化简单！
10-13 1221
委托和匿名函数在我们的日常编程中用得非常多，甚至有些同学用了大半年的匿名函数，却对其本质不甚了解，就像我们天天都要呼吸空气，却对空气质量和成分却没清晰的认识。委托和匿名函数虽然使用起来非常方便，但由于使用者理解不够深刻，不假思索地使用带来更多的是内存泄漏和过多的垃圾产生。那么这里，笔者就用一种他所理解的方式来给大家挖挖委托匿名函数的原理，让大家看看为什么这家伙用起来这么容易让人上瘾。
C#编程学习24：委托、事件与反射机制
m1m2m3mmm的博客
07-13 567
源码分析C#语言中的委托与事件；介绍使用反射机制调用程序集以及var关键字的使用细节
CSharp中委托（一）委托、匿名函数、lambda表达式、多播委托、窗体传值、泛型委托
xiaoyaolangwj的博客
03-10 1204
委托 先来个例子： 三个需求： 1、将一个字符串数组中每个元素都转换成大写 2、将一个字符串数组中每个元素都转换成小写 3、将一个字符串数组中每个元素两边都加上 双引号 string[] names = { "abCDefG", "HIJKlmnOP", "QRsTuvW", "XyZ" }; //StrToLower(names); StrToUpper(names); //StrSYH(names); for (int i = 0; i < names.Length; i++) {
C#委托定义和使用
Silas 蝈蝈 博客
01-30 4045
委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。简单的说，C#中的委托是一种类型安全的函数指针。它是对一个方法或函数的引用，然后调用执行。简单理解是这样的,比如您要管您的孩子，把孩子送进了幼儿园,此时您就把您的孩子委托给了幼儿园当幼儿园放学，将孩子交还给您的手中则是委托的回调(这里的例子是说异步委托调用)也可以同步,什么是同步委托调用？
C#从委托到事件
liu_if_else的博客
03-20 1342
文章目录C#委托C#委托与C函数指针C#委托的实例化C#事件Event先看一个用委托实现的发布者与订阅者模式上文中委托delegate的缺点：事件event的改进一个使用事件event的简单例子：一个更完善，规范的事件event使用案例：事件event的“属性访问器”多个绑定的事件处理方法中某个方法出现异常的解决办法 C#委托 C#委托与C函数指针 C#的委托与C语言的函数指针都可以实现把一个方法...
Unity/C#------委托与事件（一篇文章彻底搞懂...）
leikang111的博客
03-03 1891
从委托开始介绍到事件 从完整Event声明格式 到简洁的声明格式 到UnityEvent...
C#初级——List 容器
wacanda的博客
07-31 440
在C#中，容器通常指的是用于存储和组织数据的集合类。本文介绍的容器是内部使用数组来存储元素，当添加元素超出当前数组容量时，会自动调整大小（扩容）。
通过进程协作显示图像-C#
weixin_45114627的博客
07-30 828
如果一个软件比较复杂或者某些情况下需要拆解，可以考试将软件分解成两个或多个进程，但常规的消息传递又不能完全够用，使用消息+共享内存，实现图像传递，当然性能这个方面我并没有测试，仅是一种解决思路吧。
c#设置触控屏触控自动映射到扩展屏
sczmzx的博客
08-01 824
SetDisplayMapping可以实时告知系统当前触控设备映射到哪个屏幕，即使不设置注册表也能够生效（如果你只想设置临时生效，电脑重启后回到默认状态，那么就可以不进行2.3的步骤）当通过2.3在注册表中将关系挂上后，如果不做其它操作，你会发现你的设置是没有生效的，这时可以采用以下几种办法使配置生效。文末提供了源码下载链接。通过调用SetDisplayMapping方法，可以直接完成通知，并且实时生效，完美解决了我的问题。dwm进程结束后，系统会自动重启dwm，当重启完成后，你会发现新的映射已经生效了。
C# winform 串口读取字节流，MB级别字节流
曾经的我也很优秀，现在的我一无所有。
07-31 644
要一次性读取兆级别的数据（例如几百 KB 到几 MB），你需要确保你的串口硬件能够支持这样的传输速率，并且你的软件能够高效地处理大量的数据。如果硬件限制了数据传输速度，那么即使软件能够处理更大的缓冲区，也可能无法达到预期的性能。确保你的串口配置正确，能够支持较大的数据传输。例如，如果使用的是 USB 转串口适配器，可能需要较高的波特率（例如 115200 或更高）。事件处理程序中，你可以使用循环来读取所有可用的数据，直到没有更多数据可读为止。例如，你可以设置一个固定的较大缓冲区，或者动态调整缓冲区大小。
【C#】ThreadPool的使用
wangnaisheng的专栏
07-30 516
【C#】ThreadPool的使用
C# 使用 NLog 输出日志到文件夹
最新发布
build2024
08-04 185
通过设置 ·maxArchiveDays·，可以实现自动管理日志文件的归档和清理，避免日志文件过多导致存储空间的浪费。=“5242880”: 文件归档大小尺寸，如果单文凭超过 5242880，则重新创建一个新的文件。或者创建一个共用的写日志静态类,需要输出日志的代码逻辑处，通过调用当前静态类即可。: 这些设置确保文件可以在多个进程中安全写入，同时不保持文件句柄打开。: 日志文件归档使用滚动编号，避免创建大量的备份文件。: 这表示每天生成一个新的日志文件。的文件夹，并在其中创建。属性：日志内容输出的模板。
C#实战 - C#实现发送邮件的三种方法
逍遥Sean的博客
07-31 493
当使用 C# 编程语言发送邮件时，可以利用不同的方法来实现。本文将介绍三种常用的方法：使用SMTP客户端库、使用.NET Framework内置类和使用第三方库。我们将详细讨论每种方法的优缺点以及如何实现。
C# Where关键字
vtheshow的博客
07-31 521
C#的where关键字用途
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值