是否有任何选项可以限制每次下载的下载带宽？ [英] Are there any options to limit download bandwidth per download?

问题描述

我正在使用客户端服务器体系结构从集中式服务器下载文件。由于客户端计算机的限制，我在它们上使用Framework 3.5，在服务器上使用4.6。

I am using a Client Server architecture to download files from a centralized server. Due to the Limits of the Client machines I'm using Framework 3.5 on them and 4.6 on the Server.

在服务器上，我正在执行以下操作：

On the Server I'm doing the following:

public IHttpActionResult MyControllerMedhod()
{
    return MySecondMethod();
}

private HttpResponseMessage MySecondMethod()
{
     HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK);

     FileStream stream = new FileStream("c:\temp\tester.dat", FileMode.Open, FileAccess.Read, FileShare.ReadWrite);


     result.Content = new StreamContent(stream);
     result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
     result.Content.Headers.ContentDisposition.FileName = "c:\temp\tester.dat";
     result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
     result.Content.Headers.ContentLength = stream.Length;

return result;
}

在我使用的客户端计算机上：

On the Client machine I'm using:

webClient.DownloadFile("http://127.0.0.1/Download/MyControllerMethod", "c:\temp\test.dat");

效果很好，但是我绝对无法控制使用多少带宽。对于某些客户端，如果使用较少的带宽来下载文件，将是有利的。

It works quite fine BUT I have absolutely no control over how much bandwidth is used. For some of the Clients it would be of Advantage if less bandwidth is being used to download the files.

现在我的问题是：有什么方法可以限制带宽吗？每次下载正在使用？ （从客户端或服务器端）。

Now my question is: Is there any way to Limit the bandwidth that is being used per download? (either from Client side or Server side).

请注意：下载文件可以是800或900 MB的数据文件。

As remark: The Downloads can be data files as big as 800 or 900 MB.

推荐答案

如果您不能调整IIS设置，可以从服务器端实现此目的的一种方法是使用ThrottledStream。这是我早在某个地方发现的类，如果可以找到原始源，我将确保将其链接回去。

One way that this can be achieved from the server side, if you don't have the ability to adjust IIS settings is to use a ThrottledStream. This is a class that I found somewhere way back when, if I can located the original source I'll be sure to link back to it.

节流流： p>

Throttled Stream:

public class ThrottledStream : Stream
{
    /// <summary>
    /// A constant used to specify an infinite number of bytes that can be transferred per second.
    /// </summary>
    public const long Infinite = 0;

    #region Private members
    /// <summary>
    /// The base stream.
    /// </summary>
    private Stream _baseStream;

    /// <summary>
    /// The maximum bytes per second that can be transferred through the base stream.
    /// </summary>
    private long _maximumBytesPerSecond;

    /// <summary>
    /// The number of bytes that has been transferred since the last throttle.
    /// </summary>
    private long _byteCount;

    /// <summary>
    /// The start time in milliseconds of the last throttle.
    /// </summary>
    private long _start;
    #endregion

    #region Properties
    /// <summary>
    /// Gets the current milliseconds.
    /// </summary>
    /// <value>The current milliseconds.</value>
    protected long CurrentMilliseconds
    {
        get
        {
            return Environment.TickCount;
        }
    }

    /// <summary>
    /// Gets or sets the maximum bytes per second that can be transferred through the base stream.
    /// </summary>
    /// <value>The maximum bytes per second.</value>
    public long MaximumBytesPerSecond
    {
        get
        {
            return _maximumBytesPerSecond;
        }
        set
        {
            if (MaximumBytesPerSecond != value)
            {
                _maximumBytesPerSecond = value;
                Reset();
            }
        }
    }

    /// <summary>
    /// Gets a value indicating whether the current stream supports reading.
    /// </summary>
    /// <returns>true if the stream supports reading; otherwise, false.</returns>
    public override bool CanRead
    {
        get
        {
            return _baseStream.CanRead;
        }
    }

    /// <summary>
    /// Gets a value indicating whether the current stream supports seeking.
    /// </summary>
    /// <value></value>
    /// <returns>true if the stream supports seeking; otherwise, false.</returns>
    public override bool CanSeek
    {
        get
        {
            return _baseStream.CanSeek;
        }
    }

    /// <summary>
    /// Gets a value indicating whether the current stream supports writing.
    /// </summary>
    /// <value></value>
    /// <returns>true if the stream supports writing; otherwise, false.</returns>
    public override bool CanWrite
    {
        get
        {
            return _baseStream.CanWrite;
        }
    }

    /// <summary>
    /// Gets the length in bytes of the stream.
    /// </summary>
    /// <value></value>
    /// <returns>A long value representing the length of the stream in bytes.</returns>
    /// <exception cref="T:System.NotSupportedException">The base stream does not support seeking. </exception>
    /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
    public override long Length
    {
        get
        {
            return _baseStream.Length;
        }
    }

    /// <summary>
    /// Gets or sets the position within the current stream.
    /// </summary>
    /// <value></value>
    /// <returns>The current position within the stream.</returns>
    /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
    /// <exception cref="T:System.NotSupportedException">The base stream does not support seeking. </exception>
    /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
    public override long Position
    {
        get
        {
            return _baseStream.Position;
        }
        set
        {
            _baseStream.Position = value;
        }
    }
    #endregion

    #region Ctor
    /// <summary>
    /// Initializes a new instance of the <see cref="T:ThrottledStream"/> class with an
    /// infinite amount of bytes that can be processed.
    /// </summary>
    /// <param name="baseStream">The base stream.</param>
    public ThrottledStream(Stream baseStream)
        : this(baseStream, ThrottledStream.Infinite)
    {
        // Nothing todo.
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="T:ThrottledStream"/> class.
    /// </summary>
    /// <param name="baseStream">The base stream.</param>
    /// <param name="maximumBytesPerSecond">The maximum bytes per second that can be transferred through the base stream.</param>
    /// <exception cref="ArgumentNullException">Thrown when <see cref="baseStream"/> is a null reference.</exception>
    /// <exception cref="ArgumentOutOfRangeException">Thrown when <see cref="maximumBytesPerSecond"/> is a negative value.</exception>
    public ThrottledStream(Stream baseStream, long maximumBytesPerSecond)
    {
        if (baseStream == null)
        {
            throw new ArgumentNullException("baseStream");
        }

        if (maximumBytesPerSecond < 0)
        {
            throw new ArgumentOutOfRangeException("maximumBytesPerSecond",
                maximumBytesPerSecond, "The maximum number of bytes per second can't be negatie.");
        }

        _baseStream = baseStream;
        _maximumBytesPerSecond = maximumBytesPerSecond;
        _start = CurrentMilliseconds;
        _byteCount = 0;
    }
    #endregion

    #region Public methods
    /// <summary>
    /// Clears all buffers for this stream and causes any buffered data to be written to the underlying device.
    /// </summary>
    /// <exception cref="T:System.IO.IOException">An I/O error occurs.</exception>
    public override void Flush()
    {
        _baseStream.Flush();
    }

    /// <summary>
    /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
    /// </summary>
    /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
    /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
    /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
    /// <returns>
    /// The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
    /// </returns>
    /// <exception cref="T:System.ArgumentException">The sum of offset and count is larger than the buffer length. </exception>
    /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
    /// <exception cref="T:System.NotSupportedException">The base stream does not support reading. </exception>
    /// <exception cref="T:System.ArgumentNullException">buffer is null. </exception>
    /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
    /// <exception cref="T:System.ArgumentOutOfRangeException">offset or count is negative. </exception>
    public override int Read(byte[] buffer, int offset, int count)
    {
        Throttle(count);

        return _baseStream.Read(buffer, offset, count);
    }

    /// <summary>
    /// Sets the position within the current stream.
    /// </summary>
    /// <param name="offset">A byte offset relative to the origin parameter.</param>
    /// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"></see> indicating the reference point used to obtain the new position.</param>
    /// <returns>
    /// The new position within the current stream.
    /// </returns>
    /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
    /// <exception cref="T:System.NotSupportedException">The base stream does not support seeking, such as if the stream is constructed from a pipe or console output. </exception>
    /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
    public override long Seek(long offset, SeekOrigin origin)
    {
        return _baseStream.Seek(offset, origin);
    }

    /// <summary>
    /// Sets the length of the current stream.
    /// </summary>
    /// <param name="value">The desired length of the current stream in bytes.</param>
    /// <exception cref="T:System.NotSupportedException">The base stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. </exception>
    /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
    /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
    public override void SetLength(long value)
    {
        _baseStream.SetLength(value);
    }

    /// <summary>
    /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
    /// </summary>
    /// <param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream.</param>
    /// <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
    /// <param name="count">The number of bytes to be written to the current stream.</param>
    /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
    /// <exception cref="T:System.NotSupportedException">The base stream does not support writing. </exception>
    /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
    /// <exception cref="T:System.ArgumentNullException">buffer is null. </exception>
    /// <exception cref="T:System.ArgumentException">The sum of offset and count is greater than the buffer length. </exception>
    /// <exception cref="T:System.ArgumentOutOfRangeException">offset or count is negative. </exception>
    public override void Write(byte[] buffer, int offset, int count)
    {
        Throttle(count);

        _baseStream.Write(buffer, offset, count);
    }

    /// <summary>
    /// Returns a <see cref="T:System.String"></see> that represents the current <see cref="T:System.Object"></see>.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.String"></see> that represents the current <see cref="T:System.Object"></see>.
    /// </returns>
    public override string ToString()
    {
        return _baseStream.ToString();
    }
    #endregion

    #region Protected methods
    /// <summary>
    /// Throttles for the specified buffer size in bytes.
    /// </summary>
    /// <param name="bufferSizeInBytes">The buffer size in bytes.</param>
    protected void Throttle(int bufferSizeInBytes)
    {
        // Make sure the buffer isn't empty.
        if (_maximumBytesPerSecond <= 0 || bufferSizeInBytes <= 0)
        {
            return;
        }

        _byteCount += bufferSizeInBytes;
        long elapsedMilliseconds = CurrentMilliseconds - _start;

        if (elapsedMilliseconds > 0)
        {
            // Calculate the current bps.
            long bps = _byteCount * 1000L / elapsedMilliseconds;

            // If the bps are more then the maximum bps, try to throttle.
            if (bps > _maximumBytesPerSecond)
            {
                // Calculate the time to sleep.
                long wakeElapsed = _byteCount * 1000L / _maximumBytesPerSecond;
                int toSleep = (int)(wakeElapsed - elapsedMilliseconds);

                if (toSleep > 1)
                {
                    try
                    {
                        // The time to sleep is more then a millisecond, so sleep.
                        Thread.Sleep(toSleep);
                    }
                    catch (ThreadAbortException)
                    {
                        // Eatup ThreadAbortException.
                    }

                    // A sleep has been done, reset.
                    Reset();
                }
            }
        }
    }

    /// <summary>
    /// Will reset the bytecount to 0 and reset the start time to the current time.
    /// </summary>
    protected void Reset()
    {
        long difference = CurrentMilliseconds - _start;

        // Only reset counters when a known history is available of more then 1 second.
        if (difference > 1000)
        {
            _byteCount = 0;
            _start = CurrentMilliseconds;
        }
    }
    #endregion
}

这是通过将原始流以及您希望对其进行限制的每秒最大字节数放入构造函数中来使用的。例如：

This is used by placing the original stream into the constructor along with the maximum bytes per second that you would like to throttle it to. For example:

public IHttpActionResult MyControllerMedhod()
{
    return MySecondMethod();
}

private HttpResponseMessage MySecondMethod()
{
    HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK);

    FileStream stream = new FileStream("c:\temp\tester.dat", FileMode.Open, FileAccess.Read, FileShare.ReadWrite);


    result.Content = new ThrottledStream(stream, 153600);
    result.Content.Headers.ContentDisposition = new 
    ContentDispositionHeaderValue("attachment");
    result.Content.Headers.ContentDisposition.FileName = "c:\temp\tester.dat";
    result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
    result.Content.Headers.ContentLength = stream.Length;

    return result;
}

编辑：

原始来源： https://gist.github.com/passy/637319

这篇关于是否有任何选项可以限制每次下载的下载带宽？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！