拦截和委托对自定义对象/库的请求

Question

在之前的 question 的基础上，我在 middleware 的 Configure 方法中拦截传入请求。

public class Startup: IStartup
{
    public Startup(IHostingEnvironment environment)
    {
        // starting apparatus
    }

    public void Configure(IApplicationBuilder app)
    {
        var self = this;
        app.Run(async (context) =>
        {
             await self.Delegate.Service(context);
        });
    }

    public void output(HttpContext context string output) 
    {
          context.Response.WriteAsync(output);
    }

    // other methods

    public IRouter Delegate { get; set; }
}

处理程序

public class Handler: IRouter
{

    public void Service(HttpContext context)
    {
        // shuttles the context to the other parts of the system
        // for processing data
    }

    public void ServiceResult(HttpContext context, object result) 
    {
        // system calls this method, which is then passed back to Startup object.
        Startup.output(context, result);
    }
}

1. 启动应该将上下文交给处理程序来处理请求。

2. Handler 然后分派到系统的另一部分，在该部分中根据 URI 处理请求。处理完成后，其他部分将调用 ServerResult。

3. 基本上，工作流是Startup 将上下文委托给设备，并且设备将上下文与输出结果一起返回。断开连接，输出将发生在另一个函数/闭包/lambda中，但不是同一个中间件。

我被这个中间件阻止了，它迫使我等待并将其定义为异步，关于如何在 asp.net 核心世界中实现上述内容的任何进一步建议。

P.S. 请求拦截可以在任何地方发生，我不必像我的示例那样在中间件中进行。

P.P.S 一个想法可能是 Startup 可以将 lambda 传递给设备，然后一旦请求完成处理，设备就可以调用该设备。

---

我的尝试：

启动

public void Configure(IApplicationBuilder app)
{
    var self = this;
    app.Run(async (context) =>
    {
        await self.Handler.Handle(new Request(context, new Task(() => { })));
    });
}

public void Result(Request request)
{
    request.Context.Response.WriteAsync(request.Result); // write the result
    request.Task.Start(); // end waiting for the middleware async
}

处理程序

public Task Handle(Request request)
{
    // delegates to helper objects to process the request
    return request.Task;
}

public void Result(Request request)
{
    // helper objects called this function after populating results
    startup.Result(request);
}

Answer 1

我并不是说最好这样做，但由于您缺乏经验并完成工作 - 您可以使用TaskCompletionSource：

public class Handler {        
    private TaskCompletionSource<string> _tcs;
    public Task<string> Start(HttpContext context) {
        _tcs = new TaskCompletionSource<string>();
        // shuttles the context to the other parts of the system
        // for processing data
        return _tcs.Task;
    }

    private void Complete(string output) {
        if (_tcs == null)
            throw new Exception("Task has not been started yet");
        // system calls this method, which is then passed back to Startup object.
        _tcs.SetResult(output);
    }
}


public void Configure(IApplicationBuilder app) {
    app.Run(async (context) => {
        var output = await new Handler().Start(context);
        await context.Response.WriteAsync(output);
    });
}