I'm implementing Binance's API.

The documentation says:

WebSocket connections have a limit of 5 incoming messages per second. A message is considered:

• A PING frame
• A PONG frame
• A JSON controlled message (e.g. subscribe, unsubscribe)

For ex. there is a simple web socket wrapper such as the one from the official Binance Connector. According to the limitation above, SendAsync should be restricted 5 messages per second. If a few threads call SendAsync 5 times at the same time (including PING frame which is built-in the ClientWebSocket class), it's going to fail. How can I solve the issue with that limitation gracefully? Using bounded channels is a solution?

public class BinanceWebSocket : IDisposable
{
    private IBinanceWebSocketHandler handler;
    private List<Func<string, Task>> onMessageReceivedFunctions;
    private List<CancellationTokenRegistration> onMessageReceivedCancellationTokenRegistrations;
    private CancellationTokenSource loopCancellationTokenSource;
    private Uri url;
    private int receiveBufferSize;

    public BinanceWebSocket(IBinanceWebSocketHandler handler, string url, int receiveBufferSize = 8192)
    {
        this.handler = handler;
        this.url = new Uri(url);
        this.receiveBufferSize = receiveBufferSize;
        this.onMessageReceivedFunctions = new List<Func<string, Task>>();
        this.onMessageReceivedCancellationTokenRegistrations = new List<CancellationTokenRegistration>();
    }

    public async Task ConnectAsync(CancellationToken cancellationToken)
    {
        if (this.handler.State != WebSocketState.Open)
        {
            this.loopCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
            await this.handler.ConnectAsync(this.url, cancellationToken);
            await Task.Factory.StartNew(() => this.ReceiveLoop(loopCancellationTokenSource.Token, this.receiveBufferSize), loopCancellationTokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
        }
    }

    public async Task DisconnectAsync(CancellationToken cancellationToken)
    {
        if (this.loopCancellationTokenSource != null)
        {
            this.loopCancellationTokenSource.Cancel();
        }
        if (this.handler.State == WebSocketState.Open)
        {
            await this.handler.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, cancellationToken);
            await this.handler.CloseAsync(WebSocketCloseStatus.NormalClosure, null, cancellationToken);
        }
    }

    public void OnMessageReceived(Func<string, Task> onMessageReceived, CancellationToken cancellationToken)
    {
        this.onMessageReceivedFunctions.Add(onMessageReceived);

        if (cancellationToken != CancellationToken.None)
        {
            var reg = cancellationToken.Register(() =>
                this.onMessageReceivedFunctions.Remove(onMessageReceived));

            this.onMessageReceivedCancellationTokenRegistrations.Add(reg);
        }
    }

    public async Task SendAsync(string message, CancellationToken cancellationToken)
    {
        byte[] byteArray = Encoding.ASCII.GetBytes(message);

        await this.handler.SendAsync(new ArraySegment<byte>(byteArray), WebSocketMessageType.Text, true, cancellationToken);
    }

    public void Dispose()
    {
        this.DisconnectAsync(CancellationToken.None).Wait();

        this.handler.Dispose();

        this.onMessageReceivedCancellationTokenRegistrations.ForEach(ct => ct.Dispose());

        this.loopCancellationTokenSource.Dispose();
    }

    private async Task ReceiveLoop(CancellationToken cancellationToken, int receiveBufferSize = 8192)
    {
        WebSocketReceiveResult receiveResult = null;
        try
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                var buffer = new ArraySegment<byte>(new byte[receiveBufferSize]);
                receiveResult = await this.handler.ReceiveAsync(buffer, cancellationToken);

                if (receiveResult.MessageType == WebSocketMessageType.Close)
                {
                    break;
                }
                string content = Encoding.UTF8.GetString(buffer.ToArray());
                this.onMessageReceivedFunctions.ForEach(omrf => omrf(content));
            }
        }
        catch (TaskCanceledException)
        {
            await this.DisconnectAsync(CancellationToken.None);
        }
    }
}

Second way which I'm not 100% sure it solves it

SendAsync is being called in a loop using Channels. SingleReader is set to true, which means there will be only one consumer at a time. It technically should solve the issue, but I'm not 100% sure because the channel might only be limiting the amount in the buffer.

private readonly Channel<string> _messagesTextToSendQueue = Channel.CreateUnbounded<string>(new UnboundedChannelOptions()
{
    SingleReader = true,
    SingleWriter = false
});

public ValueTask SendAsync(string message)
{
    Validations.Validations.ValidateInput(message, nameof(message));

    return _messagesTextToSendQueue.Writer.WriteAsync(message);
}

public void Send(string message)
{
    Validations.Validations.ValidateInput(message, nameof(message));

    _messagesTextToSendQueue.Writer.TryWrite(message);
}

private async Task SendTextFromQueue()
{
    try
    {
        while (await _messagesTextToSendQueue.Reader.WaitToReadAsync())
        {
            while (_messagesTextToSendQueue.Reader.TryRead(out var message))
            {
                try
                {
                    await SendInternalSynchronized(message).ConfigureAwait(false);
                }
                catch (Exception e)
                {
                    Logger.Error(e, L($"Failed to send text message: '{message}'. Error: {e.Message}"));
                }
            }
        }
    }
    catch (TaskCanceledException)
    {
        // task was canceled, ignore
    }
    catch (OperationCanceledException)
    {
        // operation was canceled, ignore
    }
    catch (Exception e)
    {
        if (_cancellationTotal.IsCancellationRequested || _disposing)
        {
            // disposing/canceling, do nothing and exit
            return;
        }

        Logger.Trace(L($"Sending text thread failed, error: {e.Message}. Creating a new sending thread."));
        StartBackgroundThreadForSendingText();
    }
}

CodePudding user response：

I would try to keep it as simple as possible and use Semaphore Slim to achieve this, I have created a class to perform this task.

public class ThrottlingLimiter
{
    private readonly SemaphoreSlim _semaphore;
    private readonly TimeSpan _timeUnit;

    public ThrottlingLimiter(int maxActionsPerTimeUnit, TimeSpan timeUnit)
    {
        if (maxActionsPerTimeUnit < 1)
            throw new ArgumentOutOfRangeException(nameof(maxActionsPerTimeUnit));

        if (timeUnit < TimeSpan.Zero || timeUnit.TotalMilliseconds > int.MaxValue)
            throw new ArgumentOutOfRangeException(nameof(timeUnit));

        _semaphore = new SemaphoreSlim(maxActionsPerTimeUnit, maxActionsPerTimeUnit);
        _timeUnit = timeUnit;
    }

    public async Task WaitAsync(CancellationToken cancellationToken = default)
    {
        await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
        ScheduleSemaphoreRelease();
    }

    private async void ScheduleSemaphoreRelease()
    {
        await Task.Delay(_timeUnit).ConfigureAwait(false);
        _semaphore.Release();
    }
}

Now to Use this class, all you have to do is set your limit and timeSpan

 public async Task SendData(List<string> allMessages)
 {
     // Limiting 5 calls per second
     ThrottlingLimiter throttlingLimiter = new ThrottlingLimiter(5, TimeSpan.FromSeconds(1));

     await Task.WhenAll(allMessages.Select(async message =>
     {
        await throttlingLimiter.WaitAsync();

        try {
            await SendInternalSynchronized(message);
            // I am not sure what this SendInternalSynchronized returns but I would return some thing to keep a track if this call is successful or not
        }
        catch (Exception e)
        {
           Logger.Error(e, L($"Failed to send text message: {message}'. Error: {e.Message}"));
        }
      });
 }

so basically what will happen here is, no matter how big your list is, the ThrottlingLimiter will only send 5 messages per second and wait for the next second to send the next 5 messages.

so, in your case, get all the data from your call to

 await _messagesTextToSendQueue.Reader.WaitToReadAsync();

store that into a list or any collection and pass that to the SendData function.