天天看點
傳回

一文說通Dotnet Core的背景任務

這是一文說通系列的第二篇，裡面有些内容會用到第一篇中間件的部分概念。如果需要，可以參看第一篇：一文說通Dotnet Core的中間件

 

一、前言

背景任務在一些特殊的應用場合，有相當的需求。

比方，我們需要實作一個定時任務、或周期性的任務、或非API輸出的業務響應、或不允許并發的業務處理，像提現、支付回調等，都需要用到背景任務。

通常，我們在實作背景任務時，有兩種選擇：WebAPI和Console。

下面，我們會用實際的代碼，來理清這兩種工程模式下，背景任務的開發方式。

    為了防止不提供原網址的轉載，特在這裡加上原文連結：https://www.cnblogs.com/tiger-wang/p/13081020.html

二、開發環境&基礎工程

這個Demo的開發環境是：Mac + VS Code + Dotnet Core 3.1.2。

$ dotnet --info
.NET Core SDK (reflecting any global.json):
 Version:   3.1.201
 Commit:    b1768b4ae7

Runtime Environment:
 OS Name:     Mac OS X
 OS Version:  10.15
 OS Platform: Darwin
 RID:         osx.10.15-x64
 Base Path:   /usr/local/share/dotnet/sdk/3.1.201/

Host (useful for support):
  Version: 3.1.3
  Commit:  4a9f85e9f8

.NET Core SDKs installed:
  3.1.201 [/usr/local/share/dotnet/sdk]

.NET Core runtimes installed:
  Microsoft.AspNetCore.App 3.1.3 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 3.1.3 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]

首先，在這個環境下建立工程：

  1. 建立Solution 
% dotnet new sln -o demo
The template "Solution File" was created successfully.
  1. 這次，我們用Webapi建立工程 
% cd demo
% dotnet new webapi -o webapidemo
The template "ASP.NET Core Web API" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on webapidemo/webapidemo.csproj...
  Restore completed in 179.13 ms for demo/demo.csproj.

Restore succeeded.
% dotnet new console -o consoledemo
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on consoledemo/consoledemo.csproj...
  Determining projects to restore...
  Restored consoledemo/consoledemo.csproj (in 143 ms).

Restore succeeded.
  1. 把工程加到Solution中 
% dotnet sln add webapidemo/webapidemo.csproj
% dotnet sln add consoledemo/consoledemo.csproj

基礎工程搭建完成。

三、在WebAPI下實作一個背景任務

WebAPI下背景任務需要作為托管服務來實作，而托管服務，需要實作

IHostedService

接口。

首先，我們需要引入一個庫：

% cd webapidemo
% dotnet add package Microsoft.Extensions.Hosting

引入後，我們就有了

IHostedService

。

下面，我們來做一個

IHostedService

的派生托管類：

namespace webapidemo
{
    public class DemoService : IHostedService
    {
        public DemoService()
        {
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            throw new NotImplementedException();
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            throw new NotImplementedException();
        }
    }
}

IHostedService

需要實作兩個方法：

StartAsync

和

StopAsync

。其中：

StartAsync： 用于啟動背景任務；

StopAsync：主機Host正常關閉時觸發。

如果派生類中有任何非托管資源，那還可以引入

IDisposable

，并通過實作

Dispose

來清理非托管資源。

這個類生成後，我們将這個類注入到

ConfigureServices

中，以使這個類在

Startup.Configure

調用之前被調用：

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddHostedService<DemoService>();
}

下面，我們用一個定時器的背景任務，來加深了解：

namespace webapidemo
{
    public class TimerService : IHostedService, IDisposable
    {
          /* 下面這兩個參數是示範需要，非必須 */
        private readonly ILogger _logger;
        private int executionCount = 0;

          /* 這個是定時器 */
        private Timer _timer;

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

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

        }

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

            _logger.LogInformation($"Service proccessing {count}");
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Service starting");

            _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
            return Task.CompletedTask;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Service stopping");

            _timer?.Change(Timeout.Infinite, 0);
            return Task.CompletedTask;
        }
    }
}

注入到

ConfigureServices

中：

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddHostedService<TimerService>();
}

就OK了。代碼比較簡單，就不解釋了。

四、WebAPI背景任務的依賴注入變形

上一節的示例，是一個簡單的形态。

下面，我們按照标準的依賴注入，實作一下這個定時器。

依賴注入的簡單樣式，請參見一文說通Dotnet Core的中間件。

首先，我們建立一個接口

IWorkService

：

namespace webapidemo
{
    public interface IWorkService
    {
        Task DoWork();
    }
}

再根據

IWorkService

，建立一個實體類：

namespace webapidemo
{
    public class WorkService : IWorkService
    {
        private readonly ILogger _logger;
        private Timer _timer;
        private int executionCount = 0;

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

        public async Task DoWork()
        {
            var count = Interlocked.Increment(ref executionCount);

            _logger.LogInformation($"Service proccessing {count}");
        }
    }
}

這樣就建好了依賴的全部内容。

下面，建立托管類：

namespace webapidemo
{
    public class HostedService : IHostedService, IDisposable
    {
        private readonly ILogger<HostedService> _logger;
        public IServiceProvider Services { get; }
        private Timer _timer;

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

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

        private void DoWork(object state)
        {
            _logger.LogInformation("Service working");

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

                scopedProcessingService.DoWork().GetAwaiter().GetResult();
            }
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Service starting");

            _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
            return Task.CompletedTask;
        }


        public Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Service stopping");

            _timer?.Change(Timeout.Infinite, 0);
            return Task.CompletedTask;
        }
    }
}

把托管類注入到

ConfigureServices

 
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddHostedService<HostedService>();
    services.AddSingleton<IWorkService, WorkService>();
}

這樣就完成了。

這種模式下，可以根據注入的内容切換應用的執行内容。不過，這種模式需要注意

services.AddSingleton

、

services.AddScoped

services.AddTransient

的差別。

五、Console下的背景任務

Console應用本身就是背景運作，是以差別于WebAPI，它不需要托管運作，也不需要

Microsoft.Extensions.Hosting

庫。

我們要做的，就是讓程式運作，就OK。

下面是一個簡單的Console模闆：

namespace consoledemo
{
    class Program
    {
        private static AutoResetEvent _exitEvent;

        static async Task Main(string[] args)
        {
                /* 確定程式隻有一個執行個體在運作 */
            bool isRuned;
            Mutex mutex = new Mutex(true, "OnlyRunOneInstance", out isRuned);
            if (!isRuned)
                return;

            await DoWork();

                        /* 背景等待 */
            _exitEvent = new AutoResetEvent(false);
            _exitEvent.WaitOne();
        }

        private static async Task DoWork()
        {
            throw new NotImplementedException();
        }
    }
}

這個模闆有兩個關鍵的内容：

  1. 單執行個體運作：通常背景任務，隻需要有一個執行個體運作。是以，第一個小段，是解決單執行個體運作的。多次啟動時，除了第一個執行個體外，其它的執行個體會自動退出；
  2. 背景等待：看過很多人寫的，在這兒做背景等待時，用了一個無限的循環。類似于下面的： 
while(true)
{
    Thread.Sleep(1000);
}

這種方式也沒什麼太大的問題。不過，這段代碼總是要消耗CPU的計算量，雖然很少，但做為背景任務，或者說Service，畢竟是一種消耗，而且看着不夠高大上。

當然如果我們需要中斷，我們也可以把這個模闆改成這樣：

namespace consoledemo
{
    class Program
    {
        private static AutoResetEvent _exitEvent;

        static async Task Main(string[] args)
        {
            bool isRuned;
            Mutex mutex = new Mutex(true, "OnlyRunOneInstance", out isRuned);
            if (!isRuned)
                return;

            _exitEvent = new AutoResetEvent(false);
            await DoWork(_exitEvent);
            _exitEvent.WaitOne();
        }

        private static async Task DoWork(AutoResetEvent _exitEvent)
        {
            /* Your Code Here */

            _exitEvent.Set();
        }
    }
}

這樣就可以根據需要，來實作中斷程式并退出。

六、Console應用的其它運作方式

上一節介紹的Console，其實是一個應用程式。

在實際應用中，Console程式跑在Linux伺服器上，我們可能會有一些其它的要求：

  1. 定時運作

Linux上有一個Service，叫cron，是一個用來定時執行程式的服務。

這個服務的設定，需要另一個指令：crontab，位置在

/usr/bin

下。

具體指令格式這兒不做解釋，網上随便查。

  1. 運作到背景

指令後邊加個

&

字元即可：

$ ./command &
  1. 運作為Service

需要持續運作的應用，如果以Console的形态存在，則設定為Service是最好的方式。

Linux下，設定一個應用為Service很簡單，就這麼簡單三步：

第一步：在

/etc/systemd/system

下面，建立一個service檔案，例如

command.service

 
[Unit]
# Service的描述，随便寫
Description=Command

[Service]
RestartSec=2s
Type=simple
# 執行應用的預設使用者。應用如果沒有特殊要求，最好别用root運作
User=your_user_name
Group=your_group_name
# 應用的目錄，絕對路徑
WorkingDirectory=your_app_folder
# 應用的啟動路徑
ExecStart=your_app_folder/your_app
Restart=always

[Install]
WantedBy=multi-user.target

差不多就這麼個格式。參數的詳細說明可以去網上查，實際除了設定，就是運作了一個腳本。

第二步：把這個

command.service

加上運作權限：

# chmod +x ./command.service

第三步：注冊為Service：

# systemctl enable command.service

完成。

為了配合應用，還需要記住兩個指令：啟動和關閉Service

# #啟動Service
# systemctl start command.service
# #關閉Service
# systemctl stop command.service

七、寫在後邊的話

今天這個文章，是因為前兩天，一個兄弟跑過來問我關于資料總線的實作方式，而想到的一個點。

很多時候，大家在寫代碼的時候，會有一種固有的思想：寫WebAPI，就想在這個架構中把所有的内容都實作了。這其實不算是一個很好的想法。WebAPI，在業務層面，就應該隻是實作簡單的處理請求，傳回結果的工作，而背景任務跟這個内容截然不同，通常它隻做處理，不做傳回 --- 事實上也不太好傳回，要麼用戶端等待時間太長，要麼用戶端已經斷掉了。換句話說，用WebAPI實作總線，絕不是一個好的方式。

不過，Console運作為Service，倒是一個總線應用的絕好方式。如果需要按序執行，可以配合MQ伺服器，例如RabbitMQ，來實作消息的按序處理。

再說代碼。很多需求，本來可以用很簡單的方式實作。模式這個東西，用來面試，用來講課，都是很好的内容，但實際開發中，如果有更簡單更有效的方式，用起來！Coding的工作是實作，而不是秀技術。當然，能否找到簡單有效的方式，這個可能跟實際的技術面有關系。但這并不是一個不能跨越的坎。

多看，多想，每天成長一點點！

今天的代碼，在：https://github.com/humornif/Demo-Code/tree/master/0012/demo

（全文完）

一文說通Dotnet Core的背景任務

微信公衆号：老王Plus

掃描二維碼，關注個人公衆号，可以第一時間得到最新的個人文章和内容推送

本文版權歸作者所有，轉載請保留此聲明和原文連結
dotnet core
上一篇: python之基礎文法
下一篇: Python筆記_1基礎之文法格式總結

繼續閱讀