Curriculum
Consuming APIs and HTTP Client in ASP.NET Core is an essential skill for modern software development. Most applications not only expose APIs but also consume APIs provided by third-party services, cloud platforms, payment gateways, social media platforms, weather services, mapping systems, AI services, and microservices.
Understanding Consuming APIs and HTTP Client in ASP.NET Core is important because modern applications constantly exchange information with external systems. Whether you are building a Banking Application, E-Commerce Platform, CRM, ERP, Hospital Management System, SaaS Product, or Microservices Architecture, consuming APIs is a common requirement.
API Consumption means:
Calling An External API
↓
Receiving Data
↓
Processing DataApplications act as clients that communicate with other services.
Modern applications require:
Payment Services
Weather Data
Maps
Authentication Providers
AI Services
Cloud ServicesThese functionalities are often provided through APIs.
Food Delivery Application:
Food App
↓
Google Maps API
↓
Location DataThe application consumes external services.
E-Commerce Website:
Store Website
↓
Payment Gateway API
↓
Payment ProcessingExternal APIs provide business functionality.
API Provider:
Creates APIAPI Consumer:
Uses APIApplications may play both roles.
Application
↓
HTTP Client
↓
External API
↓
Response
↓
ApplicationThis is the standard API consumption workflow.
HttpClient is the primary class used to send HTTP requests in .NET.
Purpose:
Send Requests
Receive Responses
Consume APIsMost API integrations use HttpClient.
Benefits:
Built-In Support
Easy Integration
Asynchronous Operations
High PerformanceHttpClient is the recommended approach.
A request contains:
URL
Headers
Method
BodyThese components define the API call.
A response contains:
Status Code
Headers
BodyThe response contains API results.
Example:
HttpClient client =
new HttpClient();The object can now send requests.
Example:
var response =
await client.GetAsync(
"https://api.example.com");The request is sent asynchronously.
Send Request
↓
API Processes Request
↓
Response ReturnedThis retrieves data.
Example:
if(response
.IsSuccessStatusCode)
{
}Purpose:
Verify SuccessAlways check response status.
Example:
var content =
await response
.Content
.ReadAsStringAsync();The response body becomes available.
Most APIs return:
JSON DataExample:
{
"id": 1,
"name": "Rahul"
}JSON is the standard format.
Example:
Student student =
JsonSerializer
.Deserialize<
Student>(
content);JSON becomes a C# object.
Purpose:
Create DataExample:
await client
.PostAsync(
url,
content);The request sends data to the API.
Create Object
↓
Convert To JSON
↓
Send Request
↓
Receive ResponseUsed for resource creation.
Example:
var json =
JsonSerializer
.Serialize(student);Object data becomes JSON.
Example:
var content =
new StringContent(
json);The content becomes part of the request body.
Purpose:
Update Existing DataExample:
await client
.PutAsync(
url,
content);Used for updates.
Purpose:
Remove DataExample:
await client
.DeleteAsync(
url);Used to remove resources.
Examples:
GET
POST
PUT
DELETEThese methods support CRUD operations.
Headers provide additional information.
Example:
client.DefaultRequestHeaders
.Add(
"Authorization",
"Bearer Token");Headers are commonly used for authentication.
Many APIs require:
API Keys
JWT Tokens
OAuth TokensAuthentication protects API resources.
Authorization:
Bearer TOKENThe API validates the token.
IHttpClientFactory is the recommended way to create HttpClient instances.
Benefits:
Better Resource Management
Improved Performance
Dependency Injection SupportIt solves common HttpClient issues.
Program.cs:
builder.Services
.AddHttpClient();Registers HttpClient services.
Example:
private readonly
IHttpClientFactory
factory;Dependency Injection provides the factory.
Example:
var client =
factory.CreateClient();A configured client is returned.
Without Factory:
Socket Exhaustion RiskWith Factory:
Efficient Connection ManagementThis is the recommended enterprise approach.
Example:
builder.Services
.AddHttpClient(
"WeatherApi");Named clients simplify configuration.
Purpose:
Encapsulate API LogicBenefits:
Cleaner Code
Better MaintainabilityWidely used in enterprise systems.
Always handle:
Network Failures
Timeouts
Server ErrorsExternal APIs are not always available.
try
{
}
catch(Exception ex)
{
}Exception handling improves reliability.
Purpose:
Prevent Endless WaitingExample:
client.Timeout =
TimeSpan
.FromSeconds(30);Applications should define reasonable timeouts.
Monitor:
Request URLs
Response Status Codes
ErrorsLogging simplifies troubleshooting.
Weather Application:
Application
↓
Weather API
↓
Forecast DataExternal weather information is consumed.
External APIs:
Payment Gateway
Shipping Service
Tax ServiceThese integrations support business operations.
External APIs:
Credit Score API
Payment API
Fraud Detection APIBanking systems often consume multiple APIs.
Service Communication:
User Service
↓
Order Service
↓
Inventory ServiceMicroservices communicate through APIs.
Connects with external services.
Leverages existing platforms.
Supports distributed systems.
Reduces development effort.
Works well in modern architectures.
These advantages are critical for enterprise applications.
May cause resource issues.
Can hide failures.
Reduces reliability.
Creates maintenance problems.
Can affect performance.
HttpClient is used to send HTTP requests and receive responses.
IHttpClientFactory manages HttpClient creation efficiently.
It improves performance and prevents resource management issues.
JSON.
A request used to retrieve data.
It enables applications to integrate with external systems and services.
API Consumption is the process of calling and using external APIs.
HttpClient is a .NET class used for sending HTTP requests.
IHttpClientFactory is a service that manages HttpClient creation and configuration.
It improves performance, reliability, and resource management.
Most APIs use JSON for data exchange.
It enables integration with external systems, cloud services, third-party platforms, and microservices.