将IHttpClientFactory传递到类中

Question

如果我有一个控制器类，并且我想将它传递给处理我的HTTP调用的另一个名称空间，比如在下面的场景中，主任务调用TaskA() --它调用TaskG() --我需要像下面这样通过A将它传递给TaskG吗？或者是否有方法只在名称空间HttpClassFurtherDown中创建它，而不需要传递调用类。

namespace Controllers{
public class Drawings : ControllerBase
{
    private IHttpClientFactory _client {get;set;}
    public Drawings(IHttpClientFactory client)
    {
        _client=client;
    }

    [Route("api/Drawings")]
    [HttpPost]
    public async Task<ActionResult> PostAsync([FromBody] JsonFileContent[] content)
    {
        HttpExample e = new HttpExample(_client);
        e.TaskA();
        TaskB();
        return Accepted($"Drawings/Job/{id}");
    }
}}

namespace HttpClassExample{
public class HttpExample
{
  private IHttpClientFactory _client {get;set;}
    public HttpExample(IHttpClientFactory client)
    {
        _client=client;
    }
    public void TaskA()
    {
        DoSomeProcessing();
        HttpClassExampleFurtherDown e = new HttpClassExampleFurtherDown(client);
        e.TaskG();
    }
}

}
namespace HttpClassExampleFurtherDown{
public class HttpExampleFurtherDown
{
  private IHttpClientFactory _client {get;set;}
    public HttpExampleFurtherDown(IHttpClientFactory client)
    {
        _client=client;
    }
    public void TaskG(client)
    {
        //Finally Using It Here. I want to avoid having to generate it at the controller level and pass it all the way down.
        client.CreateClient();
        client.SendAsync();
    }
}

}

Answer 1

，我想避免在控制器级别生成它，然后一直传递下去。

如果遵循DIP，那么在实际需要的地方注入显式依赖项，而不是与实现关注点紧密耦合。

虽然我认为提供的示例过于简化，但上面的示例应该是这样的

Controllers.Drawings

namespace Controllers{
    using HttpClassExample;
    //...

    public class Drawings : ControllerBase {
        private readonly IHttpExample client;
        public Drawings(IHttpExample client) {
            this.client = client;
        }

        [Route("api/Drawings")]
        [HttpPost]
        public async Task<ActionResult> PostAsync([FromBody] JsonFileContent[] content) {
            await client.TaskA();
            TaskB();
            return Accepted($"Drawings/Job/{id}");
        }
    }
}

HttpClassExample.HttpExample

namespace HttpClassExample{
    using HttpClassExampleFurtherDown;
    //...
    
    public class HttpExample : IHttpExample{
        private readonly IHttpExampleFurtherDown client;
        
        public HttpExample(IHttpExampleFurtherDown client) {
            this.client = client;
        }
        
        public async Task TaskA() {
            DoSomeProcessing();
            await client.TaskG();
        }
        
        //...
    }
}

HttpClassExampleFurtherDown.HttpExampleFurtherDown

namespace HttpClassExampleFurtherDown{
    public class HttpExampleFurtherDown : IHttpExampleFurtherDown {
        private readonly IHttpClientFactory factory;
        
        public HttpExampleFurtherDown(IHttpClientFactory factory) {
            this.factory = factory;
        }
        
        public async Task TaskG() {
            HttpClient client = factory.CreateClient();
            
            //...
            
            var response = await client.SendAsync();
            
            //...
        }
    }
}

这假设容器被用于管理基于其注册抽象的依赖实现的解析和注入。