C#语言中的异步事件

最新推荐文章于 2024-04-19 09:27:18 发布
最新推荐文章于 2024-04-19 09:27:18 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： CSharp.NET 文章标签： c# event
原文链接：https://www.codeproject.com/Articles/5341837/Asynchronous-Events-in-Csharp
版权

目录

介绍

事件机制在单个线程上提供同步调用

使用TPL的异步事件

使用TPL的异步事件——扩展方法

使用TAP的异步事件

使用TAP – Ver2的异步事件

结论

参考

介绍

像C#这样的现代语言集成了事件机制，它实际上将观察者模式集成到语言机制中。

实际上，事件机制提供同步调用这一事实经常被忽视，并且没有得到足够的重视。程序员经常有并行的错觉，这不是现实，是当今多核处理器世界中的一个重要问题。接下来，我们提供多线程问题的分析和解决方案。

提供的代码是一个教程，概念演示级别，为简洁起见，不处理或显示所有变体/问题。

事件机制在单个线程上提供同步调用

需要强调的是，在调用中：

if (SubjectEvent != null)
{
    SubjectEvent(this, args);
}

//or

SubjectEvent?.Invoke(this, args);

正在单个线程上同步调用订阅的EventHandler。这有一些不太明显的后果：

  • 按订阅事件的顺序依次执行EventHandler。
  • 这意味着早期订阅EventHandler的对象/值比其他订阅EventHandler的对象/值更新得更早，这可能会对程序逻辑产生影响。
  • 调用某些EventHandler将阻塞线程，直到完成其EventHandler中的所有工作。
  • 如果在某个EventHandler中抛出异常，则在该异常之后订阅的所有EventHandler将不会执行。

我们将在示例中演示它。计划是创建三个EventHandler，每个EventHandler需要10秒才能完成，并监视每个运行线程的线程以及所花费的总时间。我们将输出与此示例相关的每个线程ThreadId，以查看正在使用的线程数。

public class EventArgsW : EventArgs
{
    public string StateW = null;
}

public class EventWrapper
{
    public event EventHandler<EventArgsW> EventW;

    public string StateW;

    public void Notify()
    {
        Console.WriteLine("Notify is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        EventArgsW args = new EventArgsW();
        args.StateW = this.StateW;

        EventW?.Invoke(this, args);
    }
}

public class HandlerWrapper
{
    private string name;
    private string StateW;
    private ManualResetEvent mrs;

    public HandlerWrapper(string name, ManualResetEvent mrs)
    {
        this.name = name;
        this.mrs = mrs;
    }

    public void Handler(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0} is running on ThreadId:{1}",
            name, Thread.CurrentThread.ManagedThreadId);

        Worker(subject, args);
    }

    private void Worker(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0}.Worker is running on ThreadId:{1}, i:0",
            name, Thread.CurrentThread.ManagedThreadId);
        StateW = args.StateW;

        for (int i = 1; i <= 2; ++i)
        {
            Thread.Sleep(5000);
            Console.WriteLine("Handler{0}.Worker is running on ThreadId:{1}, i:{2}",
                name, Thread.CurrentThread.ManagedThreadId, i);
        }
        mrs.Set();
    }
}

internal class Client
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Client is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        ManualResetEvent[] mres = new ManualResetEvent[3];
        for (int i = 0; i < mres.Length; i++) mres[i] = new ManualResetEvent(false);

        EventWrapper s = new EventWrapper();
        s.EventW += (new HandlerWrapper("1", mres[0])).Handler;
        s.EventW += (new HandlerWrapper("2", mres[1])).Handler;
        s.EventW += (new HandlerWrapper("3", mres[2])).Handler;

        // Change subject state and notify observers
        s.StateW = "ABC123";

        var timer = new Stopwatch();
        timer.Start();

        s.Notify();

        ManualResetEvent.WaitAll(mres);
        timer.Stop();
        TimeSpan timeTaken = timer.Elapsed;
        string tmp1 = "Client time taken: " + timeTaken.ToString(@"m\:ss\.fff");
        Console.WriteLine(tmp1);

        Console.ReadLine();
    }
}

执行结果为：

从执行结果可以看出，EventHandler一个接一个地运行，全部在thread Id=1上，与客户端运行的线程相同。完成所有工作需要30.059秒。

使用TPL的异步事件

使用任务并行库（TPL），我们可以使我们的EventHandler在单独的线程上异步运行。更重要的是，如果我们想将Client线程从任何工作中释放出来（假设我们的Client是UI线程），我们可以在与Client线程不同的线程上引发Event（调度EventHandler调用）。以下是新的实现：

新的解决方案代码如下所示：

public class EventArgsW : EventArgs
{
    public string StateW = null;
}

public class EventWrapper
{
    public event EventHandler<EventArgsW> EventW;

    public string StateW;

    public void Notify()
    {
        Task.Factory.StartNew(
            () => {
                Console.WriteLine("Notify is running on ThreadId:{0}",
                Thread.CurrentThread.ManagedThreadId);

                EventArgsW args = new EventArgsW();
                args.StateW = this.StateW;

                EventW?.Invoke(this, args);
            });
    }
}

public class HandlerWrapper
{
    private string name;
    private string StateW;
    private ManualResetEvent mrs;

    public HandlerWrapper(string name, ManualResetEvent mrs)
    {
        this.name = name;
        this.mrs = mrs;
    }

    public void Handler(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0} is running on ThreadId:{1}",
            name, Thread.CurrentThread.ManagedThreadId);

        Task.Factory.StartNew(
            () => Worker(subject, args)); ;
    }

    private void Worker(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0}.Worker is running on ThreadId:{1}, i:0",
            name, Thread.CurrentThread.ManagedThreadId);
        StateW = args.StateW;

        for (int i = 1; i <= 2; ++i)
        {
            Thread.Sleep(5000);
            Console.WriteLine("Handler{0}.Worker is running on ThreadId:{1}, i:{2}",
                name, Thread.CurrentThread.ManagedThreadId, i);
        }
        mrs.Set();
    }
}

internal class Client
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Client is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        ManualResetEvent[] mres = new ManualResetEvent[3];
        for (int i = 0; i < mres.Length; i++) mres[i] = new ManualResetEvent(false);

        EventWrapper s = new EventWrapper();
        s.EventW += (new HandlerWrapper("1", mres[0])).Handler;
        s.EventW += (new HandlerWrapper("2", mres[1])).Handler;
        s.EventW += (new HandlerWrapper("3", mres[2])).Handler;

        // Change subject state and notify observers
        s.StateW = "ABC123";

        var timer = new Stopwatch();
        timer.Start();

        s.Notify();

        ManualResetEvent.WaitAll(mres);
        timer.Stop();
        TimeSpan timeTaken = timer.Elapsed;
        string tmp1 = "Client time taken: " + timeTaken.ToString(@"m\:ss\.fff");
        Console.WriteLine(tmp1);

        Console.ReadLine();
    }
}

执行结果在这里：

从执行结果可以看出，我们看到EventHandler在单独的线程上运行，从执行日志中可以看到并发性，总耗时为10.020秒。

使用TPL的异步事件——扩展方法

由于TPL的使用需要更改现有代码并混淆代码的可读性，因此我创建了一个Extension方法来简化TPL的使用。而不是编写：

EventW?.Invoke(this, args);

有人会这样编写：

EventW?.InvokeAsync<EventArgsW>(this, args);

所有的TPL魔法都会在幕后发生。以下是新解决方案的所有源代码：

public class EventArgsW : EventArgs
{
    public string StateW = null;
}

public class EventWrapper
{
    public event EventHandler<EventArgsW> EventW;

    public string StateW;

    public void Notify()
    {
        Console.WriteLine("Notify is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        EventArgsW args = new EventArgsW();
        args.StateW = this.StateW;

        EventW?.InvokeAsync<EventArgsW>(this, args);  //(1)
    }
}

public class HandlerWrapper
{
    private string name;
    private string StateW;
    private ManualResetEvent mrs;

    public HandlerWrapper(string name, ManualResetEvent mrs)
    {
        this.name = name;
        this.mrs = mrs;
    }

    public void Handler(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0} is running on ThreadId:{1}",
            name, Thread.CurrentThread.ManagedThreadId);

        Worker(subject, args);
    }

    private void Worker(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0}.Worker is running on ThreadId:{1}, i:0",
            name, Thread.CurrentThread.ManagedThreadId);
        StateW = args.StateW;

        for (int i = 1; i <= 2; ++i)
        {
            Thread.Sleep(5000);
            Console.WriteLine("Handler{0}.Worker is running on ThreadId:{1}, i:{2}",
                name, Thread.CurrentThread.ManagedThreadId, i);
        }
        mrs.Set();
    }
}

public static class AsyncEventsUsingTplExtension
{
    public static void InvokeAsync<TEventArgs>   //(2)
        (this EventHandler<TEventArgs> handler, object sender, TEventArgs args)
    {
        Task.Factory.StartNew(() =>
        {
            Console.WriteLine("InvokeAsync<TEventArgs> is running on ThreadId:{0}",
                Thread.CurrentThread.ManagedThreadId);

            var delegates = handler?.GetInvocationList();

            foreach (var delegated in delegates)
            {
                var myEventHandler = delegated as EventHandler<TEventArgs>;
                if (myEventHandler != null)
                {
                    Task.Factory.StartNew(() => myEventHandler(sender, args));
                }
            };
        });
    }
}

internal class Client
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Client is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        ManualResetEvent[] mres = new ManualResetEvent[3];
        for (int i = 0; i < mres.Length; i++) mres[i] = new ManualResetEvent(false);

        EventWrapper s = new EventWrapper();
        s.EventW += (new HandlerWrapper("1", mres[0])).Handler;
        s.EventW += (new HandlerWrapper("2", mres[1])).Handler;
        s.EventW += (new HandlerWrapper("3", mres[2])).Handler;

        // Change subject state and notify observers
        s.StateW = "ABC123";

        var timer = new Stopwatch();
        timer.Start();

        s.Notify();

        ManualResetEvent.WaitAll(mres);
        timer.Stop();
        TimeSpan timeTaken = timer.Elapsed;
        string tmp1 = "Client time taken: " + timeTaken.ToString(@"m\:ss\.fff");
        Console.WriteLine(tmp1);

        Console.ReadLine();
    }
}

这是执行结果：

从执行结果可以看出，我们看到EventHandle在单独的线程上运行，从执行日志中可以看到并发性，总耗时为10.039秒。TPL正在将工作分派给线程池中的线程，可以看到线程Id=4已被使用了两次，可能它提前完成了工作并再次可用于工作。

使用TAP的异步事件

根据它们在C#中的定义方式的性质，EventHandler是任务异步模式（TAP）上下文中的同步函数。如果您希望EventHandler在TAP的上下文中异步，以便您可以在其中等待，您需要实际推出自己的事件通知机制，以支持您的自定义异步EventHandler版本。在[1]中可以看到这种工作的一个很好的例子。出于示例的目的，我修改了该代码，以下是解决方案的新版本：

public class EventArgsW : EventArgs
{
    public string StateW = null;
}

public class EventWrapper
{
    public event AsyncEventHandler<EventArgsW> EventW;

    public string StateW;

    public async Task Notify(CancellationToken token)
    {
        Console.WriteLine("Notify is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        EventArgsW args = new EventArgsW();
        args.StateW = this.StateW;

        await this.EventW.InvokeAsync(this, args, token);
    }
}

public class HandlerWrapper
{
    private string name;
    private string StateW;
    private ManualResetEvent mrs;

    public HandlerWrapper(string name, ManualResetEvent mrs)
    {
        this.name = name;
        this.mrs = mrs;
    }

    public async Task Handler(object subject, EventArgsW args,
        CancellationToken token)
    {
        Console.WriteLine("Handler{0} is running on ThreadId:{1}",
            name, Thread.CurrentThread.ManagedThreadId);

        await Worker(subject, args);
    }

    private async Task Worker(object subject, EventArgsW args)
    {
        Console.WriteLine("Handler{0}.Worker is running on ThreadId:" +
            "{1}, i:0",
            name, Thread.CurrentThread.ManagedThreadId);
        StateW = args.StateW;

        for (int i = 1; i <= 2; ++i)
        {
            Thread.Sleep(5000);
            Console.WriteLine("Handler{0}.Worker is running on ThreadId:" +
                "{1}, i:{2}",
                name, Thread.CurrentThread.ManagedThreadId, i);
        }
        await Task.Delay(0);
        mrs.Set();
    }
}

public delegate Task AsyncEventHandler<TEventArgs>(
        object sender, TEventArgs e, CancellationToken token);

public static class AsynEventHandlerExtensions
{
    // invoke an async event (with null-checking)
    public static async Task InvokeAsync<TEventArgs>(
        this AsyncEventHandler<TEventArgs> handler,
        object sender, TEventArgs args, CancellationToken token)
    {
        await Task.Run(async () =>
        {
            Console.WriteLine("InvokeAsync<TEventArgs> is running on ThreadId:{0}",
                Thread.CurrentThread.ManagedThreadId);

            var delegates = handler?.GetInvocationList();
            if (delegates?.Length > 0)
            {
                var tasks =
                delegates
                .Cast<AsyncEventHandler<TEventArgs>>()
                .Select(e => Task.Run(
                    async () => await e.Invoke(sender, args, token)));
                await Task.WhenAll(tasks);
            }
        }).ConfigureAwait(false);
    }
}

internal class Client
{
    public static async Task Main(string[] args)
    {
        Console.WriteLine("Client is running on ThreadId:{0}",
            Thread.CurrentThread.ManagedThreadId);

        ManualResetEvent[] mres = new ManualResetEvent[3];
        for (int i = 0; i < mres.Length; i++)
            mres[i] = new ManualResetEvent(false);

        EventWrapper s = new EventWrapper();
        s.EventW += (new HandlerWrapper("1", mres[0])).Handler;
        s.EventW += (new HandlerWrapper("2", mres[1])).Handler;
        s.EventW += (new HandlerWrapper("3", mres[2])).Handler;

        // Change subject state and notify observers
        s.StateW = "ABC123";

        var timer = new Stopwatch();
        timer.Start();

        await s.Notify(CancellationToken.None);

        ManualResetEvent.WaitAll(mres);
        timer.Stop();
        TimeSpan timeTaken = timer.Elapsed;
        string tmp1 = "Client time taken: " +
            timeTaken.ToString(@"m\:ss\.fff");
        Console.WriteLine(tmp1);

        Console.ReadLine();
    }
}

这是执行结果：

从执行结果可以看出，我们看到EventHandler，现在异步在单独的线程上运行，从执行日志中可以看到并发性，总耗时为10.063秒。

使用TAP – Ver2的异步事件

虽然这不是本文的主要目的，但我们可以更改代码以更好地演示TAP模式。我们只对上面的项目代码做一个小的更改，改变一种方法，所有其他方法都与上面相同。

private async Task Worker(object subject, EventArgsW args)
{
    Console.WriteLine("Handler{0}.Worker is running on ThreadId:" +
        "{1}, i:0",
        name, Thread.CurrentThread.ManagedThreadId);
    StateW = args.StateW;

    for (int i = 1; i <= 2; ++i)
    {
        await Task.Delay(5000);
        Console.WriteLine("Handler{0}.Worker is running on ThreadId:" +
            "{1}, i:{2}",
            name, Thread.CurrentThread.ManagedThreadId, i);
    }
    mrs.Set();
}

现在，我们得到以下执行结果：

例如，如果我们把注意力集中在Handler1.Worker上，我们可以看到该异步方法已经在ID为 5，8，6的线程的三个来自ThreadPool的不同线程上运行。由于TAP模式，这一切都很好，因为await方法的工作被ThreadPool中的下一个可用线程选择。并发性再次明显，总时间为10.101秒。

结论

实际上，事件机制提供对EventHandler的同步调用。我们在上面的例子中展示了如何异步调用EventHandler。代码中提供了两种可重用的扩展方法，它们简化了异步调用实现。好处是并行调用EventHandler，这在当今的多核系统中很重要。

参考

https://www.codeproject.com/Articles/5341837/Asynchronous-Events-in-Csharp

寒冰屋
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【微软技术栈】C#.NET 异步编程
Coding life, Coding world, Coding feature.
10-12 397
C# 拥有语言级别的异步编程模型，让你能轻松编写异步代码，而无需应付回调或受限于支持异步的库。 它遵循基于任务的异步模式 (TAP)。如果需要 I/O 绑定（例如从网络请求数据、访问数据库或读取和写入到文件系统），则需要利用异步编程。 还可以使用 CPU 绑定代码（例如执行成本高昂的计算），对编写异步代码而言，这是一个不错的方案。
C# 深入理解事件（event）机制
明月清风@的博客
07-18 4000
事件作为类的成员，一般是通过事件向其他类或对象通知发生的相关事情。发送事件的类称为发布者，接收事件的类称为订阅者。发布者确定何时引发事件；订阅者确定对事件作出何种响应一个事件可以有多个订阅者。订阅者可以处理来自多个发行者的多个事件。没有订阅者的事件永远也不会引发。事件通常用于表示用户操作，例如单击按钮或图形用户界面中的菜单选项。当事件具有多个订阅者时，引发该事件时会同步调用事件处理程序。也可通过async/await达到异步调用事件的作用。
c#异步调用的几种方式（五）
最新发布
sbk100的博客
04-19 1159
异步await实例
C# 异步方法的运行机制
qq_35320456的博客
03-02 1348
C# 异步方法的运行机制
C#异步编程(async and await)及异步方法同步调用
极客神殿
02-28 6400
1、什么是异步？ 异步操作通常用于执行完成时间可能较长的任务，如打开大文件、连接远程计算机或查询数据库=异步操作在主应用程序线程以外的线程中执行。应用程序调用方法异步执行某个操作时，应用程序可在异步方法执行其任务时继续执行。 2、同步与异步的区别 同步（Synchronous）：在执行某个操作时，应用程序必须等待该操作执行完成后才能继续执行。 异步（Asynchronous）：在执行某个操作时，应用程序可在异步操作执行时继续执行。实质：异步操作，启动了新的线程，主线程与方法线程并行执行。 3、异步和多线程的
事件是同步还是异步(总结)
我有三种目的：坚持、思考、太阳
09-02 1099
事件是同步还是异步，react中的事件绑定this问题，vue的事件绑定this问题 这四个按钮依次点击输出的是 dom0级绑定依赖dom对象上的onclick属性 ① 要是按照的写法会将红色部分作为参数传入dom对象上的onclick属性里面（此属性是个函数） ② 第二个按钮其test函数和上面。 ③ 第三种方式： btn是拿到的这个按钮，也就是dom对象。这种写法是往对象身上添加一个方法，那这里一样的道理用自己写的onclick函数替换了dom对象上原本的那个属性 ④dom2级
C#异步调用四大方法
12-22
C#异步调用四大方法是什么呢？C#异步调用四大方法的使用是如何进行的呢？让我们首先了解下什么时候用到C#异步调用： 　.NET Framework 允许您C#异步调用任何方法。定义与您需要调用的方法具有相同签名的委托；公共...
C#语言定义文档 中文版(微软官网)
01-18
C#语言定义文档是微软官方发布的重要参考资料，它详细阐述了C#语法、特性、语义以及程序设计的核心原则。这份中文版文档使得国内开发者能够更方便地学习和理解C#，从而在开发Windows应用、Web应用、移动应用等领域...
C# TCP 异步通信
04-30
C#作为.NET框架的主要编程语言，提供了强大的支持来实现网络通信，其中包括TCP（传输控制协议）异步通信。TCP是一种面向连接的、可靠的传输协议，而异步通信则能确保程序在进行网络操作时不会阻塞主线程，提高应用的...
CSharpAsyncSocket:C#语言编写的异步套接字通信
07-06
4. **回调函数**：在C#中，异步操作完成后通常会调用预先定义的回调函数，例如`SocketAsyncEventArgs.Completed`事件。在这里，你可以处理接收到的数据，或者准备并发送新的数据。 5. **错误处理**：异步操作可能会...
C#同步和异步调用方法实例
09-04
C#语言中，同步和异步调用是两种不同的编程方式，对于程序的执行效率和响应速度有着至关重要的影响。同步调用是指程序按照顺序执行每一条语句，而异步调用则是指程序可以在执行一条语句时，同时执行其他语句，提高...
C# 多线程异步执行
06-20
使用委托事件模拟多线程下载网络图片，即同时发送多个网络请求下载图片。 也可应用于其他异步多线程执行事件。
C#多线程开发之----委托异步运行，事件结束回调
oSenLin123456的博客
09-28 155
【代码】C#多线程开发之----委托异步运行，事件结束回调。
C#如何使用Task完成异步方法
weixin_66598341的博客
04-06 4305
简单介绍了在C#中如何使用Task完成简单的异步方法，内容包含了创建简单的异步方法，异步的取消，异步的等待...
c#中使用任务队列实现异步
小仙女的博客
08-28 2573
1、类QueueMessage using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace CHEER.Common { public class QueueMessage { ...
同步 异步和事件
a404007652的博客
11-10 747
同步和异步 事件 浏览器提供了同步和异步机制 JS是单线程的，提供了两个队列，一个是主队列（放同步代码），一个是异步队列队列池。 同步 所有的代码按顺序执行，每一部分执行完后才能执行下面的代码。 异步 这块代码执行后，可以去做其他事情，等这块代码执行完后，再回来处理这里的事项。 异步性能会比较高 回调函数 ajax 定时器 时间 ...
JavaScript：彻底理解同步、异步和事件循环(Event Loop)
weixin_34128534的博客
12-08 294
一. 单线程 我们常说“JavaScript是单线程的”。 所谓单线程，是指在JS引擎中负责解释和执行JavaScript代码的线程只有一个。不妨叫它主线程。 但是实际上还存在其他的线程。例如：处理AJAX请求的线程、处理DOM事件的线程、定时器线程、读写文件的线程(例如在Node.js中)等等。这些线程可能存在于JS引擎之内，也可能存在于JS引擎之...
C#异步方法调用（四大方法详解）
shaily读书学习
07-02 1971
<br />计算机中有些处理比较耗时。调用这种处理代码时，调用方如果站在那里苦苦等待，会严重影响程序性能。例如，某个程序启动后如果需要打开文件读出其中的数据，再根据这些数据进行一系列初始化处理，程序主窗口将迟迟不能显示，让用户感到这个程序怎么等半天也不出来，太差劲了。借助异步调用可以把问题轻松化解：把整个初始化处理放进一个单独线程，主线程启动此线程后接着往下走，让主窗口瞬间显示出来。等用户盯着窗口犯呆时，初始化处理就在背后悄悄完成了。程序开始稳定运行以后，还可以继续使用这种技巧改善人机交互的瞬时反应。用户点
C# 异步编程(async和await)
weixin_52026996的博客
08-01 4498
在C#中，如果需要 I/O 绑定（例如从网络请求数据、访问数据库或读取和写入到文件系统），则需要利用异步编程。 还可以使用 CPU 绑定代码（例如执行成本高昂的计算），对编写异步代码而言，写法简单易用。异步编程其实也就是Task实现的多线程。本文主要介绍C# 异步编程(async和await)。...
C# windows label 异步移动
09-01
可以使用C#中的`async/await`语法和`Task.Delay()`方法来实现异步移动Label。以下是一个简单的例子： ```csharp private async void MoveLabelAsync() { while (true) { label1.Left += 5; await Task.Delay...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值