Asynchronous HTTP Requests – Explained Simply

Imagine a waiter taking your order and waiting in the kitchen until your food is ready. During this time, the waiter cannot serve other guests. This is how a synchronous HTTP request works – it blocks the process.

An asynchronous HTTP request, on the other hand, allows the waiter to serve other guests while your food is being prepared. Once your dish is ready, the waiter brings it to you without others being delayed. Sounds efficient, right?

Why Are Asynchronous Requests So Important?

In daily life, we encounter asynchronous HTTP requests all the time, for example:
• WhatsApp: Messages are loaded while you’re using other functions.
• Instagram: Images and videos are loaded in the background.
• Netflix: The next episode is preloaded while you’re still watching.
• Online Shopping: Products are filtered and sorted in the background.

What Does Idempotence Mean in This Context?

Idempotence is an essential concept in web development, particularly for HTTP requests. It describes the property of an operation that delivers the same result no matter how many times it is performed. This principle plays an important role in the reliability and repeatability of requests – especially with asynchronous HTTP requests, as they might be sent multiple times due to network failures or timeouts.

Examples of idempotent HTTP methods:
• GET: Repeatedly fetching the same resource always returns the same data (unless the resource changes).
• PUT: Overwriting a resource with the same data does not change the final state.
• DELETE: Deleting a resource has no effect if the resource has already been removed.

In contrast, POST is not idempotent because it often creates new resources or changes states, which can lead to inconsistent behavior when executed multiple times.

A Simple Introduction in C#

Here is an example of fetching weather data in C#, which also considers idempotence:

public class WetterService
{
    private readonly HttpClient _httpClient;

    public WetterService()
    {
        _httpClient = new HttpClient();
        _httpClient.BaseAddress = new Uri("https://api.wetter.de/");
    }

    public async Task<WetterDaten> HoleWetterAsync(string stadt)
    {
        try
        {
            var antwort = await _httpClient.GetAsync($"wetter/{stadt}");

            if (!antwort.IsSuccessStatusCode)
            {
                return new WetterDaten { Fehler = "Ups! Da ist etwas schiefgelaufen." };
            }

            var json = await antwort.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<WetterDaten>(json);
        }
        catch (Exception)
        {
            return new WetterDaten { Fehler = "Sorry, wir konnten das Wetter nicht abrufen." };
        }
    }
}

Note: The use of the HTTP-GET method ensures idempotence. Even with multiple requests, the server’s state remains unchanged.

Practical Example: Online Shop

A typical controller processing asynchronous and idempotent requests:

[ApiController]
[Route("api/produkte")]
public class ProduktController : ControllerBase
{
    private readonly IProduktService _produktService;

    public ProduktController(IProduktService produktService)
    {
        _produktService = produktService;
    }

    [HttpGet]
    public async Task<ActionResult<List<Produkt>>> HoleAlleProdukte()
    {
        var produkte = await _produktService.HoleAlleProdukteAsync();
        return Ok(produkte);
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Produkt>> HoleProdukt(int id)
    {
        var produkt = await _produktService.HoleProduktAsync(id);

        if (produkt == null)
        {
            return NotFound("Produkt nicht gefunden");
        }

        return Ok(produkt);
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> LoescheProdukt(int id)
    {
        var erfolgreich = await _produktService.LoescheProduktAsync(id);

        if (!erfolgreich)
        {
            return NotFound("Produkt nicht gefunden oder bereits gelöscht.");
        }

        return NoContent();
    }
}

Idempotence in detail: Both GET and DELETE are idempotent here. Even with multiple executions, the results remain consistent, enhancing the system’s stability.

Benefits of Asynchronous and Idempotent HTTP Requests
1. Better User Experience: The app remains responsive and does not freeze.
2. More Efficient Resource Utilization: The server can handle other tasks during wait times.
3. Increased Reliability: Repeated requests do not lead to inconsistent behavior thanks to idempotence.
4. Scalability: Asynchronous processing reduces bottlenecks, especially with parallel requests.

Advanced Use Case: Parallel Loading

Sometimes it is necessary to load multiple resources simultaneously:

public class DashboardService
{
    private readonly IBenutzerService _benutzerService;
    private readonly IBestellungService _bestellungService;

    public async Task<DashboardDaten> HoleDashboardDatenAsync()
    {
        var benutzerTask = _benutzerService.HoleStatistikenAsync();
        var bestellungenTask = _bestellungService.HoleStatistikenAsync();

        await Task.WhenAll(benutzerTask, bestellungenTask);

        return new DashboardDaten
        {
            BenutzerStats = await benutzerTask,
            BestellungStats = await bestellungenTask
        };
    }
}

Common Pitfalls and Solutions
1. Forgotten await: Without await, the code remains blocking and loses its asynchronous behavior.
2. Neglecting Error Handling: Network issues are common, so plan for appropriate error handling.
3. Not Setting Timeouts: Avoid endless wait times by implementing timeout rules.
4. Ignoring Idempotence: Non-idempotent requests can lead to hard-to-trace errors.
5. Lack of Tests: Asynchronous code is prone to subtle bugs and should be thoroughly tested.

Conclusion

Asynchronous HTTP requests are the foundation of modern, responsive applications. By adhering to idempotence principles, repeated requests do not produce unexpected results. Together, they not only enhance the user experience but also create robust and scalable systems. However, their proper implementation requires careful planning and execution.