C# 委托与事件深度解析：从原理到实战

C#委托与事件原理解析
原创 于 2025-12-11 00:41:08 发布 · 804 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c#

在 C# 开发体系中，委托和事件是实现回调机制、松耦合设计的核心基石，也是开发者从入门迈向进阶的关键知识点。很多开发者易混淆两者关系，甚至误将事件等同于委托。本文整合核心原理、进阶特性与实战技巧，从底层实现到框架应用，全方位拆解委托与事件的本质、用法及最佳实践。

一、委托：类型安全的 “函数指针”

1.1 委托的本质与继承体系

委托的本质是继承自 System.MulticastDelegate（其父类为 System.Delegate）的密封引用类型，编译器会自动为自定义委托生成包含核心成员的类结构：

// 编译器生成的委托类简化结构
public sealed class MyDelegate : MulticastDelegate {
    public override MethodInfo Method { get; } // 绑定的方法信息
    public override object Target { get; }     // 方法所属的实例
    public override void Invoke(...);          // 同步调用方法
    public override IAsyncResult BeginInvoke(...); // 异步调用开始
    public override object EndInvoke(IAsyncResult); // 异步调用结束
}

可通过反射验证继承关系：

Console.WriteLine(typeof(MyDelegate).BaseType); // 输出: System.MulticastDelegate
using System;
using System.Threading;

namespace ConsoleApp2
{
    // 自定义委托（编译器会自动为其生成 BeginInvoke/EndInvoke 方法）
    public delegate void MyDelegate(int number);

    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // 1. 初始化委托（Lambda 简化写法）
                MyDelegate myDelegate = number =>
                {
                    // 模拟耗时操作（方便观察异步效果）
                    Thread.Sleep(1000);
                    Console.WriteLine($"委托执行：Number = {number}");
                };

                // 2. 打印委托核心信息（验证基类/方法生成）
                PrintDelegateInfo(myDelegate);

                // 3. 同步调用委托
                Console.WriteLine("\n=== 同步调用委托 ===");
                myDelegate(32); // 等价于 myDelegate.Invoke(32)

                // 4. 异步调用委托（原生 APM 模式：BeginInvoke + EndInvoke）
                Console.WriteLine("\n=== 异步调用委托（BeginInvoke/EndInvoke）===");
                Console.WriteLine("开始异步调用（主线程继续执行...）");

                // 4.1 调用 BeginInvoke 启动异步
                // 参数说明：
                // - 委托的入参（number=45）
                // - 异步完成回调（AsyncCallback）
                // - 回调携带的自定义状态（可选）
                IAsyncResult asyncResult = myDelegate.BeginInvoke(
                    45,                  // 委托的参数
                    AsyncCallbackHandler, // 异步完成后的回调方法
                    myDelegate           // 回调中携带的状态（传递委托实例）
                );

                // 主线程可在此执行其他操作（演示异步并行）
                Console.WriteLine("主线程：异步调用已发起，我先做其他事...");
                Thread.Sleep(500); // 模拟主线程耗时操作

                // 4.2 等待异步完成并调用 EndInvoke（必须调用，否则会泄露资源）
                // 方式1：阻塞等待（直到异步完成）
                // myDelegate.EndInvoke(asyncResult);

                // 方式2：非阻塞等待（轮询 IsCompleted）
                while (!asyncResult.IsCompleted)
                {
                    Console.WriteLine("主线程：异步还没完成，再等一等...");
                    Thread.Sleep(200);
                }
                myDelegate.EndInvoke(asyncResult); // 收尾异步调用

                Console.WriteLine("\n所有操作执行完成！");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行异常：{ex.Message}", ex);
            }
            finally
            {
                Console.WriteLine("\n按任意键退出...");
                Console.ReadKey();
            }
        }

        /// <summary>
        /// 异步调用完成后的回调方法
        /// </summary>
        private static void AsyncCallbackHandler(IAsyncResult ar)
        {
            Console.WriteLine("\n回调触发：异步调用执行完成！");

            // 从 AsyncResult 中取出委托实例（BeginInvoke 传入的 state）
            if (ar.AsyncState is MyDelegate callbackDelegate)
            {
                // 回调中也可调用 EndInvoke（二选一，确保只调用一次）
                // callbackDelegate.EndInvoke(ar);
                Console.WriteLine("回调中验证：委托状态正常");
            }
        }

        /// <summary>
        /// 打印委托核心信息（验证自动生成的方法/基类）
        /// </summary>
        private static void PrintDelegateInfo(Delegate delegateInstance)
        {
            if (delegateInstance == null)
            {
                Console.WriteLine("委托实例为 null");
                return;
            }

            // 委托基类验证（所有委托都继承自 MulticastDelegate）
            Console.WriteLine($"委托基类：{delegateInstance.GetType().BaseType.FullName}");
            Console.WriteLine($"委托类型：{delegateInstance.GetType().Name}");

            // 委托方法信息
            var method = delegateInstance.Method;
            Console.WriteLine("\n委托方法信息：");
            Console.WriteLine($"  方法名：{method.Name}");
            Console.WriteLine($"  声明类型：{method.DeclaringType?.FullName ?? "未知"}");
            Console.WriteLine($"  是否自动生成：{method.Name.StartsWith("<")}"); // 编译器生成的匿名方法特征

            // 委托目标
            var target = delegateInstance.Target;
            Console.WriteLine($"委托目标：{(target == null ? "null" : target.ToString())}");
        }
    }
}

image

委托的核心价值是将方法作为参数传递，实现类型安全的 “函数指针” 功能，相当于 “方法容器”，仅容纳与自身签名（参数类型、返回值类型）匹配的方法。

1.2 委托的基础用法

（1）自定义委托

通过 delegate 关键字声明，格式为 delegate 返回值类型 委托名(参数列表)：

// 定义无返回值、接收int参数的委托
delegate void MyDel(int i);

class Program
{
    static void Main(string[] args)
    {
        // 实例化委托并绑定方法
        MyDel d1 = F1;
        MyDel d2 = F2;
        
        // 调用委托（本质调用绑定方法）
        d1(5); // 输出：我是F1：5
        d2(5); // 输出：我是F2：5
    } 
    
    // 符合MyDel签名的目标方法
    static void F1(int i) => Console.WriteLine("我是F1："+i);
    static void F2(int i) => Console.WriteLine("我是F2：" + i);
}
（2）多播委托（委托组合）

委托支持通过 +=（或 +）组合多个方法，调用时按绑定顺序依次执行，也可通过 -= 移除方法。需注意多线程下的线程安全：

// 基础多播委托用法
MyDel d1 = F1;
MyDel d2 = F2;
MyDel d3 = F3;
MyDel d4 = d1 + d2 + d3;
d4(8); // 依次执行F1、F2、F3

// 多线程下的安全组合（锁保护字段原子性）
private MyDel _delegate;
private readonly object lockObj = new object();
public void AddDelegate(MyDel newDelegate)
{
    lock (lockObj)
    {
        _delegate = (MyDel)Delegate.Combine(_delegate, newDelegate);
    }
}

注：Delegate.Combine 本身线程安全，锁仅用于保护 _delegate 字段的原子性。

1.3 内置泛型委托：Func/Action（优先使用）

实际开发中无需重复定义委托，.NET 内置的 Func 和 Action 覆盖 90% 以上场景：

委托类型特点适用场景
Action无返回值，可接收 0-16 个参数事件处理、日志记录、执行操作
Func有返回值，可接收 0-16 个参数（最后一个泛型参数为返回值）LINQ 查询、数据计算 / 转换 / 筛选
（1）Action 示例
// 无参数Action
Action printHello = () => Console.WriteLine("Hello Action");
printHello();

// 接收2个参数的Action
Action<string, int> log = (msg, level) => Console.WriteLine($"[{level}] {msg}");
log("数据更新成功", 1); // 输出：[1] 数据更新成功
（2）Func 示例
using System;
using System.Collections.Generic;
using System.Linq;

class FuncDemo
{
    static void Main()
    {
        // 1. 无参数，返回string（当前时间）
        Func<string> getTime = () => DateTime.Now.ToString("HH:mm:ss");
        Console.WriteLine("当前时间：" + getTime());

        // 2. 接收2个int参数，返回int（求和）
        Func<int, int, int> add = (a, b) => a + b;
        Console.WriteLine("3 + 5 = " + add(3, 5)); // 输出：8

        // 3. LINQ中应用（筛选偶数）
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // Where方法接收 Func<int, bool> 类型的委托参数（输入int，返回bool）
        var evenNumbers = numbers.Where(n => n % 2 == 0);
        
        Console.Write("偶数列表：");
        foreach (var num in evenNumbers)
        {
            Console.Write(num + " "); // 输出：2 4
        }
    }
}

1.4 进阶特性：异步委托与闭包陷阱

（1）异步委托

支持绑定异步方法，需声明返回 Task 的委托类型，调用时通过 await 处理：

using System;
using System.Threading.Tasks;

class AsyncDelegateDemo
{
    // 修正：异步委托返回Task<int>（对应有返回值的异步操作）
    public delegate Task<int> AsyncDelegate(int x);

    static async Task Main(string[] args)
    {
        // 绑定异步Lambda到委托
        AsyncDelegate del = async x =>
        {
            // 模拟异步操作（延迟100ms）
            await Task.Delay(100).ConfigureAwait(false); 
            return x * 2; // 返回计算结果
        };

        // 异步调用委托并处理结果/异常
        try
        {
            int result = await del(5); // 调用委托，等待异步完成
            Console.WriteLine($"异步调用结果：{result}"); // 输出：10
        }
        catch (Exception ex)
        {
            Console.WriteLine($"捕获异步异常：{ex.Message}");
        }
    }
}
（2）Lambda 闭包陷阱

循环中 Lambda 捕获的是变量引用而非值，易导致结果不符合预期：

// 问题代码：所有按钮点击后均输出3
for (int i = 0; i < 3; i++) {
    buttons[i].OnClick += () => Console.WriteLine(i);
}

// 修复方案：创建局部副本
for (int i = 0; i < 3; i++) {
    int current = i;
    buttons[i].OnClick += () => Console.WriteLine(current);
}

二、事件：委托的安全封装

2.1 核心认知：事件≠委托

事件是委托的安全包装器，基于委托实现但通过访问控制限制外部操作，核心区别如下：

特性委托（Delegate）事件（Event）
本质独立的引用类型（类）委托的封装（类成员）
外部操作可直接调用、赋值、覆盖仅允许 +=（订阅）、-=（取消订阅）
触发权限任何地方均可调用仅声明类内部可触发
设计目的通用方法回调、参数传递安全的发布 - 订阅通知
典型场景LINQ 查询、异步回调按钮点击、状态变更通知

2.2 事件的定义与使用

通过 event 关键字声明，通常结合 EventHandler<T> 实现强类型参数，遵循微软标准事件模式：

// 自定义事件参数（继承EventArgs）
public class AgeChangedEventArgs : EventArgs {
    public int NewAge { get; }
    public AgeChangedEventArgs(int newAge) => NewAge = newAge;
}

public class Person
{
    private int _age;
    // 声明强类型事件（推荐）
    public event EventHandler<AgeChangedEventArgs> OnBenMingNian;
    
    public int Age 
    {
        get => _age;
        set 
        {
            if (value == _age) return;
            _age = value;
            // 触发事件（空条件运算符避免空引用）
            if (value % 12 == 0)
            {
                OnBenMingNian?.Invoke(this, new AgeChangedEventArgs(value));
            }
        }
    }
}

// 调用示例
class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();
        // 订阅事件
        p.OnBenMingNian += (sender, e) => Console.WriteLine($"本命年到了，年龄：{e.NewAge}");
        
        p.Age = 24; // 触发事件，输出：本命年到了，年龄：24
    }
}

2.3 事件的关键问题：内存泄漏

（1）典型泄漏场景
  • 静态事件未取消订阅；
  • 订阅者未在 Dispose 中取消订阅；
  • 长生命周期发布者持有短生命周期订阅者引用。
（2）解决方案
  1. 实现 IDisposable 模式，主动取消订阅：
public class AlarmSystem : IDisposable
{
    private readonly Sensor _sensor;
    public AlarmSystem(Sensor sensor)
    {
        _sensor = sensor;
        _sensor.TemperatureChanged += OnTemperatureChange;
    }
    
    private void OnTemperatureChange(object sender, TemperatureChangedEventArgs e)
    {
        if (e.NewValue > 50) Console.WriteLine("高温警报！");
    }
    
    // 取消订阅，避免内存泄漏
    public void Dispose()
    {
        _sensor.TemperatureChanged -= OnTemperatureChange;
    }
}
  1. WPF 场景使用 WeakEventManager；
  2. 采用事件私有封装模式，避免外部直接操作。

三、委托与事件的性能优化与调试

3.1 委托链性能优化

委托链长度过大会影响性能，建议生产环境控制在 5 以内，可通过 GetInvocationList() 监控：

Delegate[] invocables = _delegate.GetInvocationList();
Debug.WriteLine($"委托链长度：{invocables.Length}");
if (invocables.Length > 5)
{
    // 优化：拆分委托链或调整订阅逻辑
}

3.2 事件触发优化

优先使用空条件运算符 ?.Invoke()，替代传统的空值判断，编译器会自动转换为更高效的 DelegateExtensions.Invoke 方法：

// 传统方式（不推荐）
if (OnEvent != null) OnEvent(sender, e);

// 推荐方式（C#6+）
OnEvent?.Invoke(sender, e);

四、框架级应用场景

框架 / 场景委托实现事件实现最佳实践
WPF 数据绑定PropertyChangedEventHandlerINotifyPropertyChanged 接口使用强类型事件参数
ASP.NET 中间件RequestDelegate 链式调用无结合 IAsyncMiddleware
Unity 事件系统UnityEvent（编辑器增强）自定义 UnityEvent<T>避免在 Update 中频繁订阅

五、综合实战：观察者模式（委托 + 事件核心应用）

观察者模式是委托与事件的典型落地场景，实现发布者 - 订阅者的松耦合通信：

// 自定义事件参数
public class TemperatureChangedEventArgs : EventArgs
{
    public float NewValue { get; }
    public TemperatureChangedEventArgs(float newValue) => NewValue = newValue;
}

// 发布者：传感器（温度变更通知）
public class Sensor : IDisposable
{
    private float _temperature;
    // 声明温度变更事件
    public event EventHandler<TemperatureChangedEventArgs> TemperatureChanged;
    
    public float Temperature
    {
        get => _temperature;
        set
        {
            if (value != _temperature)
            {
                _temperature = value;
                // 触发事件
                TemperatureChanged?.Invoke(this, new TemperatureChangedEventArgs(value));
            }
        }
    }

    public void Dispose()
    {
        // 清空事件订阅，避免内存泄漏
        TemperatureChanged = null;
    }
}

// 订阅者：警报系统
public class AlarmSystem : IDisposable
{
    private readonly Sensor _sensor;
    public AlarmSystem(Sensor sensor)
    {
        _sensor = sensor;
        _sensor.TemperatureChanged += OnTemperatureChange;
    }
    
    private void OnTemperatureChange(object sender, TemperatureChangedEventArgs e)
    {
        if (e.NewValue > 50) Console.WriteLine("高温警报！");
    }
    
    // 取消订阅，释放资源
    public void Dispose()
    {
        _sensor.TemperatureChanged -= OnTemperatureChange;
    }
}

// 调用示例
class Program
{
    static void Main(string[] args)
    {
        using (var sensor = new Sensor())
        using (var alarm = new AlarmSystem(sensor))
        {
            sensor.Temperature = 40; // 无警报
            sensor.Temperature = 55; // 输出：高温警报！
        } // 自动调用Dispose，取消订阅
    }
}

六、学习路线与最佳实践

6.1 学习路线图

  1. 基础掌握：委托声明 / 调用、Func/Action 内置委托使用；
  2. 进阶特性：多播委托、异步委托、Lambda 闭包捕获；
  3. 设计模式：观察者模式、策略模式、责任链模式（基于委托实现）；
  4. 框架源码：研究 .NET Runtime 委托实现、WPF 事件系统；
  5. 性能调优：委托链长度控制、弱事件模式实现。

6.2 核心最佳实践

  1. 优先使用 Func/Action 内置委托，避免重复定义；
  2. 事件触发必须做空值判断（?.Invoke()）；
  3. 事件订阅后必须在合适时机取消（如 Dispose 方法），避免内存泄漏；
  4. 多线程场景下组合多播委托需加锁保护字段；
  5. 异步委托使用 ConfigureAwait(false) 避免上下文捕获问题；
  6. 循环中使用 Lambda 绑定委托时，需创建局部变量副本避免闭包陷阱。

掌握委托与事件的核心逻辑，不仅能写出更灵活、松耦合的代码，更是理解 .NET 框架底层设计（如 ASP.NET 中间件、WPF 响应式设计）的关键。建议结合文中示例动手调试，重点验证多线程、异步场景下的行为，加深对底层原理的理解。

C#委托：从底层原理到实战应用全解析
墨夶的博客
08-09 931
委托是一种。
C#中委托与事件的深度解析及实战应用
java专栏
06-30 490
🔥关注墨瑾轩，带你探索Java的奥秘！🚀🔥超萌技术攻略，轻松晋级编程高手！🚀🔥技术宝库已备好，就等你来挖掘！🚀🔥订阅墨瑾轩，智趣学习不孤单！🚀🔥即刻启航，编程之旅更有趣！🚀在C#中，委托（Delegate）和事件（Event）是实现函数回调、事件驱动编程的核心机制。它们为面向对象编程添加了响应式和松耦合的特性，使得代码更加灵活和模块化。下面我们将深入探讨委托和事件的原理、使用方法，并通过示例代码进行详尽说明。
C#反射技术深度解析：从原理到实战应用指南
品质生活，极致编程。
03-17 1172
反射是C#中实现动态编程的核心技术，适用于框架开发、模块化设计等场景，但其灵活性的代价是性能和安全风险。​建议遵循以下原则​按需使用：优先使用接口或设计模式替代反射。​性能监控：在高频代码中避免反射调用。​代码可读性：通过封装反射逻辑降低维护成本。// 示例：封装反射操作通过合理利用反射，开发者可以构建高度灵活的系统（如插件架构、动态UI生成器等），但同时需权衡其优缺点，确保代码的健壮性与效率。
Unity委托、匿名方法与事件深度解析：从理论到实战
计算机领域优质博文分享
08-26 631
摘要：本文深入解析Unity中的委托、匿名方法与事件机制，从原理到实践全面讲解。通过12个代码片段和6个核心图示，详细说明委托的内存结构、多播原理、匿名方法优化技巧及事件安全模式。重点包括Lambda表达式应用、闭包问题解决方案、事件总线设计等实战内容，并提供性能优化建议（如委托缓存、事件清理等）。适用于Unity 2020+版本开发，帮助构建高效事件驱动系统，提升开发效率。
C#事件机制深度解析：从原理到实践
钢铁男儿
07-02 236
【代码】C#事件机制深度解析：从原理到实践。
C# Lambda表达式深度解析：从语法到实战的完整指南
品质生活，极致编程。
03-17 760
通过合理运用Lambda表达式，开发者可以构建出如电商平台的实时数据分析系统、工业控制软件的事件响应模块等高效率应用。建议结合微软官方Lambda指南进行深度实践，掌握这一现代C#开发的核心利器。Lambda表达式是C# 3.0引入的匿名函数语法糖，其核心目标是通过。来提升代码的可读性和开发效率。相比传统的匿名方法，Lambda通过。运算符将参数与执行逻辑分离，形成直观的"输入到输出"结构。
C# 策略模式深度解析：从原理到实战
品质生活，极致编程。
03-18 425
/ 促销策略接口优点消除条件分支，提升代码可读性。支持动态扩展，符合单一职责原则。缺点类数量可能激增（每个策略对应一个类）。客户端需理解策略差异，增加使用成本。策略模式通过算法封装与动态替换，为复杂业务逻辑提供了优雅的解决方案。在C#中，其实现灵活且易于集成至现代框架（如依赖注入）。无论是电商促销、支付系统还是游戏开发，合理运用策略模式均可显著提升代码质量与可维护性。
【C#委托与事件深度解析】：揭秘高手都在用的异步编程核心机制
AlgoFun的博客
11-01 548
掌握C#异步编程核心，深入解析委托与事件机制。本文清晰阐述C#委托（Delegate）与事件（Event）区别，涵盖事件订阅、回调处理与内存管理等关键场景，揭示解耦设计与高效通信的核心方法。提升代码可维护性与扩展性，值得收藏。
C#委托完全指南：从原理到多播实战
钢铁男儿
06-25 474
✅ 实现松耦合架构✅ 支持链式操作（观察者模式）✅ 为LINQ的lambda表达式提供基础。
C#深度解析：委托与事件详解及实战应用
本文将深入解析C#中的委托与事件，这两个概念在面向对象编程中扮演着关键角色，尤其对于理解和使用C#语言至关重要。首先，委托在C#中是一个特殊的类型，它本质上是一个密封类，继承自`MulticastDelegate`，用于封装...
C#深度解析：从基础到实战
本文档涵盖了C#的基础知识，对比了C#与Java的区别，并介绍了C#的主要特征、安装环境、编辑器、程序结构、名称空间以及编程实战演习。" 在深入探讨C#之前，我们首先要明白C#是什么。C#是由微软公司开发的一种面向...
C#深度解析：委托与事件详解与实战应用
C#中的委托和事件是.NET Framework中强大的编程工具，它们对于理解和实现灵活、可扩展的软件架构至关重要。委托是一种类型，它允许我们将方法作为参数传递给其他方法，实现了函数指针的概念，使得代码更加模块化和可...
Python 字符串全面解析
这是一个c++热爱者的博客哟
12-07 1079
本文全面解析Python字符串操作，涵盖字符串创建、基本操作、常用方法和格式化技巧。内容包括：使用单引号、双引号和三引号创建字符串；索引访问、切片、拼接和重复等基本操作；查找替换、大小写转换、空白处理等字符串方法；f-string、format()和%三种格式化方式；转义字符和原始字符串的使用；字符串编码转换；以及字符串检查处理方法。文章提供了丰富的代码示例，帮助掌握Python字符串的各种操作技巧，适用于Python 3.x版本，特别推荐使用f-string进行字符串格式化。
幽冥大陆(四十六)人工智能自动化交互系统ASR2——东方仙盟筑基期
最新发布
cybersnow精通 28 门计算机语言，凭借其超凡的技术能力，成功开发过上万个应用，广泛涉及政府、商业、个人等众多领域，甚至在检察院、环保局、公安局等专业场景中也大放异彩。不仅熟练掌握单片机和物联网开发，在软件架构设计方面更是独树一帜，自创了跨平台软件
12-10 548
在当今数字化时代，自动语音识别（ASR）技术正以前所未有的速度改变着我们与设备交互的方式。在 C# 和浏览器环境中开发 ASR 应用，为开发者开启了一扇通往创新交互体验的大门。对于初学者而言，这既是充满挑战的征程，也是收获满满的学习之旅。
halcon图像增强——emphasize
qq_34059233的博客
12-09 324
我们有时候需要提取图像的边缘进行后续的处理，在提取边缘之前，我们可以对图像的边缘进行增强处理
CAD点集生成泰森多边形Voronoi图）——CAD二次开发
12-10 83
实现了基于点集生成泰森多边形（Voronoi图）的功能，并能够将生成的Voronoi多边形和Delaunay三角网进行裁剪，以适应指定的边界框。代码主要采用C#编写，依赖于AutoCAD的.NET API。将生成的Voronoi多边形和Delaunay边裁剪到指定的边界框（通过放大输入点集的范围得到）。将结果以多段线（Polyline）的形式添加到AutoCAD模型空间。从AutoCAD中选择点或多段线（提取顶点）作为输入点集。根据Delaunay三角网生成Voronoi图。采用CAD c#开发，
台达AS系列PLC modbus TCP网口上位机通信，项目现场使用设备的C#源代码
2509_94268028的博客
12-07 296
所以啊，工业网络调试，三分靠技术，七分靠玄学。最近在工业现场折腾台达AS系列PLC的Modbus TCP通讯，发现这玩意儿的协议实现和常规设备还真有点不一样。项目需求是抓取设备每月每天的生产数据存Excel，先给大伙儿看看我们是怎么用C#暴力破解的。EPPlus处理十万级数据量时建议开启内存优化模式，别问我怎么知道的——上个月报表生成直接吃光8G内存，现场工控机当场罢工。台达AS系列PLC modbus TCP网口上位机通信，项目现场使用设备的C#源代码，监控设备每月每天的生产数据并生成Excel表格。
Qt对Word网页的读写功能实现
fie8889的博客
12-05 504
Qt对Word网页的读写功能实现
C# 中的 dynamic 类型
chinalog的专栏
12-08 285
‌1、编译时与运行时行为‌：dynamic 变量在编译时被视为静态类型（类似 object），但所有操作（如方法调用、属性访问）的类型检查和成员解析都在运行时完成。‌类型安全性‌：由于类型检查延迟，错误可能在运行时才暴露，增加调试难度。2、 ‌重载决策延迟‌：当方法调用的参数或接收方类型为 dynamic 时，重载决策在运行时进行。‌性能开销‌：dynamic 的运行时检查会带来性能损失，通常低于静态类型。// 整数转换为 dynamic。‌隐式转换‌：任何类型都可以隐式转换为 dynamic，反之亦然。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bugcom

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值