.NET core API third Party API integration

Any proper article any other resources please share

Integrating a third-party API into a .NET Core API involves several steps, from setting up your .NET Core project to making HTTP requests and handling the responses. Here’s a detailed guide:

      1. Set Up Your .NET Core Project

1. Create a new .NET Core Web API project:

   dotnet new webapi -n MyApiIntegration
   cd MyApiIntegration
   

2. Open the project in your preferred IDE (e.g., Visual Studio, Visual Studio Code).

      2. Install Necessary Packages

1. You might need packages like HttpClient, Newtonsoft.Json for JSON handling, and any other package specific to the third-party API.

   dotnet add package Microsoft.Extensions.Http
   dotnet add package Newtonsoft.Json
   

   3. Configure HttpClient

   Register HttpClient in your Startup.cs or Program.cs:

   For .NET 6 and later (Program.cs):

   var builder = WebApplication.CreateBuilder(args);
   
   builder.Services.AddHttpClient();
   
   var app = builder.Build();
   
   // Configure the HTTP request pipeline.
   
   app.UseHttpsRedirection();
   
   app.MapControllers();
   
   app.Run();
   

   For .NET 5 and earlier (Startup.cs):

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddHttpClient();
       services.AddControllers();
   }
   
   public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
   {
       if (env.IsDevelopment())
       {
           app.UseDeveloperExceptionPage();
       }
   
       app.UseHttpsRedirection();
   
       app.UseRouting();
   
       app.UseAuthorization();
   
       app.UseEndpoints(endpoints =>
       {
           endpoints.MapControllers();
       });
   }
   

   4. Create a Service to Handle API Calls

   Create a service that will handle interactions with the third-party API.

   public interface IThirdPartyApiService
   {
       Task GetDataAsync();
   }
   
   public class ThirdPartyApiService : IThirdPartyApiService
   {
       private readonly HttpClient _httpClient;
   
       public ThirdPartyApiService(HttpClient httpClient)
       {
           _httpClient = httpClient;
       }
   
       public async Task GetDataAsync()
       {
           var response = await _httpClient.GetAsync("https://api.example.com/data");
           response.EnsureSuccessStatusCode();
   
           var content = await response.Content.ReadAsStringAsync();
           return content;
       }
   }
   

   Register the service in your Startup.cs or Program.cs:

   For .NET 6 and later (Program.cs):

   builder.Services.AddScoped();
   

   For .NET 5 and earlier (Startup.cs):

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

   5. Create a Controller to Use the Service

   Create a new controller that will use the service to get data from the third-party API.

   [ApiController]
   [Route("api/[controller]")]
   public class ExternalDataController : ControllerBase
   {
       private readonly IThirdPartyApiService _thirdPartyApiService;
   
       public ExternalDataController(IThirdPartyApiService thirdPartyApiService)
       {
           _thirdPartyApiService = thirdPartyApiService;
       }
   
       [HttpGet]
       public async Task GetExternalData()
       {
           var data = await _thirdPartyApiService.GetDataAsync();
           return Ok(data);
       }
   }
   

   6. Handling Configuration

   Store API URLs and other configurations in appsettings.json:

   {
     "ThirdPartyApi": {
       "BaseUrl": "https://api.example.com"
     }
   }
   

   Bind this configuration to a class and inject it into your service:

   public class ThirdPartyApiOptions
   {
       public string BaseUrl { get; set; }
   }
   
   // In Startup.cs or Program.cs
   builder.Services.Configure(builder.Configuration.GetSection("ThirdPartyApi"));
   

   Modify the service to use the configuration:

   public class ThirdPartyApiService : IThirdPartyApiService
   {
       private readonly HttpClient _httpClient;
       private readonly ThirdPartyApiOptions _options;
   
       public ThirdPartyApiService(HttpClient httpClient, IOptions options)
       {
           _httpClient = httpClient;
           _options = options.Value;
       }
   
       public async Task GetDataAsync()
       {
           var response = await _httpClient.GetAsync($"{_options.BaseUrl}/data");
           response.EnsureSuccessStatusCode();
   
           var content = await response.Content.ReadAsStringAsync();
           return content;
       }
   }
   

   7. Testing the Integration

   Run your application and navigate to https://localhost:5001/api/externaldata (or the appropriate URL based on your configuration). This should trigger the call to the third-party API and return the data.
   
   Read the article 
   https://www.c-sharpcorner.com/article/asp-net-core-2-0-implementing-a-third-party-web-api/