Asynchronous Events in .NET MAUI

In this blog post, we explore the usage of System.Threading.Channels in .NET MAUI to efficiently manage event-driven data asynchronously. This method boosts application performance and ensures the UI remains responsive.

What Is System.Threading.Channels?

Asynchronous programming is a critical component of modern software development, especially in environments where responsive UIs are essential. In the .NET MAUI SDK for Aptabase, utilizing System.Threading.Channels provides a simple method for handling events without blocking the main thread.

System.Threading.Channels is a .NET library for scenarios where data can be produced and consumed asynchronously and it’s particularly suited for applications that require high-performance event handling such as analytics and telemetry.

Key Features:

• ✅ Asynchronous data flow: Allows for non-blocking data transmission between different parts of an application.
• ✅ Low memory footprint: Provides a more efficient memory usage pattern especially in high-throughput scenarios.
• ✅ Backpressure management: Can limit the size of the queue to prevent overconsumption of resources with bounded channels.
• ✅ Simpler code: Leads to more readable and maintainable code compared to other concurrent collections.

Implementing Channels in .NET MAUI

Here’s an implementation example of System.Threading.Channels for asynchronous event processing in the Aptabase .NET MAUI SDK.

1. Defining the Event Model

public class EventData
{
    public string Timestamp { get; set; }
    public string EventName { get; set; }
    public Dictionary<string, object>? Props { get; set; }
    public SystemInfo? SystemProps { get; set; }
    public string? SessionId { get; set; }

    public EventData(string eventName, Dictionary<string, object>? props = null)
    {
        Timestamp = DateTime.UtcNow.ToString("o");
        EventName = eventName;
        Props = props;
    }
}

2. Setting Up the Channel

Initialize a channel to handle these events:

Channel<EventData> _channel = Channel.CreateUnbounded<EventData>();

3. Writing to the Channel

Define the method used by the consumer of the SDK for tracking events:

public void TrackEvent(string eventName, Dictionary<string, object>? props = null)
{
    if (!_channel.Writer.TryWrite(new EventData(eventName, props)))
    {
        _logger?.LogError("Failed to perform TrackEvent");
    }
}

4. Reading from the Channel

Read the events and make an http call to the Aptabase server:

private async ValueTask ProcessEventsAsync()
{
    while (await _channel.Reader.WaitToReadAsync())
    {
        while (_channel.Reader.TryRead(out EventData? eventData))
        {
            await SendEventAsync(eventData);
        }
    }
}

5. Integrating Producers and Consumers

When the client is instantiated, start the processing task such that consumers of the SDK can begin sending events:

_processingTask = Task.Run(ProcessEventsAsync);

6. Disposing: Closing the Writer and Awaiting Completion

To safely dispose of resources, complete the channel writer and ensure the associated consumer task finishes gracefully:

public async ValueTask DisposeAsync()
{
    // Signal that no more data will be written to the channel.
    _channel?.Writer.Complete();

    // If the processing task is still running, wait for it to finish.
    if (_processingTask?.IsCompleted == false)
    {
        await _processingTask;
    }
}

Conclusion

At Aptabase, we’re developing an open-source and privacy-centric analytics platform for desktop and mobile apps. Aptabase has SDKs for various frameworks, now including .NET MAUI.

If you have any questions or feedback, feel free to reach out on Twitter or join us on Discord and we’ll be happy to help!