C#中的带宽限制

Bandwidth throttling in C#

提问by Christian P.

I am developing a program that continually sends a stream of data in the background and I want to allow the user to set a cap for both upload and download limit.

我正在开发一个在后台持续发送数据流的程序，我希望允许用户为上传和下载限制设置上限。

I have read up on the token bucketand leaky bucketalghorhithms, and seemingly the latter seems to fit the description since this is not a matter of maximizing the network bandwidth but rather being as unobtrusive as possible.

我已经阅读了令牌桶和漏桶算法，似乎后者似乎符合描述，因为这不是最大化网络带宽的问题，而是尽可能不引人注目。

I am however a bit unsure on how I would implement this. A natural approach is to extend the abstract Stream class to make it simple to extend existing traffic, but would this not require the involvement of extra threads to send the data while simultaneously receiving (leaky bucket)? Any hints on other implementations that do the same would be appreciated.

然而，我有点不确定我将如何实现这一点。一种自然的方法是扩展抽象 Stream 类，以便扩展现有流量变得简单，但这是否不需要额外线程的参与来发送数据，同时接收（漏桶）？任何有关执行相同操作的其他实现的提示将不胜感激。

Also, although I can modify how much data the program receives, how well does bandwidth throttling work at the C# level? Will the computer still receive the data and simply save it, effectively canceling the throttling effect or will it wait until I ask to receive more?

此外，虽然我可以修改程序接收的数据量，但带宽限制在 C# 级别的工作情况如何？计算机是否仍会接收数据并简单地保存它，从而有效地取消节流效果，还是会等到我要求接收更多数据？

EDIT: I am interested in throttling both incoming and outgoing data, where I have no control over the opposite end of the stream.

编辑：我对限制传入和传出数据感兴趣，我无法控制流的另一端。

回答by 0xDEADBEEF

I came up with a different implementation of the ThrottledStream-Class mentioned by arul. My version uses a WaitHandle and a Timer with a 1s Interval:

我想出了 arul 提到的 ThrottledStream-Class 的不同实现。我的版本使用 WaitHandle 和间隔为 1 秒的计时器：

public ThrottledStream(Stream parentStream, int maxBytesPerSecond=int.MaxValue) 
{
    MaxBytesPerSecond = maxBytesPerSecond;
    parent = parentStream;
    processed = 0;
    resettimer = new System.Timers.Timer();
    resettimer.Interval = 1000;
    resettimer.Elapsed += resettimer_Elapsed;
    resettimer.Start();         
}

protected void Throttle(int bytes)
{
    try
    {
        processed += bytes;
        if (processed >= maxBytesPerSecond)
            wh.WaitOne();
    }
    catch
    {
    }
}

private void resettimer_Elapsed(object sender, ElapsedEventArgs e)
{
    processed = 0;
    wh.Set();
}

Whenever the bandwidth-limit exceeds the Thread will sleep until the next second begins. No need to calculate the optimal sleep duration.

每当带宽限制超过线程将休眠直到下一秒开始。无需计算最佳睡眠时间。

Full Implementation:

全面实施：

public class ThrottledStream : Stream
{
    #region Properties

    private int maxBytesPerSecond;
    /// <summary>
    /// Number of Bytes that are allowed per second
    /// </summary>
    public int MaxBytesPerSecond
    {
        get { return maxBytesPerSecond; }
        set 
        {
            if (value < 1)
                throw new ArgumentException("MaxBytesPerSecond has to be >0");

            maxBytesPerSecond = value; 
        }
    }

    #endregion


    #region Private Members

    private int processed;
    System.Timers.Timer resettimer;
    AutoResetEvent wh = new AutoResetEvent(true);
    private Stream parent;

    #endregion

    /// <summary>
    /// Creates a new Stream with Databandwith cap
    /// </summary>
    /// <param name="parentStream"></param>
    /// <param name="maxBytesPerSecond"></param>
    public ThrottledStream(Stream parentStream, int maxBytesPerSecond=int.MaxValue) 
    {
        MaxBytesPerSecond = maxBytesPerSecond;
        parent = parentStream;
        processed = 0;
        resettimer = new System.Timers.Timer();
        resettimer.Interval = 1000;
        resettimer.Elapsed += resettimer_Elapsed;
        resettimer.Start();         
    }

    protected void Throttle(int bytes)
    {
        try
        {
            processed += bytes;
            if (processed >= maxBytesPerSecond)
                wh.WaitOne();
        }
        catch
        {
        }
    }

    private void resettimer_Elapsed(object sender, ElapsedEventArgs e)
    {
        processed = 0;
        wh.Set();
    }

    #region Stream-Overrides

    public override void Close()
    {
        resettimer.Stop();
        resettimer.Close();
        base.Close();
    }
    protected override void Dispose(bool disposing)
    {
        resettimer.Dispose();
        base.Dispose(disposing);
    }

    public override bool CanRead
    {
        get { return parent.CanRead; }
    }

    public override bool CanSeek
    {
        get { return parent.CanSeek; }
    }

    public override bool CanWrite
    {
        get { return parent.CanWrite; }
    }

    public override void Flush()
    {
        parent.Flush();
    }

    public override long Length
    {
        get { return parent.Length; }
    }

    public override long Position
    {
        get
        {
            return parent.Position;
        }
        set
        {
            parent.Position = value;
        }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        Throttle(count);
        return parent.Read(buffer, offset, count);
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        return parent.Seek(offset, origin);
    }

    public override void SetLength(long value)
    {
        parent.SetLength(value);
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        Throttle(count);
        parent.Write(buffer, offset, count);
    }

    #endregion


}

回答by Johannes Egger

Based on @0xDEADBEEF's solution I created the following (testable) solution based on Rx schedulers:

基于@0xDEADBEEF 的解决方案，我基于 Rx 调度程序创建了以下（可测试的）解决方案：

public class ThrottledStream : Stream
{
    private readonly Stream parent;
    private readonly int maxBytesPerSecond;
    private readonly IScheduler scheduler;
    private readonly IStopwatch stopwatch;

    private long processed;

    public ThrottledStream(Stream parent, int maxBytesPerSecond, IScheduler scheduler)
    {
        this.maxBytesPerSecond = maxBytesPerSecond;
        this.parent = parent;
        this.scheduler = scheduler;
        stopwatch = scheduler.StartStopwatch();
        processed = 0;
    }

    public ThrottledStream(Stream parent, int maxBytesPerSecond)
        : this (parent, maxBytesPerSecond, Scheduler.Immediate)
    {
    }

    protected void Throttle(int bytes)
    {
        processed += bytes;
        var targetTime = TimeSpan.FromSeconds((double)processed / maxBytesPerSecond);
        var actualTime = stopwatch.Elapsed;
        var sleep = targetTime - actualTime;
        if (sleep > TimeSpan.Zero)
        {
            using (var waitHandle = new AutoResetEvent(initialState: false))
            {
                scheduler.Sleep(sleep).GetAwaiter().OnCompleted(() => waitHandle.Set());
                waitHandle.WaitOne();
            }
        }
    }

    public override bool CanRead
    {
        get { return parent.CanRead; }
    }

    public override bool CanSeek
    {
        get { return parent.CanSeek; }
    }

    public override bool CanWrite
    {
        get { return parent.CanWrite; }
    }

    public override void Flush()
    {
        parent.Flush();
    }

    public override long Length
    {
        get { return parent.Length; }
    }

    public override long Position
    {
        get
        {
            return parent.Position;
        }
        set
        {
            parent.Position = value;
        }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        var read = parent.Read(buffer, offset, count);
        Throttle(read);
        return read;
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        return parent.Seek(offset, origin);
    }

    public override void SetLength(long value)
    {
        parent.SetLength(value);
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        Throttle(count);
        parent.Write(buffer, offset, count);
    }
}

and some tests that just take some milliseconds:

和一些只需要几毫秒的测试：

[TestMethod]
public void ShouldThrottleReading()
{
    var content = Enumerable
        .Range(0, 1024 * 1024)
        .Select(_ => (byte)'a')
        .ToArray();
    var scheduler = new TestScheduler();
    var source = new ThrottledStream(new MemoryStream(content), content.Length / 8, scheduler);
    var target = new MemoryStream();

    var t = source.CopyToAsync(target);

    t.Wait(10).Should().BeFalse();
    scheduler.AdvanceTo(TimeSpan.FromSeconds(4).Ticks);
    t.Wait(10).Should().BeFalse();
    scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks - 1);
    t.Wait(10).Should().BeFalse();
    scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks);
    t.Wait(10).Should().BeTrue();
}

[TestMethod]
public void ShouldThrottleWriting()
{
    var content = Enumerable
        .Range(0, 1024 * 1024)
        .Select(_ => (byte)'a')
        .ToArray();
    var scheduler = new TestScheduler();
    var source = new MemoryStream(content);
    var target = new ThrottledStream(new MemoryStream(), content.Length / 8, scheduler);

    var t = source.CopyToAsync(target);

    t.Wait(10).Should().BeFalse();
    scheduler.AdvanceTo(TimeSpan.FromSeconds(4).Ticks);
    t.Wait(10).Should().BeFalse();
    scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks - 1);
    t.Wait(10).Should().BeFalse();
    scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks);
    t.Wait(10).Should().BeTrue();
}