ASP.NET Core 实现后台任务 IHostedService 和 BackgroundService

最新推荐文章于 2024-09-09 07:45:12 发布
最新推荐文章于 2024-09-09 07:45:12 发布
阅读量2.9w 收藏 25
点赞数 19
分类专栏： .Net Core 文章标签： .Net Core IHostedService 后台任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hefeng_aspnet/article/details/141261776
版权

在 ASP.NET Core 中，后台任务作为托管服务实现。 托管服务是一个类，具有实现 IHostedService 接口的后台任务逻辑。 本文提供了三个托管服务示例：

辅助角色服务模板

ASP.NET Core 辅助角色服务模板可作为编写长期服务应用的起点。 通过辅助角色服务模板创建的应用将在其项目文件中指定 Worker SDK：

<Project Sdk="Microsoft.NET.Sdk.Worker">

要使用该模板作为编写托管服务应用的基础： 

Visual Studio： 

  1. 创建新项目。
  2. 选择“辅助角色服务”。 选择“下一步”。
  3. 在“项目名称”字段提供项目名称，或接受默认项目名称。 选择“下一页”。
  4. 在“其他信息”对话框中，选择“框架” 。 选择创建。

.NET CLI： 

将辅助角色服务 (worker) 模板用于命令行界面中的 dotnet new 命令。 下面的示例中创建了名为 ContosoWorker 的辅助角色服务应用。 执行命令时会自动为 ContosoWorker 应用创建文件夹。 

dotnet new worker -o ContosoWorker 

程序包

基于辅助角色服务模板的应用使用 Microsoft.NET.Sdk.Worker SDK，并且具有对 Microsoft.Extensions.Hosting 包的显式包引用。 有关示例，请参阅示例应用的项目文件 (BackgroundTasksSample.csproj)。

对于使用 Microsoft.NET.Sdk.Web SDK 的 Web 应用，通过共享框架隐式引用 Microsoft.Extensions.Hosting 包。 在应用的项目文件中不需要显式包引用。

IHostedService 接口

IHostedService 接口为主机托管的对象定义了两种方法：

StartAsync

StartAsync(CancellationToken) 包含用于启动后台任务的逻辑。 在以下操作之前调用 StartAsync：

StartAsync 应仅限于短期任务，因为托管服务是按顺序运行的，在 StartAsync 运行完成之前不会启动其他服务。

StopAsync

默认情况下，取消令牌会有 30 秒超时，以指示关闭进程不再正常。 在令牌上请求取消时：

  • 应中止应用正在执行的任何剩余后台操作。
  • StopAsync 中调用的任何方法都应及时返回。

但是，在请求取消后，将不会放弃任务，调用方会等待所有任务完成。

如果应用意外关闭（例如，应用的进程失败），则可能不会调用 StopAsync。 因此，在 StopAsync 中执行的任何方法或操作都可能不会发生。

若要延长默认值为 30 秒的关闭超时值，请设置：

托管服务在应用启动时激活一次，在应用关闭时正常关闭。 如果在执行后台任务期间引发错误，即使未调用 StopAsync，也应调用 Dispose。

BackgroundService 基类

BackgroundService 是用于实现长时间运行的 IHostedService 的基类。

调用 ExecuteAsync(CancellationToken) 来运行后台服务。 实现返回一个 Task，其表示后台服务的整个生存期。 在 ExecuteAsync 变为异步（例如通过调用 await）之前，不会启动任何其他服务。 避免在 ExecuteAsync 中执行长时间的阻塞初始化工作。 StopAsync(CancellationToken) 中的主机块等待完成 ExecuteAsync。

调用 IHostedService.StopAsync 时，将触发取消令牌。 当激发取消令牌以便正常关闭服务时，ExecuteAsync 的实现应立即完成。 否则，服务将在关闭超时后不正常关闭。 有关更多信息，请参阅 IHostedService interface 部分。

有关详细信息，请参阅 BackgroundService 源代码。

计时的后台任务

定时后台任务使用 System.Threading.Timer 类。 计时器触发任务的 DoWork 方法。 在 StopAsync 上禁用计时器，并在 Dispose 上处置服务容器时处置计时器：

public class TimedHostedService : IHostedService, IDisposable
{
    private int executionCount = 0;
    private readonly ILogger<TimedHostedService> _logger;
    private Timer? _timer = null;

    public TimedHostedService(ILogger<TimedHostedService> logger)
    {
        _logger = logger;
    }

    public Task StartAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service running.");

        _timer = new Timer(DoWork, null, TimeSpan.Zero,
            TimeSpan.FromSeconds(5));

        return Task.CompletedTask;
    }

    private void DoWork(object? state)
    {
        var count = Interlocked.Increment(ref executionCount);

        _logger.LogInformation(
            "Timed Hosted Service is working. Count: {Count}", count);
    }

    public Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service is stopping.");

        _timer?.Change(Timeout.Infinite, 0);

        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

Timer 不等待先前的 DoWork 执行完成，因此所介绍的方法可能并不适用于所有场景。 使用 Interlocked.Increment 以原子操作的形式将执行计数器递增，这可确保多个线程不会并行更新 executionCount。

已使用 AddHostedService 扩展方法在 IHostBuilder.ConfigureServices (Program.cs) 中注册该服务：

services.AddHostedService<TimedHostedService>(); 

在后台任务中使用有作用域的服务

要在 BackgroundService 中使用有作用域的服务，请创建作用域。 默认情况下，不会为托管服务创建作用域。

作用域后台任务服务包含后台任务的逻辑。 如下示例中：

  • 服务是异步的。 DoWork 方法返回 Task。 出于演示目的，在 DoWork 方法中等待 10 秒的延迟。
  • ILogger 注入到服务中。

internal interface IScopedProcessingService
{
    Task DoWork(CancellationToken stoppingToken);
}

internal class ScopedProcessingService : IScopedProcessingService
{
    private int executionCount = 0;
    private readonly ILogger _logger;
    
    public ScopedProcessingService(ILogger<ScopedProcessingService> logger)
    {
        _logger = logger;
    }

    public async Task DoWork(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            executionCount++;

            _logger.LogInformation(
                "Scoped Processing Service is working. Count: {Count}", executionCount);

            await Task.Delay(10000, stoppingToken);
        }
    }
}

托管服务创建一个作用域来解决作用域后台任务服务以调用其 DoWork 方法。 DoWork 返回 ExecuteAsync 等待的 Task：

public class ConsumeScopedServiceHostedService : BackgroundService
{
    private readonly ILogger<ConsumeScopedServiceHostedService> _logger;

    public ConsumeScopedServiceHostedService(IServiceProvider services, 
        ILogger<ConsumeScopedServiceHostedService> logger)
    {
        Services = services;
        _logger = logger;
    }

    public IServiceProvider Services { get; }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service running.");

        await DoWork(stoppingToken);
    }

    private async Task DoWork(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service is working.");

        using (var scope = Services.CreateScope())
        {
            var scopedProcessingService = 
                scope.ServiceProvider
                    .GetRequiredService<IScopedProcessingService>();

            await scopedProcessingService.DoWork(stoppingToken);
        }
    }

    public override async Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service is stopping.");

        await base.StopAsync(stoppingToken);
    }
}

已在 IHostBuilder.ConfigureServices (Program.cs) 中注册这些服务。 已使用 AddHostedService 扩展方法注册托管服务： 

services.AddHostedService<ConsumeScopedServiceHostedService>();
services.AddScoped<IScopedProcessingService, ScopedProcessingService>(); 

排队的后台任务

后台任务队列基于 .NET 4.x QueueBackgroundWorkItem：

public interface IBackgroundTaskQueue
{
    ValueTask QueueBackgroundWorkItemAsync(Func<CancellationToken, ValueTask> workItem);

    ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
        CancellationToken cancellationToken);
}

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly Channel<Func<CancellationToken, ValueTask>> _queue;

    public BackgroundTaskQueue(int capacity)
    {
        // Capacity should be set based on the expected application load and
        // number of concurrent threads accessing the queue.            
        // BoundedChannelFullMode.Wait will cause calls to WriteAsync() to return a task,
        // which completes only when space became available. This leads to backpressure,
        // in case too many publishers/calls start accumulating.
        var options = new BoundedChannelOptions(capacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        };
        _queue = Channel.CreateBounded<Func<CancellationToken, ValueTask>>(options);
    }

    public async ValueTask QueueBackgroundWorkItemAsync(
        Func<CancellationToken, ValueTask> workItem)
    {
        if (workItem == null)
        {
            throw new ArgumentNullException(nameof(workItem));
        }

        await _queue.Writer.WriteAsync(workItem);
    }

    public async ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
        CancellationToken cancellationToken)
    {
        var workItem = await _queue.Reader.ReadAsync(cancellationToken);

        return workItem;
    }
}

在以下 QueueHostedService 示例中：

  • BackgroundProcessing 方法返回 ExecuteAsync 中等待的 Task。
  • 在 BackgroundProcessing 中，取消排队并执行队列中的后台任务。
  • 服务在 StopAsync 中停止之前，将等待工作项。

public class QueuedHostedService : BackgroundService
{
    private readonly ILogger<QueuedHostedService> _logger;

    public QueuedHostedService(IBackgroundTaskQueue taskQueue, 
        ILogger<QueuedHostedService> logger)
    {
        TaskQueue = taskQueue;
        _logger = logger;
    }

    public IBackgroundTaskQueue TaskQueue { get; }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            $"Queued Hosted Service is running.{Environment.NewLine}" +
            $"{Environment.NewLine}Tap W to add a work item to the " +
            $"background queue.{Environment.NewLine}");

        await BackgroundProcessing(stoppingToken);
    }

    private async Task BackgroundProcessing(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = 
                await TaskQueue.DequeueAsync(stoppingToken);

            try
            {
                await workItem(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, 
                    "Error occurred executing {WorkItem}.", nameof(workItem));
            }
        }
    }

    public override async Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Queued Hosted Service is stopping.");

        await base.StopAsync(stoppingToken);
    }
}

每当在输入设备上选择 w 键时，MonitorLoop 服务将处理托管服务的排队任务：

  • IBackgroundTaskQueue 注入到 MonitorLoop 服务中。
  • 调用 IBackgroundTaskQueue.QueueBackgroundWorkItem 来将工作项排入队列。
  • 工作项模拟长时间运行的后台任务：

public class MonitorLoop
{
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly ILogger _logger;
    private readonly CancellationToken _cancellationToken;

    public MonitorLoop(IBackgroundTaskQueue taskQueue,
        ILogger<MonitorLoop> logger,
        IHostApplicationLifetime applicationLifetime)
    {
        _taskQueue = taskQueue;
        _logger = logger;
        _cancellationToken = applicationLifetime.ApplicationStopping;
    }

    public void StartMonitorLoop()
    {
        _logger.LogInformation("MonitorAsync Loop is starting.");

        // Run a console user input loop in a background thread
        Task.Run(async () => await MonitorAsync());
    }

    private async ValueTask MonitorAsync()
    {
        while (!_cancellationToken.IsCancellationRequested)
        {
            var keyStroke = Console.ReadKey();

            if (keyStroke.Key == ConsoleKey.W)
            {
                // Enqueue a background work item
                await _taskQueue.QueueBackgroundWorkItemAsync(BuildWorkItem);
            }
        }
    }

    private async ValueTask BuildWorkItem(CancellationToken token)
    {
        // Simulate three 5-second tasks to complete
        // for each enqueued work item

        int delayLoop = 0;
        var guid = Guid.NewGuid().ToString();

        _logger.LogInformation("Queued Background Task {Guid} is starting.", guid);

        while (!token.IsCancellationRequested && delayLoop < 3)
        {
            try
            {
                await Task.Delay(TimeSpan.FromSeconds(5), token);
            }
            catch (OperationCanceledException)
            {
                // Prevent throwing if the Delay is cancelled
            }

            delayLoop++;

            _logger.LogInformation("Queued Background Task {Guid} is running. " 
                                   + "{DelayLoop}/3", guid, delayLoop);
        }

        if (delayLoop == 3)
        {
            _logger.LogInformation("Queued Background Task {Guid} is complete.", guid);
        }
        else
        {
            _logger.LogInformation("Queued Background Task {Guid} was cancelled.", guid);
        }
    }
}

已在 IHostBuilder.ConfigureServices (Program.cs) 中注册这些服务。 已使用 AddHostedService 扩展方法注册托管服务：

services.AddSingleton<MonitorLoop>();
services.AddHostedService<QueuedHostedService>();
services.AddSingleton<IBackgroundTaskQueue>(ctx =>
{
    if (!int.TryParse(hostContext.Configuration["QueueCapacity"], out var queueCapacity))
        queueCapacity = 100;
    return new BackgroundTaskQueue(queueCapacity);
}); 

已在 Program.cs 中启动 MonitorLoop： 

var monitorLoop = host.Services.GetRequiredService<MonitorLoop>();
monitorLoop.StartMonitorLoop(); 

异步定时后台任务

以下代码将创建异步定时后台任务：

namespace TimedBackgroundTasks;

public class TimedHostedService : BackgroundService
{
    private readonly ILogger<TimedHostedService> _logger;
    private int _executionCount;

    public TimedHostedService(ILogger<TimedHostedService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service running.");

        // When the timer should have no due-time, then do the work once now.
        DoWork();

        using PeriodicTimer timer = new(TimeSpan.FromSeconds(1));

        try
        {
            while (await timer.WaitForNextTickAsync(stoppingToken))
            {
                DoWork();
            }
        }
        catch (OperationCanceledException)
        {
            _logger.LogInformation("Timed Hosted Service is stopping.");
        }
    }

    // Could also be a async method, that can be awaited in ExecuteAsync above
    private void DoWork()
    {
        int count = Interlocked.Increment(ref _executionCount);

        _logger.LogInformation("Timed Hosted Service is working. Count: {Count}", count);
    }
}

其他资源

参考官网：在 ASP.NET Core 中使用托管服务实现后台任务 | Microsoft Learn

csdn_aspnet
关注
专栏目录
.NET Core 如何长时间运行在后台服务？
java专栏
08-16 651
从创建基本的服务，到定时任务，再到状态管理和异步任务的编排，我们一步步深入到了后台服务的核心。后台服务就像是你家里的智能管家，默默地在后台执行任务，而你只需要享受它带来的便利。别急，我们这就来揭秘！最后，让我们来考虑一个场景：后台服务需要执行一个长时间的任务，比如下载一个大文件。这样，我们就能确保后台服务可以高效地处理多个任务，同时还能优雅地处理中断的情况。好的，我们有了一个Web应用，接下来要做的就是添加一个后台服务。有时候，我们可能需要在后台服务执行过程中进行一些控制，比如取消正在执行的任务。
在ASP.NET CORE 运行后台任务：基于IHostedService的托管服务
覃鸿宇的博客
06-15 2300
前言 在进行基于钉钉的H5微应用开发时，会遇到这样的业务场景：需要定时刷接口获取access_token，这是一个调用接口的凭证，本且有效期是两个小时，在过期后我们需要定时去请求获取该token，否则就无法调用接口服务。于是，就有了后台任务的需求。 本文应该算是钉钉H5微应用开发系列的一个补充知识。 如何实现？ 前提条件：使用NUGET添加Microsoft.Extensions.Hosting包到项目中。 主角：IHostedService接口 托管服务必须实现IHostedService接口
在 ASP.NET Core 中使用托管服务实现后台任务
https://github.com/conanl5566
12-24 988
在 ASP.NET Core 中，后台任务作为托管服务实现。托管服务是一个类，具有实现 IHostedService 接口的后台任务逻辑。 ASP.NET Core 辅助角色服务模板可作为编写长期服务应用的起点。通过辅助角色服务模板创建的应用将在其项目文件中指定 Worker SDK： <ProjectSdk="Microsoft.NET.Sdk.Worker"> 要使用该模板作为编写托管服务应用的基础： 创建新项目。 选择“辅助角色服务”。选择“下一步”。 在“项目名称”字段.
ASP.NET Core 中的高效后台任务管理：实施定时托管服务
最新发布
java专栏
09-09 763
接下来，我们将通过一个具体的示例来展示如何在ASP.NET Core中使用托管服务来实现定时任务的管理。跟着我一起，一步步来，你会发现这一切并不难。📋。
ASP.NET Core MVC应用程序中的后台工作任务
qq_39110534的博客
01-11 440
ASP.NET Core MVC应用程序中的后台工作任务 2019-01-11 11:59 by 张子浩, ... 阅读, ... 评论, 收藏, 编辑 　　在应用程序的内存中缓存常见数据（如查找）可以显着提高您的MVC Web应用程序性能和响应时间。当然，这些数据必须定期刷新。 　　当然你可以使用任何方法来更新数据，例如Re...
ASP.NET Core 2.1 : 十一. 如何在后台运行一个任务
weixin_33881753的博客
06-27 180
　　在大部分程序中一般都会需要用到后台任务， 比如定时更新缓存或更新某些状态。（ASP.NET Core 系列目录） 一、应用场景 　　以调用微信公众号的Api为例， 经常会用到access_token，官方文档这样描述：“是公众号的全局唯一接口调用凭据，有效期目前为2个小时，需定时刷新，重复获取将导致上次获取的access_token失效，建议公众号开发者使用中控服务器统一获取和刷新Acce...
aspnet core运行后台任务
anfeng4628的博客
11-03 410
之前在公司的一个项目中需要用到定时程序，当时使用的是aspnet core提供的IHostedService接口来实现后台定时程序，具体的示例可去官网查看。现在的dotnet core中默认封装了实现IHostedService接口的基类BackgroundService，该类实现如下： // Copyright (c) .NET Foundation. All rights ...
托管服务（IHostedService，BackgroundService）
qq_24769781的博客
06-14 339
有些工作是需要后台运行的，比如每天凌晨备份数据库。ASP.NET Core提供了托管服务来供我们编写后台代码。托管服务只需要实现IHostedService即可，一般在开发时编写继承自BackgroundService的类,该类不进实现了IHostedService接口，并且处理了任务取消等逻辑，我们只需实现BackgroundService中定义的ExecuteAsync方法即可。
ASP.NET Core中的后台工作者
04-05
2. **`BackgroundService`基类**：`BackgroundService`是ASP.NET Core提供的一个抽象基类，它实现了`IHostedService`接口，该接口有两个关键方法——`StartAsync`和`StopAsync`，用于控制服务的启动和停止。...
ASP.NET Core 3框架揭秘之 异步线程无法使用IServiceProvider问题
10-15
- 如果需要在后台运行长时间的任务，可以考虑使用IHostedService接口的实现，特别是BackgroundService类。这样，服务生命周期与应用程序的宿主同步，而非HTTP请求。 5. **异步编程的最佳实践**： - 避免在控制器...
hosted-service-netcore：通过.NET Core 3.1使用IHostedService在微服务中实现后台任务
02-18
托管服务网核 Marcos Soares通过.NET Core 3.1使用IHostedService在微服务中实现后台任务，然后在Docker上托管应用程序。 细节 ASP.NET Core 1.x和2.x支持IWebHost用于Web应用程序中的后台进程。 .NET Core 2.1和更高版本支持IHost使用简单的控制台应用程序进行后台进程。 注意WebHost和Host之间的区别。 ASP.NET Core 2.0中的WebHost（实现IWebHost的基类）是用于向流程提供HTTP服务器功能的基础结构构件，例如，当您实现MVC Web应用程序或Web API服务时。 它提供了ASP.NET Core中所有新的基础结构优点，使您能够使用依赖项注入，在请求管道中插入中间件等。 WebHost使用这些非常相同的IHostedServices进行后台任务。 .NET Core 2.
[.NET 6] IHostedService 的呼叫等等我的爱——等待Web应用准备就绪
网尘的技术专栏
09-13 453
如果在应用中同时启用了多个IHostedService，已开始多个背景任务，那么一个有趣的现象是，其他的任务总是比 web应用启动的快，这有时候会导致一些异常。 当然，除了有些无力的控制感以外，并没有啥大不了的，除非真的有其他需求要求我们必须这么做。 而现在我就遇到了一个类似的问题，我想在背景任务中获取应用已经绑定的端口，啊哈哈，什么，应用还没有启动，那我们搞个毛线...
在asp.net core中使用托管服务实现后台任务
weixin_30500289的博客
09-04 278
在业务场景中经常需要后台服务不停的或定时处理一些任务，这些任务是不需要及时响应请求的。 在 asp.net中会使用windows服务来处理。 在 asp.net core中，可以使用托管服务来实现，托管服务是一个类，具有实现IHostService接口的后台任务逻辑。 导入包 使用NUGET添加Microsoft.Extensions.Hosting包到项目中 Microsoft.Ex...
ASP.NET Core 开启后台任务
lindexi
09-02 1234
本文告诉大家如何通过 Microsoft.Extensions.Hosting.BackgroundService 开启后台任务 实现 BackManagerService 类继承 BackgroundService 抽象类，请看代码 public class BackManagerService : BackgroundService { /// &lt...
ASP.NET Core-组件-后台任务：Hangfire
weixin_30416497的博客
10-29 184
ylbtech-ASP.NET Core-组件-后台任务：Hangfire Hangfire作为一款高人气且容易上手的分布式后台执行服务，支持多种数据库。在.net core的环境中，由Core自带的DI管理着生命周期，免去了在NF4.X环境中配置always running的麻烦，真正做到开箱即用。 1.返回顶部 2.返回...
【5min+】后台任务的积木。.NetCore中的IHostedService
终极冥帝
02-29 1984
系列介绍传奇小说 https://m.xs86.com 【五分钟的dotnet】是一个利用您的碎片化时间来学习和丰富.net知识的博文系列。它所包含了.net体系中可能会涉及到的方方面面，比如C#的小细节，AspnetCore，微服务中的.net知识等等。 5min+不是超过5分钟的意思，"+"是知识的增加。so，它是让您花费5分钟以下的时间来提升您的知识储备量。 前言 这次终于可以给大...
.NET Core中使用IHostedService结合队列执行定时任务
weixin_33795093的博客
01-14 1135
最近遇到了这样的场景：每隔一段时间，需要在后台使用队列对一批数据进行业务处理。 Quartz.NET是一种选择，在 .NET Core中，可以使用IHostedService执行后台定时任务。在本篇中，首先尝试把队列还原到最简单、原始的状态，然后给出以上场景问题的具体解决方案。 假设一个队列有8个元素。现在abcd依次进入队列。 0 1 2 3 4 5 6 7 a b c d ...
ASP.NET Core开发-后台任务利器Hangfire使用
zhanglong_longlong的专栏
08-26 1230
SP.NET Core开发系列之后台任务利器Hangfire 使用。 Hangfire 是一款强大的.NET开源后台任务利器，无需Windows服务/任务计划程序。 可以使用于ASP.NET 应用也可以使用于控制台。Hangfire 只需简单几句代码即可创建新的不同种类的任务。 目前 Hangfire 已经支持.NET Core ，现在就给大家讲解下在ASP.NET Core 里的使用。 Hangfire GitHub：https://github.com/HangfireIO/Hangfire
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值