C# C语言中的带宽限制#

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

我读过和alghorhithms，后者似乎符合描述，因为这不是最大化网络带宽的问题，而是尽可能不引人注目

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

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

---

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

我提出了arul提到的ThrottledStream类的不同实现。我的版本使用WaitHandle和计时器，间隔为1s：

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();
}

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

全面实施：

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


}

公共类节流流：流
{
#区域属性
私有整数maxBytesPerSecond；
/// 
///每秒允许的字节数
/// 
公共整数MaxBytesPerSecond
{
获取{return maxBytesPerSecond；}
设置
{
如果（值<1）
抛出新ArgumentException（“MaxBytesPerSecond必须大于0”）；
maxBytesPerSecond=值；
}
}
#端区
#区域私人成员
已处理的私有int；
System.Timers.Timer resettimer；
AutoResetEvent wh=新的AutoResetEvent（真）；
私有流父级；
#端区
/// 
///使用Databandwith cap创建新流
/// 
/// 
/// 
公共节流流（流父流，int-maxBytesPerSecond=int.MaxValue）
{
MaxBytesPerSecond=MaxBytesPerSecond；
父=父流；
已处理=0；
resettimer=新的System.Timers.Timer（）；
重置计时器。间隔=1000；
resettimer.Appead+=resettimer\u Appead；
resettimer.Start（）；
}
受保护的无效限制（整数字节）
{
尝试
{
已处理+=字节；
如果（已处理>=maxBytesPerSecond）
wh.WaitOne（）；
}
抓住
{
}
}
私有void resettimer_已过（对象发送器，ElapsedEventArgs e）
{
已处理=0；
wh.Set（）；
}
#区域流覆盖
公共覆盖无效关闭（）
{
resettimer.Stop（）；
resettimer.Close（）；
base.Close（）；
}
受保护的覆盖无效处置（布尔处置）
{
resettimer.Dispose（）；
基地。处置（处置）；
}
公共覆盖布尔可读取
{
获取{return parent.CanRead；}
}
公共覆盖布尔搜索
{
获取{return parent.CanSeek；}
}
公共覆盖布尔可写
{
获取{return parent.CanWrite；}
}
公共覆盖无效刷新（）
{
parent.Flush（）；
}
公共覆盖长长度
{
获取{return parent.Length；}
}
公众优先多头仓位
{
得到
{
返回父位置；
}
设置
{
父位置=值；
}
}
公共重写整型读取（字节[]缓冲区、整型偏移量、整型计数）
{
节流阀（计数）；
返回parent.Read（缓冲区、偏移量、计数）；
}
公共覆盖长寻道（长偏移，参见原始坐标系）
{
返回父搜索（偏移、原点）；
}
公共覆盖无效设置长度（长值）
{
父.SetLength（值）；
}
公共重写无效写入（字节[]缓冲区、整数偏移量、整数计数）
{
节流阀（计数）；
写入（缓冲区、偏移量、计数）；
}
#端区
}

基于@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);
    }
}

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

[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();
}

---

如果在计时器计时时不将

processed

设置为

0

，而是从中减去

maxBytesPerSecond

，则会更精确。在读取中，这会使速度低于限制。例如，您可以从internet下载。缓冲区8Kib，每次读取速度1Kib，限制1Mib/秒。然后每次读取会丢失7Kib，并且以128次读取->每秒16Kib的实际速度读取

wh.WaitOne（）

。需要修复

int read=parent.read（缓冲区、偏移量、计数）；节流阀（读取）；返回读取有效，thanx！想要使用它的人，需要包括Nuget的反应式扩展