Question

如何对webClient.DownloadFile方法使用this限制？这是我的代码

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

Answer 1

如果要在客户端站点上限制流，可以创建自己的 ThrottledStream （实现 Stream 类）

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 / 8) * 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);
        }
    }
}

然后将其用作

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

Answer 2

在给定的链接中，只需将源目标与源流交换。

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

当然，不要忘记引用ThrottledStream类并将其包含在here的项目中。

带宽限制

2 个答案: