Bandwidth throttling

Question

How do I use this throttling with webClient.DownloadFile method? This is my code

WebClient webClient = new WebClient();
webClient.DownloadFile(new Uri("http://127.0.0.1/basic.xml"), "D:/basic.xml");

https://stackoverflow.com/questions/371032/bandwidth-throttling-in-c-sharp?rq=1 — MatthewMartin, Sep 22 '15 at 17:58
Possible duplicate of [Bandwidth throttling in C#](http://stackoverflow.com/questions/371032/bandwidth-throttling-in-c-sharp) — ElGovanni, Mar 16 '17 at 17:00

score 6 · Accepted Answer · edited May 17 '21 at 13:02

If you want to throttle the stream on client site, you can create your own ThrottledStream (implementing Stream class) as

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MyNamespace
{
    public class ThrottledStream : Stream
    {
        Stream _InputStream = null;
        int _Throttle = 0;
        Stopwatch _watch = Stopwatch.StartNew();
        long _TotalBytesRead = 0;

        public ThrottledStream(Stream @in, int throttleKb)
        {

            _Throttle = throttleKb * 1024;
            _InputStream = @in;
        }

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

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

        public override bool CanWrite
        {
            get { return false; }
        }

        public override void Flush()
        {
        }

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

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

        public override int Read(byte[] buffer, int offset, int count)
        {
            var newcount = GetBytesToReturn(count);
            int read = _InputStream.Read(buffer, offset, newcount);
            Interlocked.Add(ref _TotalBytesRead, read);
            return read;
        }

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

        public override void SetLength(long value)
        {
        }

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

        int GetBytesToReturn(int count)
        {
            return GetBytesToReturnAsync(count).Result;
        }

        async Task<int> GetBytesToReturnAsync(int count)
        {
            if (_Throttle <= 0)
                return count;

            long canSend = (long)(_watch.ElapsedMilliseconds * (_Throttle / 1000.0));

            int diff = (int)(canSend - _TotalBytesRead);

            if (diff <= 0)
            {
                var waitInSec = ((diff * -1.0) / (_Throttle));

                await Task.Delay((int)(waitInSec * 1000)).ConfigureAwait(false);
            }

            if (diff >= count) return count;

            return diff > 0 ? diff : Math.Min(1024 * 8, count);
        }
    }
}

and then use it as

using (HttpClient client = new HttpClient())
{
    var stream = await client.GetStreamAsync("http://stackoverflow.com");
    var throttledStream = new MyNamespace.ThrottledStream(stream, 128); //128Kb/s
    using (var fs = File.Create(@"d:/basic.xml"))
    {
        throttledStream.CopyTo(fs);
    }
}

score 3 · Answer 2 · answered Sep 22 '15 at 18:11

In the given link, just swap destination with source stream.

var originalDestinationStream = new FileStream(@"D:/basic.xml", 
                   FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);

// mySocket represents an instance to http://127.0.0.1/basic.xml
var sourceStream = new NetworkStream(mySocket, false);
var destinationStream = new ThrottledStream(originalDestinationStream, 51200)

byte[] buffer = new byte[1024];
int readCount = sourceStream.Read(buffer, 0, BufferSize);

while (readCount > 0)
{
    destinationStream.Write(buffer, 0, readCount);
    readCount = sourceStream.Read(buffer, 0, BufferSize);
}

Of course, don't forget to reference ThrottledStream class and include it on your project from here.

Bandwidth throttling

2 Answers2