Call one Web API through another Web API in .NetCore . I have Created two Web Api projects Catalog and Order i want to call catalog api through order

//Order.api --OrderController

using System.Net;
using Microsoft.AspNetCore.Mvc;
using OrderApi.Entities;
using OrderApi.Repositories;
namespace OrderApi.Controllers;
[ApiController]
[Route("api/[controller]")]
public class OrderController : ControllerBase
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderController> _logger;
public OrderController(IOrderRepository repository , ILogger<OrderController> logger )
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<Order>) , (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Order>>> GetOrders()
{
var orders = await _repository.GetOrders();
return Ok(orders);
}
[HttpGet("{id}", Name = "GetOrder")]
[ProducesResponseType((int)HttpStatusCode.NotFound)]
[ProducesResponseType(typeof(IEnumerable<Order>), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Order>>> GetOrderById(string id)
{
var order = await _repository.GetOrder(id);
if (order == null)
{
_logger.LogError($"Product with id :{id} , not found.");
return NotFound();
}
return Ok(order);
}
}

//Catalog.api --CatalogController

using System.Net;
using CatalogAPI.Entities;
using CatalogAPI.Repositories;
using Microsoft.AspNetCore.Mvc;
namespace CatalogAPI.Controllers;
[ApiController]
[Route("api/[controller]")]
public class CatalogController : ControllerBase
{
private readonly IProductRepository _repository;
private readonly ILogger<CatalogController> _logger;
public CatalogController(IProductRepository repository, ILogger<CatalogController> logger)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<Product>), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> GetProducts()
{
var products = await _repository.GetProducts();
return Ok(products);
}
/*  */
[HttpGet("{id}", Name = "GetProduct")]
[ProducesResponseType((int)HttpStatusCode.NotFound)]
[ProducesResponseType(typeof(IEnumerable<Product>), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> GetProductById(string id)
{
var product = await _repository.GetProduct(id);
if (product == null)
{
_logger.LogError($"Product with id :{id} , not found.");
return NotFound();
}
return Ok(product);
}
[Route("[action]/{category}", Name = "GetProductByCategory")]
[HttpGet]
[ProducesResponseType((int)HttpStatusCode.NotFound)]
[ProducesResponseType(typeof(IEnumerable<Product>), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> GetProductByCategory(string category)
{
var products = await _repository.GetProductByCategory(category);
return Ok(products);
}
[Route("[action]/{name}", Name = "GetProductByName")]
[HttpGet]
[ProducesResponseType((int)HttpStatusCode.NotFound)]
[ProducesResponseType(typeof(IEnumerable<Product>), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> GetProductByName(string name)
{
var items = await _repository.GetProductByName(name);
if (items == null)
{
_logger.LogError($"Product with name : {name} , not found.");
return NotFound();
}
return Ok(items);
}
[HttpPost]
[ProducesResponseType(typeof(Product), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> CreateProduct([FromBody] Product product)
{
await _repository.CreateProduct(product);
return CreatedAtRoute("GetProduct", new { id = product.Id }, product);
}
[HttpPut]
[ProducesResponseType(typeof(Product), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> UpdateProduct([FromBody] Product product)
{
return Ok(await _repository.UpdateProduct(product));
}
[HttpDelete]
[ProducesResponseType(typeof(Product), (int)HttpStatusCode.OK)]
public async Task<ActionResult<IEnumerable<Product>>> DeleteProductByID(string id)
{
return Ok(await _repository.DeleteProduct(id));
}
}

These are the two Controller classes of the given Web api projects. How should i call the Web api proj of catalog api through Orderapi proj. Can someone explain it in steps or probably provide a code for it and packages I need to add . I have gone through few blogs but i haven't got any particular solution for it.

The easiest way to call the Catalog API from the Order API is to use the HttpClient class. Here's an example of how you can call a GET endpoint in the Catalog API from the Order API:

1. In the OrderController class, create an instance of the HttpClient class and set its BaseAddress property to the Catalog API URL.

   private readonly HttpClient _httpClient;
   public OrderController()
   {
   _httpClient = new HttpClient();
   _httpClient.BaseAddress = new Uri("http://your-catalog-api-url.com/");
   }
   

2. In a controller action method, use the HttpClient instance to call a GET endpoint in the Catalog API.

   private readonly HttpClient _httpClient;
   public OrderController()
   {
   _httpClient = new HttpClient();
   _httpClient.BaseAddress = new Uri("http://your-catalog-api-url.com/");
   }
   [HttpGet("{id}")]
   public async Task<IActionResult> GetOrder(int id)
   {
   var response = await _httpClient.GetAsync($"api/catalog/products/{id}");
   if (response.IsSuccessStatusCode)
   {
   var product = await response.Content.ReadAsAsync<Product>();
   return Ok(product);
   }
   return NotFound();
   }
   

Notes:

1. You should replace *your-catalog-api-url.com and api/catalog/products/{id} with the actual endpoints URLs of the Catalog API that you want to call. You could use the Options pattern for that.

2. It is better to use Dependency Injection to configure the HttpClient (you could also use IHttpClientFactory).

3. You might need to add the access token to the header of request in Order API and configure CORS in Catalog API to allow the communication.

4. This is the easiest solution. There are, however, better ones for such cases to decouple the Order API and Catalog API and improve scalability and reliability. One is to use message queues, such as RabbitMQ, Azure Service Bus etc.