使用LibCurlNet进行带宽控制

Question

我正在使用LibCurlNet通过网络传输文件。我正在寻找使用LibCurlNet进行带宽限制的东西。有没有人有任何关于它的想法？

我发现我们可以使用“curlopt_max_recv_speed_large”来做到这一点。没有在libcurlnet中找到它。

请注意我在C＃中使用它。

感谢

Answer 1

你可以找到有关带宽限制here修改摘自该网站

using System; 
    using System.IO; 
    using System.Threading; 
    using System.Diagnostics; 

    namespace Born2Code.Net 
    { 
     /// <summary> 
     /// Class for streaming data with throttling support. 
     /// </summary> 
     public class ThrottledStream : Stream 
     { 
      public const long Infinite = 0; 

      #region Private members 
      private Stream _baseStream; 
      private long _maximumBytesPerSecond; 
      private long _byteCount; 
      private long _start; 
      #endregion 

      #region Properties 
      protected long CurrentMilliseconds 
      { 
       get 
       { 
        return Environment.TickCount; 
       } 
      } 
      public long MaximumBytesPerSecond 
      { 
       get 
       { 
        return _maximumBytesPerSecond; 
       } 
       set 
       { 
        if (MaximumBytesPerSecond != value) 
        { 
         _maximumBytesPerSecond = value; 
         Reset(); 
        } 
       } 
      } 
      public override bool CanRead 
      { 
       get 
       { 
        return _baseStream.CanRead; 
       } 
      } 
      public override bool CanSeek 
      { 
       get 
       { 
        return _baseStream.CanSeek; 
       } 
      } 
      public override bool CanWrite 
      { 
       get 
       { 
        return _baseStream.CanWrite; 
       } 
      } 
      public override long Length 
      { 
       get 
       { 
        return _baseStream.Length; 
       } 
      } 
      public override long Position 
      { 
       get 
       { 
        return _baseStream.Position; 
       } 
       set 
       { 
        _baseStream.Position = value; 
       } 
      } 
      #endregion 

      #region Ctor 
      public ThrottledStream(Stream baseStream) 
       : this(baseStream, ThrottledStream.Infinite) 
      { 
       // Nothing todo. 
      } 

      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 
      public override void Flush() 
      { 
       _baseStream.Flush(); 
      } 
      public override int Read(byte[] buffer, int offset, int count) 
      { 
       Throttle(count); 

       return _baseStream.Read(buffer, offset, count); 
      } 
      public override long Seek(long offset, SeekOrigin origin) 
      { 
       return _baseStream.Seek(offset, origin); 
      } 
      public override void SetLength(long value) 
      { 
       _baseStream.SetLength(value); 
      } 
      public override void Write(byte[] buffer, int offset, int count) 
      { 
       Throttle(count); 

       _baseStream.Write(buffer, offset, count); 
      } 
      public override string ToString() 
      { 
       return _baseStream.ToString(); 
      } 
      #endregion 

      #region Protected methods 
      protected void Throttle(int bufferSizeInBytes) 
      { 
       if (_maximumBytesPerSecond <= 0 || bufferSizeInBytes <= 0) 
       { 
        return; 
       } 

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

       if (elapsedMilliseconds > 0) 
       { 
        long bps = _byteCount * 1000L/elapsedMilliseconds; 
        if (bps > _maximumBytesPerSecond) 
        { 
         long wakeElapsed = _byteCount * 1000L/_maximumBytesPerSecond; 
         int toSleep = (int)(wakeElapsed - elapsedMilliseconds); 

         if (toSleep > 1) 
         { 
          try 
          { 
           Thread.Sleep(toSleep); 
          } 
          catch (ThreadAbortException) 
          { 
          } 
          Reset(); 
         } 
        } 
       } 
      } 
      protected void Reset() 
      { 
       long difference = CurrentMilliseconds - _start; 
       if (difference > 1000) 
       { 
        _byteCount = 0; 
        _start = CurrentMilliseconds; 
       } 
      } 
      #endregion 
     } 
    }