Bandwidth Throttle for ASP.Net

Published Feb 13, 2008

Posted in
.NET
ASP.NET
programming
C#

We were working on a project for a company that suddenly started complaining of slow ASP.Net pages. I optimised what I could, but it seemed to me that it ran pretty fast. Then I find out that some of the customers use a slow Internet connection. The only way to test this was to simulate a slow connection.

But how can one do that on IIS 5.1, the Windows XP web server? After a while of searching I realised that it was the wrong question. I don't need this for other projects and if I did I certainly wouldn't want to slow the entire web server to check it out. Because yes, changing the metadata of the server can, supposedly, change the maximum speed the pages are delivered. But it was simply too much hassle and it wasn't a reusable solution.

My way was to create a Filter for the Response of all pages. Response.Filter is supposed to be a Stream that receives as parameter the previous Response.Filter (which at the very start is Response.OutputStream) and does something to the output of the page. So I've created a BandwidthThrottleFilter object and added it in the MasterPage Page_Load:

Response.Filter=new BandwidthThrottleFilter(Response.Fitler,10000);

. It worked.

Now for the code. Follow these steps:

Create a BandwidthThrottleFilter class that inherits from the abstract class Stream
Add a constructor that receives as parameters a Stream and an integer
Add fields that will get instantiated from these two parameters
Implement all abstract methods of the Stream object and use the same methods from the Stream field
Change the Write method to also call a Delay method that receives as parameter the count parameter of the Write method

That's it. You need only create the Delay method which will do a Thread.Sleep for the duration of time it normally should take to transfer that amount of bytes. Of course, that assumes that the normal speed of transfer is negligeable.

Click to see the whole class code


    /// <summary>
    /// Use this filter to simulate slow connections
    /// </summary>
    public class BandwidthThrottleFilter : Stream
    {
        private readonly int _bytesPerSecond;
        private readonly Stream _sink;

        /// <summary>
        /// Gets a slow reading stream
        /// </summary>
        /// <param name="sink">a stream to use as a base (like Response.Filter)</param>
        /// <param name="bytesPerSecond">number of maximum bytes per second</param>
        public BandwidthThrottleFilter(Stream sink, int bytesPerSecond)
        {
            _sink = sink;
            _bytesPerSecond = bytesPerSecond;
        }


        private void Delay(int length)
        {
            int milliseconds = length*1000/_bytesPerSecond;
            if (milliseconds>0) Thread.Sleep(milliseconds);
        }


        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports reading.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports reading; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanRead
        {
            get { return _sink.CanRead; }
        }

        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports seeking.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports seeking; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanSeek
        {
            get { return _sink.CanSeek; }
        }

        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports writing.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports writing; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanWrite
        {
            get { return _sink.CanWrite; }
        }

        ///<summary>
        ///When overridden in a derived class, gets the length in bytes of the stream.
        ///</summary>
        ///
        ///<returns>
        ///A long value representing the length of the stream in bytes.
        ///</returns>
        ///
        ///<exception cref="T:System.NotSupportedException">A class derived from Stream does not support seeking. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Length
        {
            get { return _sink.Length; }
        }

        ///<summary>
        ///When overridden in a derived class, gets or sets the position within the current stream.
        ///</summary>
        ///
        ///<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 stream does not support seeking. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Position
        {
            get { return _sink.Position; }
            set { _sink.Position = value; }
        }


        ///<summary>
        ///When overridden in a derived class, 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><filterpriority>2</filterpriority>
        public override void Flush()
        {
            _sink.Flush();
        }

        ///<summary>
        ///When overridden in a derived class, sets the position within the current stream.
        ///</summary>
        ///
        ///<returns>
        ///The new position within the current stream.
        ///</returns>
        ///
        ///<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>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The 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><filterpriority>1</filterpriority>
        public override long Seek(long offset, SeekOrigin origin)
        {
            return _sink.Seek(offset, origin);
        }

        ///<summary>
        ///When overridden in a derived class, 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 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><filterpriority>2</filterpriority>
        public override void SetLength(long value)
        {
            _sink.SetLength(value);
        }

        ///<summary>
        ///When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
        ///</summary>
        ///
        ///<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>
        ///
        ///<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>
        ///<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>
        ///<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 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><filterpriority>1</filterpriority>
        public override int Read(byte[] buffer, int offset, int count)
        {
            return _sink.Read(buffer, offset, count);
        }

        ///<summary>
        ///When overridden in a derived class, 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="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>
        ///<param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream. </param>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The 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><filterpriority>1</filterpriority>
        public override void Write(byte[] buffer, int offset, int count)
        {
            Delay(count);
            _sink.Write(buffer, offset, count);
        }
    }

Comments

March 22, 2009

Sorry, I was not paying attention when answering your last comment. First of all thank you for pointing out that Thread.Sleep(0) blocked the thread. Then the answer to your question is 1000. 56K means 56000 bits. However, that doesn't mean that you can just divide the size into 125 bytes, since 56kbits refers to the entire communication in a physical device, including data, communication information, stop bits, error correction, etc.

Siderite

March 21, 2009

This comment has been removed by the author.

Siderite

March 21, 2009

The first thing I did to this was make it accept Kilobits instead of Bytes, so developers can use familiar numbers like 56 for a 56K modem. Now my question is, when it comes to bandwidth, is it actually Kilobits (1000 bits), or Kibibits (1024 bits)? Also, if you try to download a small file with a high bandwidth setting, you could get milliseconds=0, which would call Thread.Sleep(0) and suspend the thread! Thanks, - Sharpzy

Anonymous

June 12, 2008

Arghh, VB on my blog! Quick, call a priest! An exorcism must be performed :) Thanks for the code, Evan!

Siderite

June 11, 2008

Here it is in VB.Net The line to put in the MasterPage Response.Filter = New BandwidthThrottleFilter(Response.Filter, 10000) Imports System.IO Imports System.Threading Public Class BandwidthThrottleFilter Inherits Stream Private ReadOnly _bytesPerSecond As Integer Private ReadOnly _sink As Stream Public Sub New(ByVal sink As Stream, ByVal bytesPerSecond As Integer) _sink = sink _bytesPerSecond = bytesPerSecond End Sub Private Sub Delay(ByVal length As Integer) Dim milliseconds As Integer = length * 1000 / _bytesPerSecond Thread.Sleep(milliseconds) End Sub Public Overloads Overrides ReadOnly Property CanRead() As Boolean Get Return _sink.CanRead End Get End Property Public Overloads Overrides ReadOnly Property CanSeek() As Boolean Get Return _sink.CanSeek End Get End Property Public Overloads Overrides ReadOnly Property CanWrite() As Boolean Get Return _sink.CanWrite End Get End Property Public Overloads Overrides ReadOnly Property Length() As Long Get Return _sink.Length End Get End Property Public Overloads Overrides Property Position() As Long Get Return _sink.Position End Get Set(ByVal value As Long) _sink.Position = value End Set End Property Public Overloads Overrides Sub Flush() _sink.Flush() End Sub Public Overloads Overrides Function Seek(ByVal offset As Long, ByVal origin As SeekOrigin) As Long Return _sink.Seek(offset, origin) End Function Public Overloads Overrides Sub SetLength(ByVal value As Long) _sink.SetLength(value) End Sub Public Overloads Overrides Function Read(ByVal buffer As Byte(), ByVal offset As Integer, ByVal count As Integer) As Integer Return _sink.Read(buffer, offset, count) End Function Public Overloads Overrides Sub Write(ByVal buffer As Byte(), ByVal offset As Integer, ByVal count As Integer) Delay(count) _sink.Write(buffer, offset, count) End Sub End Class

Evan

May 1, 2008

Thanks! This was incredibly useful. I'm implementing an AJAX-like file upload and needed to artificially throttle my local bandwidth, to test the progress bar. Your article also pointed me towards a better solution to my original problem: how to actually tell how much of the file has been uploaded. By implementing a filter on the Request object (instead of Response) I was able to both keep track of the upload progress (simply by incrementing my counter as the data passed through), as well as being able to slow the upload down and actually see my progress bar working even on localhost.

serializer

Comments

March 22, 2009

March 21, 2009

March 21, 2009

June 12, 2008

June 11, 2008

May 1, 2008

Post a comment