Always will be ready notify the world about expectations as easy as possible: job change page
May 2

Implementing advanced long polling in .NET 6


Long polling is a server-push technique used in web applications to efficiently update clients with new information. Unlike traditional polling, long polling keeps the request open until the server has new data to send. This method is beneficial when you want to reduce the latency for data updates without overloading the server with frequent requests. In this blog, we’ll explore how to implement advanced long polling in .NET 6.

HTTP Long Polling

Understanding Long Polling

Long polling is an evolution of the HTTP polling technique. A client initiates a request to the server, which keeps the connection open until it can return fresh data. This strategy is particularly useful in scenarios where data updates are sporadic and unpredictable.

Setting up the project

First, ensure you have .NET 6 installed. Create a new ASP.NET Core Web API project, which will serve as the basis for our long polling implementation.

dotnet new webapi -n LongPollingDemo
cd LongPollingDemo

Implementing the server

We’ll create a service that simulates data updates and an API controller to handle long polling requests.

Data service

This service simulates a data source that updates at irregular intervals.

public class DataService
    private readonly ConcurrentQueue<string> _messages = new ConcurrentQueue<string>();

    public void AddMessage(string message)

    public bool TryGetMessage(out string message)
        return _messages.TryDequeue(out message);

API Controller

The controller will handle client requests and use DataService to send responses.

public class LongPollingController : ControllerBase
    private readonly DataService _dataService;
    private readonly ILogger<LongPollingController> _logger;

    public LongPollingController(DataService dataService, ILogger<LongPollingController> logger)
        _dataService = dataService;
        _logger = logger;

    public async Task<IActionResult> Poll(CancellationToken cancellationToken)
            while (!cancellationToken.IsCancellationRequested)
                if (_dataService.TryGetMessage(out string message))
                    return Ok(message);

                await Task.Delay(1000, cancellationToken);

            return new StatusCodeResult(StatusCodes.Status408RequestTimeout);
        catch (OperationCanceledException)
            _logger.LogInformation("Polling request cancelled.");
            return new StatusCodeResult(StatusCodes.Status400BadRequest);

    public IActionResult Send([FromBody] string message)
        return Ok();

Registering the service

In Program.cs, register DataService as a singleton.


Client-Side implementation

Clients can use JavaScript to poll the server for updates.

async function pollServer()
            const response = await fetch('https://localhost:5001/longpolling/poll');
            if (response.ok)
                const message = await response.text();
                console.log('New message:', message);
                console.error('Polling error:', response.status);
        catch (error)
            console.error('Polling failed:', error);


Advanced concepts

Timeout management

Implementing a timeout for long polling requests is crucial. In the example above, CancellationToken is used to manage request timeouts.

Scalability concerns

Long polling can be resource-intensive, especially with a large number of clients. Consider load balancing and proper resource management.


For more efficient real-time communication, explore WebSockets or Server-Sent Events (SSE), which may offer better performance and scalability.


Long polling in .NET 6 is a powerful technique for server-to-client communication, especially when dealing with sporadic data updates. By following the example provided, you can implement a robust long polling solution in your ASP.NET Core applications. Remember to consider scalability and alternative technologies like WebSockets for more demanding scenarios.

2 days ago
Author: Paul Balan
Pagination is in front of us everyday yet we take it for granted kind of like we do with most things. It’s what chunks huge lists of data (blog posts, articles, products) into pages so we can navigate through data.This...
Apr 16, 2022
Author: Mohsen Saniee
Today, developers are paying more attention to mapping libraries than ever before, because modern architecture forces them to map object to object across layers. For example, in the past I prepared a repository for clean architecture in github. So it’s...
Apr 24, 2022
Author: HungryWolf
What is MediatR? Why do we need it? And How to use it?Mediator Pattern - The mediator pattern ensures that objects do not interact directly instead of through a mediator. It reduces coupling between objects which makes it easy to...
Oct 20, 2022
Author: Ricardo Griffith
Schedule and run background jobs using this powerful frameworkDisclaimer: the image mentioned in this article is currently marked as preview. Opinions expressed therein are solely my own and do not express the views or opinions of my employer.Hangfire provides a...
Send message
Your name

© 1999–2024 WebDynamics
1980–... Sergey Drozdov
Area of interests: .NET Framework | .NET Core | C# | ASP.NET | Windows Forms | WPF | HTML5 | CSS3 | jQuery | AJAX | Angular | React | MS SQL Server | Transact-SQL | ADO.NET | Entity Framework | IIS | OOP | OOA | OOD | WCF | WPF | MSMQ | MVC | MVP | MVVM | Design Patterns | Enterprise Architecture | Scrum | Kanban