Our use case requires huge processing of data extraction and writing to a file to be further processed by other processors.

我们的用例需要进行大量的数据提取和写入文件的处理，以供其他处理器进一步处理。

Due to the fact that there is a lot of data involved, it's impossible for the the service that request to wait for a response and then pass the data to be processed by the worker processor.

由于涉及大量数据，请求的服务不可能等待响应，然后将数据传递给工作处理器进行处理。

Trying to achieve "fire and forget" type of mechanism here, but it doesn't seem to be working.

试图在这里实现“火和忘记”类型的机制，但它似乎不起作用。

[HttpPost]
[Route("request/ret")]
public async Task<IActionResult> PostData([FromBody][BindRequired] modelnh request,
        [Required] string code, [FromServices]IServiceScopeFactory serviceScopeFactory, CancellationToken cancellationToken)
{
    var result = new List<rbt>();

    _ = Task.Run(async () =>
            {
                using (var scope = serviceScopeFactory.CreateScope())
                {
                    qrest = (List<rbt>)await _bkgservice.GetData(request,code, cancellationToken).ConfigureAwait(false);;
                    await _filehelper.SaveToFile(qrest ,tgtdirec, append);

                }
            });

    return Ok;
}

BKGService:

BKGService：

public async Task<IEnumerable<rbt>> GetData(rbt request, string code)
{
    string query = "SELECT * ........";
    result = await _dbprov.RunQueryAsync<rbt>(query);
    return result;
}

I have not included the SaveToFile method code, but I think the question is understood here.

我没有包括SaveToFile方法代码，但我认为这里已经理解了这个问题。

The problem is that your code is defining a scope, but it's not actually using it. E.g., _bkgservice is the one injected into the controller, not a new one retrieved from the scope:

问题是您的代码正在定义一个作用域，但实际上并没有使用它。例如，_bkgservice是注入到控制器中的服务，而不是从作用域检索到的新服务：

using (var scope = serviceScopeFactory.CreateScope())
{
  qrest = (List<rbt>)await _bkgservice.GetData(request,code, cancellationToken).ConfigureAwait(false);;
  await _filehelper.SaveToFile(qrest ,tgtdirec, append);
}

Since the code is using fire-and-forget, if _bkgservice and _filehelper are scoped services, they may be disposed before the code in the Task.Run actually uses them. Also, since the code is using fire-and-forget, any exceptions are ignored, so it's not obvious at all what is happening.

由于代码使用的是即发即忘，如果_bkgservice和_filehelper是作用域服务，则它们可能会在Task.Run中的代码实际使用它们之前被释放。此外，由于代码使用的是即发即忘，任何异常都会被忽略，因此发生了什么并不明显。

A quick solution is to enforce the Task.Run code to use services resolved from the scope, e.g., using a static local method:

一个快速的解决方案是强制执行Task.Run代码以使用从作用域解析的服务，例如，使用静态本地方法：

public async Task<IActionResult> PostData([FromBody][BindRequired] modelnh request,
        [Required] string code, [FromServices]IServiceScopeFactory serviceScopeFactory, CancellationToken cancellationToken)
{
  var result = new List<rbt>();

  // Code in a static local method cannot accidentally access members.
  // When adding parameters, ensure that you do not add any values that are dependency-injected.
  static async Task DoWorkAsync()
  {
    using (var scope = serviceScopeFactory.CreateScope())
    {
      var bkgService = scope.ServiceProvider.GetRequiredService<TBkgService>();
      var fileHelper = scope.ServiceProvider.GetRequiredService<FileHelper>();
      qrest = (List<rbt>)await bkgservice.GetData(request,code, cancellationToken).ConfigureAwait(false);;
      await filehelper.SaveToFile(qrest ,tgtdirec, append);
    }
  }

  _ = Task.Run(() => DoWorkAsync());

  return Ok;
}

However, even if you get it compiling (and - for some definition of the term - "working"), you still have the problems of fire-and-forget. Specifically:

然而，即使你把它编译了(并且--对于术语的某种定义--“工作”)，你仍然会有“火就是忘”的问题。具体地说，就是：

1. Fire-and-forget work may occasionally be lost, e.g., when you do rolling upgrades.


2. Fire-and-forget work silently ignores errors.

Fire-and-forget is inherently dangerous, and generally unsuitable for any real-world production application. Instead of using fire-and-forget, I recommend either:

火和忘记本质上是危险的，通常不适合任何现实世界的生产应用程序。我的建议是，不要使用“一发不可收拾”的方式：

1. Not using fire-and-forget. Just let PostData complete naturally after it has completed its work. OR:


2. Develop a proper basic distributed architecture, as I describe on my blog.

you can run a Dapper query and write the results to a file in the background by using asynchronous programming and background tasks. Here's a step-by-step guide on how to achieve this:
Install Required NuGet Packages
Create a Dapper Query
Write Data to a File
Background Task

您可以运行Dapper查询，并使用异步编程和后台任务在后台将结果写入文件。以下是如何实现这一点的逐步指南：安装所需的NuGet包创建Dapper查询将数据写入文件后台任务