Unity C# 游戏开发 事件 消息派发器（图文详细，带源码）

Unity C# 游戏开发：事件消息派发器实现与应用
最新推荐文章于 2025-09-15 15:55:44 发布
原创 最新推荐文章于 2025-09-15 15:55:44 发布 · 2.3k 阅读 · 35 ·
CC 4.0 BY-SA版权
版权声明：本博客为非营利性个人原创 所刊登的所有作品的著作权均为本人所拥有 本人保留所有法定权利,违者必究! 对于需要复制、转载、链接和传播博客文章或内容的 请及时和本博主进行联系， 对于经本博主明确授权和许可使用文章及内容的 使用时请注明文章或内容出处并注明网址 转载请附上原文出处链接及本声明。
文章标签：

#游戏开发 #unity #c# #unity3d #消息派发器

本文详细介绍了如何使用C#在Unity中实现一个事件消息派发器，包括添加事件注册、触发事件和移除事件的功能，并提供了完整代码。通过实例展示了无参数和有参数的事件调用，简化了游戏开发中的事件处理。此外，还给出了使用案例，如按Esc键退出游戏的事件处理。

Unity C# 游戏开发 事件 消息派发器 （图文详细，带源码）

事情是这样的

可可爱爱的程序媛小姐姐又来找我玩啦，本来是开心的聊天却变成了技术研讨会，小姐姐说最近敲代码，各种事件委托，各种观察者模式，手都敲麻了，问我有好办法没有
请添加图片描述
那我可以帮你揉一下？（显然不符合我钢铁直男的人设），那就写个消息派发器来帮助小姐姐吧！

🔥总目录C#语法系列详解——总目录持续更新中。。。

一、消息派发器的几个功能

既然是要来简化观察者模式，那功能肯定一个都不能少

1.添加事件注册

需要2个参数，第一个是索引，第二个是事件

/// <summary>
    /// 添加事件注册
    /// </summary>
    /// <param name="evt">索引</param>
    /// <param name="listener"></param>
    private void AddDelegate(int evt, Delegate listener)
    {
        Delegate value;
        if (!listeners.TryGetValue(evt, out value))
        {
            //key不存在就添加
            listeners.Add(evt, listener);
        }
        else
        {
            //key存在判断value是否为空，为空就替换，不为空就多播
            value = (value != null) ? Delegate.Combine(value, listener) : listener;
            listeners[evt] = value;
        }
    }

2.事件的触发

事件的触发需要传入一个 索引

/// <summary>
    /// 事件触发
    /// </summary>
    /// <param name="evt"></param>
    public void DispatchEvent(int evt)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var act = (Act)func;
                act();
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

3.移除事件

事件移除和注册需要的参数是一样的

/// <summary>
    /// 移除事件
    /// </summary>
    /// <param name="evt"></param>
    /// <param name="listener"></param>
    private void RemoveDelegate(int evt, Delegate listener)
    {
        Delegate func;
        if (listeners.TryGetValue(evt, out func))
        {
            if (func != null)
            {
                func = Delegate.Remove(func, listener);
                listeners[evt] = func;
            }
            else
            {
                Debug.LogError("Key" + evt + "不存在！");
            }
        }
    }

二、完整代码

using System;
using System.Collections.Generic;
using UnityEngine;

public delegate void Act();
public delegate void Act<in T>(T t1);
public delegate void Act<in T1, in T2>(T1 t1, T2 t2);
public delegate void Act<in T1, in T2, in T3>(T1 t1, T2 t2, T3 t3);
public delegate void Act<in T1, in T2, in T3, in T4>(T1 t1, T2 t2, T3 t3, T4 t4);

public delegate T Fn<out T>();
public delegate T Fn<out T, in T1>(T1 t1);
public delegate T Fn<out T, in T1, in T2>(T1 t1, T2 t2);
public delegate T Fn<out T, in T1, in T2, in T3>(T1 t1, T2 t2, T3 t3);
public delegate T Fn<out T, in T1, in T2, in T3, in T4>(T1 t1, T2 t2, T3 t3, T4 t4);

public class EventDispatcher
{
    /// <summary>
    /// 字典存放
    /// </summary>
    private Dictionary<int, Delegate> listeners = new Dictionary<int, Delegate>();
    public static EventDispatcher GameWorldEventDispatcher = new EventDispatcher();
    /// <summary>
    /// 单例模式
    /// </summary>
    public static EventDispatcher GameEvent
    {
        get
        {
            return GameWorldEventDispatcher;
        }
    }
    /// <summary>
    /// 构造函数
    /// </summary>
    public EventDispatcher()
    {
    }
    /// <summary>
    /// 移除字典中所有的键值（解绑所有事件）
    /// </summary>
    public void ClearEventListener()
    {
        listeners.Clear();
    }
    /// <summary>
    /// 添加事件注册
    /// </summary>
    /// <param name="evt">索引</param>
    /// <param name="listener"></param>
    private void AddDelegate(int evt, Delegate listener)
    {
        Delegate value;
        if (!listeners.TryGetValue(evt, out value))
        {
            //key不存在就添加
            listeners.Add(evt, listener);
        }
        else
        {
            //key存在判断value是否为空，为空就替换，不为空就多播
            value = (value != null) ? Delegate.Combine(value, listener) : listener;
            listeners[evt] = value;
        }
    }
    /// <summary>
    /// 移除事件
    /// </summary>
    /// <param name="evt"></param>
    /// <param name="listener"></param>
    private void RemoveDelegate(int evt, Delegate listener)
    {
        Delegate func;
        if (listeners.TryGetValue(evt, out func))
        {
            if (func != null)
            {
                func = Delegate.Remove(func, listener);
                listeners[evt] = func;
            }
            else
            {
                Debug.LogError("Key" + evt + "不存在！");
            }
        }
    }
    /// <summary>
    /// 注册
    /// </summary>
    /// <param name="evt"></param>
    /// <param name="listener"></param>
    public void Regist(int evt, Act listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }
    /// <summary>
    /// 移除
    /// </summary>
    /// <param name="evt"></param>
    /// <param name="listener"></param>
    public void UnRegist(int evt, Act listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }
    /// <summary>
    /// 事件触发
    /// </summary>
    /// <param name="evt"></param>
    public void DispatchEvent(int evt)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var act = (Act)func;
                act();
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void Regist<T>(int evt, Act<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T>(int evt, Act<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1>(int evt, T1 args)
    {
        Delegate func;

        if (listeners.TryGetValue(evt, out func) && func != null)
        {
            var act = (Act<T1>)func;
            act(args);
        }
    }

    public void Regist<T1, T2>(int evt, Act<T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T1, T2>(int evt, Act<T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1, T2>(int evt, T1 arg1, T2 arg2)
    {
        Delegate func;
        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Act<T1, T2>)func;
                tmp(arg1, arg2);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void Regist<T1, T2, T3>(int evt, Act<T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T1, T2, T3>(int evt, Act<T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1, T2, T3>(int evt, T1 arg1, T2 arg2, T3 arg3)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Act<T1, T2, T3>)func;
                tmp(arg1, arg2, arg3);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void Regist<T1, T2, T3, T4>(int evt, Act<T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T1, T2, T3, T4>(int evt, Act<T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1, T2, T3, T4>(int evt, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Act<T1, T2, T3, T4>)func;
                tmp(arg1, arg2, arg3, arg4);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void RegistFn<T>(int evt, Fn<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T>(int evt, Fn<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T>(int evt)
    {
        Delegate func;
        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T>)func;
                return fn();
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1>(int evt, Fn<T, T1> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1>(int evt, Fn<T, T1> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1>(int evt, T1 args)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Fn<T, T1>)func;
                return tmp(args);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1, T2>(int evt, Fn<T, T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1, T2>(int evt, Fn<T, T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1, T2>(int evt, T1 arg1, T2 arg2)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T, T1, T2>)func;
                return fn(arg1, arg2);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1, T2, T3>(int evt, Fn<T, T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1, T2, T3>(int evt, Fn<T, T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1, T2, T3>(int evt, T1 arg1, T2 arg2, T3 arg3)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T, T1, T2, T3>)func;
                return fn(arg1, arg2, arg3);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1, T2, T3, T4>(int evt, Fn<T, T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1, T2, T3, T4>(int evt, Fn<T, T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }
        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1, T2, T3, T4>(int evt, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
    {
        Delegate func;
        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T, T1, T2, T3, T4>)func;
                return fn(arg1, arg2, arg3, arg4);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);

        }

        return default(T);
    }

    
}

三、使用案例

接下来就是重点了，那我们如何使用呢？
比如说我要做一个功能，按下Esc键，退出app

1.没有参数的调用

那首先，我们就要先注册事件

EventDispatcher.GameEvent.Regist(4500,EscBehavior);
private void EscBehavior()
    {
        Application.Quit();
    }

触发事件

private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            Debug.Log("发了4500");
            EventDispatcher.GameEvent.DispatchEvent(4500);
        }
    }

移除事件

 private void OnDestroy()
    {
        EventDispatcher.GameEvent.UnRegist(4500,EscBehavior);
    }

这就是一个完整的调用流程。

2.有参数的调用

又有人问了，那需要传参的怎么用啊
需要传参的用法，那他来了
熟悉的配方：
在这里插入图片描述

1.注册事件

EventDispatcher.GameEvent.Regist<string>(4500,EscBehavior);
private void EscBehavior(string content)
    {
        Debug.Log("要debug的内容:"+content);
        Application.Quit();
    }

2.触发事件

private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            Debug.Log("发了4500");
             EventDispatcher.GameEvent.DispatchEvent<string>(4500,"必须要退出app啦！！！！！");
        }
    }

3.移除事件

private void OnDestroy()
    {
        EventDispatcher.GameEvent.UnRegist<string>(4500,EscBehavior);
    }

至此就大功告成了，小姐姐的手终于不麻了。

总结

欢迎大佬多多来给萌新指正，欢迎大家来共同探讨。
如果各位看官觉得文章有点点帮助，跪求各位给点个“一键三连”，谢啦~

声明：本博文章若非特殊注明皆为原创原文链接
https://blog.csdn.net/Wrinkle2017/article/details/119575597
————————————————————————————————

版权声明

版权声明：本博客为非营利性个人原创
所刊登的所有作品的著作权均为本人所拥有
本人保留所有法定权利,违者必究!
对于需要复制、转载、链接和传播博客文章或内容的
请及时和本博主进行联系
对于经本博主明确授权和许可使用文章及内容的
使用时请注明文章或内容出处并注明网址
转载请附上原文出处链接及本声明

【从零开始入门unity游戏开发之——C#篇02】安装vscode、创建C#项目、注释、region代码折叠、打印
向宇
12-12 2513
【从零开始入门unity游戏开发之——C#篇02】安装vscode、创建C#项目、注释、打印
Unity游戏开发实战：C#脚本编程全攻略与深度优化指南
java专栏
04-23 2772
本文从零开始，详细介绍了Unity游戏开发中的C#脚本编程技巧与优化方案，包括脚本创建、生命周期方法、性能优化、面向对象设计、脚本通信以及性能分析与优化。结合文中提供的代码示例与注释，您可以轻松地将这些知识应用到实际游戏开发中，并为进一步提升Unity项目的性能与可维护性打下坚实基础。：针对Profiler找出的问题，进行代码重构，如减少冗余计算、优化算法、使用更高效的数据结构等。：使用Unity Profiler分析游戏性能瓶颈，如CPU、GPU使用率，内存分配等。等类，实现职责分离。
Unity事件派发器机制
_阿松先生的博客
08-30 1459
EventStruct派发全局静态类 using UnityEngine; using System; using System.Collections; using System.Collections.Generic; public enum GameEvent { START_GAME, END_GAME } public class EventCallBack ...
[Unity] 事件分发系统
sarono的博客
04-11 938
[Unity] Utilities 之 MessageDispatcher 文章目录[Unity] Utilities 之 MessageDispatcher1.设计MessageListenerMessageDispatcher2.测试测试代码测试图片3.总结 参考资料： https://gpp.tkchu.me/event-queue.html Message Dispatcher插件 1...
【Unity】事件分发系统的使用示例
最新发布
玉夏的博客
09-15 395
通过这个示例，可以清晰看到事件系统的解耦优势。
事件分发机制--unity碰撞器的使用
12-28
对于事件分发机制的使用，当碰到物体时，会集中调用事件
Unity 事件派发
曾用名：极客柒
01-25 636
方法 功能 备注 Watcher.on 注册监听 注册一个事件监听j Watcher.off 移除监听 移除一个事件监听 Watcher.Dispatch 派发事件 广播事件 前言: 由事件类和监听接口组成 自定义一个事件前，必须提供一个事件的监听方法以及一个事件标签。 好处: 各个模块专心的做自己的事情，不需要过问其他模块的事情 解耦 代码部分~ using System; using System.Col...
U3D C# 事件派发系统(自研)
qq_44810574的博客
07-15 530
请大家认真看完，看完必懂！ 这个类是事件的控制器类。相当于事件基类。 分别含有： 事件注入；事件移除；事件触发。 using System; using System.Collections.Generic; namespace SZL { /// <summary> /// 事件控制器 /// </summary> public class EventController { private Dictionary<st
《Unity5实战使用C#和Unity开发多平台游戏》官方源码
12-07
《Unity5实战使用C#和Unity开发多平台游戏》官方源码是一份极其珍贵的资源，对于想要深入学习Unity游戏引擎以及C#编程语言的开发者来说，它提供了丰富的实践案例和代码示例。这本书的核心是教你如何利用Unity5的强大...
【unity游戏开发之InputSystem——04】通过事件和接口方式对输入配置文件（Input Actions）生成的C#代码进行输入监听（基于unity6开发介绍）
向宇
01-23 2919
【unity游戏开发之InputSystem——04】通过事件和接口方式对输入配置文件（Input Actions）生成的C#代码进行输入监听（基于unity6开发介绍）
【零基础入门unity游戏开发——unity3D篇】unity CharacterController 3D角色控制器最详细的使用介绍，并实现俯视角、第三人称角色控制（附项目源码）
向宇
08-29 4319
【unity小技巧】unity最完美的CharacterController 3d角色控制器，实现移动、跳跃、下蹲、奔跑、上下坡、物理碰撞效果，复制粘贴即用但是我发现很多人还是不理解，都跑来私信问我，所以决定重新做一个更加详细且简单控制器，主要是实现俯视角和第三人称角色控制。添加一个胶囊体，添加Character Controller组件，记得删除Capsule Collider组件，因为Character Controller自带了碰撞，所以不需要Character Controller参数介绍。
C#事件派发器
qq_39599879的博客
11-19 802
事件派发器在监听想要监听的事件后，可以灵活的广播触发事件，可以使代码更加的调理化，易于阅读，符合开发者规范，话不多说，上代码： using System; using System.Collections; using System.Collections.Generic; public class EventManager { private static Dictionary<...
Unity事件分发器
abc1090275833的博客
03-18 1123
事件分发机制也被称之为事件监听派发系统，在每个游戏框架中都是不可或缺的一个模块。起作用主要是用来解耦，监听网络消息，或者做一些异步的操作等，下面是使用C#在Unity游戏开发中的事件分发处理机制的简单实现，希望能帮到大家。 using UnityEngine; using System.Collections; using System.Collections.Generic; ...
Unity3D 全局逻辑事件/消息派发 实现
weixin_30861797的博客
04-14 323
1.先看下怎么使用的 1）脚本中注册逻辑事件 void Start () { m_pGUICanvasObj = GameObject.Find("Canvas"); if(m_pGUICanvasObj != null) { m_pGUICa...
Unity基于事件机制的消息系统
qq_42553673的博客
08-30 1452
很多刚入行的小白同学在处理类与类之间的关系时，总是比较简单除暴的处理，直接把那个类引用到这个类，把这个类引用到那个类，最后造成很多类相互引用，形成一个复杂的蜘蛛网式的引用关系，这就是代码的耦合。如果耦合过于严重会导致代码非常难以维护并且会产生很多bug,非常难受（en ,我非常难受）。 所以我们引入了事件机制，利用事件机制进行解耦合，事件机制其实是一种叫做观察者模式的设计模式，事件的本质是一种方法的委托（Delegate），把回调方法委托到事件管理器，当条件达到时，通过事件key来告诉事件管理器可以执行那些
Unity虚拟摇杆（事件分发器实现）
m0_52021450的博客
03-12 4015
目录 搭建UI 编写代码 搭建UI ①创建一个image 命名为ControlArea 作为按钮识别的检测范围 并将透明度设置为1（透明度为0不触发事件检测） ②如下图的父子关系添加 image 并命名 找到合适的素材拖给相应的image 设置合适的大小（根据自己的喜好和素材的大小自行设置） ③注意选中joystick 的 锚点（花）放到左下角 防止因为分辨率改变使得按钮位置改变 中心点（pivot）的位置设置为（0.5，0.5）如下图 实现脚本 ...
Unity 3D 消息事件系统 NotificationCenter、CEventDispatcher事件分发机制
暗光之痕的博客
02-20 4411
版本：unity 5.4.1  语言：C#   实战核心技术这本书来到了第三章，这里给了一个消息事件系统，这是几乎每一个游戏系统都会用到的一个常用技术，非常好用，但如果你add之后忘记remove的话。。。相信每个使用过它的人都经历过这样的痛苦。   闲话不多说，书中类的名字是CEventDispatcher，而我会按照我的习惯来实现一遍，就叫做NotificationCenter，对，c
Unity 消息发送机制 解析
v1t1p9hvbd的博客
05-10 1014
1.思考  消息发送机制，也可以叫做观察者设计模式（应该是这样的）。 通俗易懂点讲，就是 一个物体发出消息，另外一个，或者几个物体可以同时接收到这一消息并作出各自不同的行为（反馈，处理）。 那么，首先，我们想到，需要什么？ I: 我们需要的是消息（实例），发送者。 消息（实例）+发送者=我们需要的消息，就能够处理任何消息。 II：怎么把这个消息发送出去（消息处理中心）。 III：发送者
Unity3D C#事件管理:EventManager
延澈左的专栏
06-10 3508
原文地址：http://bbs.9ria.com/thread-153258-1-1.html 多年的Flash开发，我非常欣赏Flash的事件系统。Uinty对象通信所使用的方法SendMessage在多数情况下是工作正常，但如果在一个具有无数引用其他对象的GameObject的大型项目进行反射，那问题就来了。 我用C＃在Uinty中所写的第一个东西，就是管理抽象类的事件管理系统。究其核
Unity引擎C#编写完整桌球游戏源码详解
标题“桌球游戏源码”和描述部分表明了这份文件包含了完整的桌球游戏源代码，该游戏是基于Unity引擎开发，使用了C#编程语言，并且具有丰富的资源文件和详细的代码注释。因此，以下是针对标题和描述中提到的几个核心...
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值