La limitation de bande passante en C#

Je suis en train d'élaborer un programme qui envoie en permanence un flux de données en arrière-plan et je veux permettre à l'utilisateur de fixer une limite de téléchargement limite.

J'ai lu sur le token bucket et seau percé alghorhithms, et apparemment celui-ci semble correspondre à la description car ce n'est pas une question de maximiser la bande passante du réseau, mais plutôt d'être la plus discrète possible.

Je suis cependant un peu des doutes sur comment je pourrais le mettre en œuvre. Une approche naturelle consiste à étendre la classe Stream abstraite pour faire simple, qui consiste à étendre le trafic, mais ne serait-ce pas exiger la participation des autres threads pour envoyer les données tout en recevant simultanément (seau percé)? Tous les conseils sur d'autres implémentations qui font la même serait appréciée.

Aussi, même si je peux modifier la quantité de données que le programme reçoit, quelle est la limitation de bande passante de travail à la C# niveau? L'ordinateur aura toujours recevoir les données et il suffit de le sauvegarder, de manière efficace de l'annulation de la limitation de l'effet ou cela est-il attendre jusqu'à ce que je demande à recevoir de plus?

EDIT: je suis intéressé par la limitation des données entrantes et sortantes, où je n'ai pas de contrôle sur l'extrémité opposée de la rivière.

InformationsquelleAutor Christian P. | 2008-12-16
  1. 2

    Basé sur @0xDEADBEEF la solution que j'ai créé le suivant (testable) solution basée sur Rx planificateurs:

    public class ThrottledStream : Stream
{
private readonly Stream parent;
private readonly int maxBytesPerSecond;
private readonly IScheduler scheduler;
private readonly IStopwatch stopwatch;
private long processed;
public ThrottledStream(Stream parent, int maxBytesPerSecond, IScheduler scheduler)
{
this.maxBytesPerSecond = maxBytesPerSecond;
this.parent = parent;
this.scheduler = scheduler;
stopwatch = scheduler.StartStopwatch();
processed = 0;
}
public ThrottledStream(Stream parent, int maxBytesPerSecond)
: this (parent, maxBytesPerSecond, Scheduler.Immediate)
{
}
protected void Throttle(int bytes)
{
processed += bytes;
var targetTime = TimeSpan.FromSeconds((double)processed / maxBytesPerSecond);
var actualTime = stopwatch.Elapsed;
var sleep = targetTime - actualTime;
if (sleep > TimeSpan.Zero)
{
using (var waitHandle = new AutoResetEvent(initialState: false))
{
scheduler.Sleep(sleep).GetAwaiter().OnCompleted(() => waitHandle.Set());
waitHandle.WaitOne();
}
}
}
public override bool CanRead
{
get { return parent.CanRead; }
}
public override bool CanSeek
{
get { return parent.CanSeek; }
}
public override bool CanWrite
{
get { return parent.CanWrite; }
}
public override void Flush()
{
parent.Flush();
}
public override long Length
{
get { return parent.Length; }
}
public override long Position
{
get
{
return parent.Position;
}
set
{
parent.Position = value;
}
}
public override int Read(byte[] buffer, int offset, int count)
{
var read = parent.Read(buffer, offset, count);
Throttle(read);
return read;
}
public override long Seek(long offset, SeekOrigin origin)
{
return parent.Seek(offset, origin);
}
public override void SetLength(long value)
{
parent.SetLength(value);
}
public override void Write(byte[] buffer, int offset, int count)
{
Throttle(count);
parent.Write(buffer, offset, count);
}
}

    et certains tests que juste prendre quelques millisecondes:

    [TestMethod]
public void ShouldThrottleReading()
{
var content = Enumerable
.Range(0, 1024 * 1024)
.Select(_ => (byte)'a')
.ToArray();
var scheduler = new TestScheduler();
var source = new ThrottledStream(new MemoryStream(content), content.Length / 8, scheduler);
var target = new MemoryStream();
var t = source.CopyToAsync(target);
t.Wait(10).Should().BeFalse();
scheduler.AdvanceTo(TimeSpan.FromSeconds(4).Ticks);
t.Wait(10).Should().BeFalse();
scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks - 1);
t.Wait(10).Should().BeFalse();
scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks);
t.Wait(10).Should().BeTrue();
}
[TestMethod]
public void ShouldThrottleWriting()
{
var content = Enumerable
.Range(0, 1024 * 1024)
.Select(_ => (byte)'a')
.ToArray();
var scheduler = new TestScheduler();
var source = new MemoryStream(content);
var target = new ThrottledStream(new MemoryStream(), content.Length / 8, scheduler);
var t = source.CopyToAsync(target);
t.Wait(10).Should().BeFalse();
scheduler.AdvanceTo(TimeSpan.FromSeconds(4).Ticks);
t.Wait(10).Should().BeFalse();
scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks - 1);
t.Wait(10).Should().BeFalse();
scheduler.AdvanceTo(TimeSpan.FromSeconds(8).Ticks);
t.Wait(10).Should().BeTrue();
}
    • Fonctionne, merci! Ceux qui veulent l'utiliser, le besoin d'inclure les Reactive Extensions par Nuget
    InformationsquelleAutor Johannes Egger
  2. 1

    Je suis venu avec une mise en œuvre différente de la ThrottledStream-Classe par aul. Ma version utilise un WaitHandle et un Timer avec un 1s Intervalle:

    public ThrottledStream(Stream parentStream, int maxBytesPerSecond=int.MaxValue) 
{
MaxBytesPerSecond = maxBytesPerSecond;
parent = parentStream;
processed = 0;
resettimer = new System.Timers.Timer();
resettimer.Interval = 1000;
resettimer.Elapsed += resettimer_Elapsed;
resettimer.Start();         
}
protected void Throttle(int bytes)
{
try
{
processed += bytes;
if (processed >= maxBytesPerSecond)
wh.WaitOne();
}
catch
{
}
}
private void resettimer_Elapsed(object sender, ElapsedEventArgs e)
{
processed = 0;
wh.Set();
}

    Chaque fois que la bande passante-la limite est dépassée, le Thread va dormir jusqu'à la prochaine seconde commence. Pas besoin de calculer la optimale de la durée du sommeil.

    Mise En Œuvre Complète:

    public class ThrottledStream : Stream
{
#region Properties
private int maxBytesPerSecond;
///<summary>
///Number of Bytes that are allowed per second
///</summary>
public int MaxBytesPerSecond
{
get { return maxBytesPerSecond; }
set 
{
if (value < 1)
throw new ArgumentException("MaxBytesPerSecond has to be >0");
maxBytesPerSecond = value; 
}
}
#endregion
#region Private Members
private int processed;
System.Timers.Timer resettimer;
AutoResetEvent wh = new AutoResetEvent(true);
private Stream parent;
#endregion
///<summary>
///Creates a new Stream with Databandwith cap
///</summary>
///<param name="parentStream"></param>
///<param name="maxBytesPerSecond"></param>
public ThrottledStream(Stream parentStream, int maxBytesPerSecond=int.MaxValue) 
{
MaxBytesPerSecond = maxBytesPerSecond;
parent = parentStream;
processed = 0;
resettimer = new System.Timers.Timer();
resettimer.Interval = 1000;
resettimer.Elapsed += resettimer_Elapsed;
resettimer.Start();         
}
protected void Throttle(int bytes)
{
try
{
processed += bytes;
if (processed >= maxBytesPerSecond)
wh.WaitOne();
}
catch
{
}
}
private void resettimer_Elapsed(object sender, ElapsedEventArgs e)
{
processed = 0;
wh.Set();
}
#region Stream-Overrides
public override void Close()
{
resettimer.Stop();
resettimer.Close();
base.Close();
}
protected override void Dispose(bool disposing)
{
resettimer.Dispose();
base.Dispose(disposing);
}
public override bool CanRead
{
get { return parent.CanRead; }
}
public override bool CanSeek
{
get { return parent.CanSeek; }
}
public override bool CanWrite
{
get { return parent.CanWrite; }
}
public override void Flush()
{
parent.Flush();
}
public override long Length
{
get { return parent.Length; }
}
public override long Position
{
get
{
return parent.Position;
}
set
{
parent.Position = value;
}
}
public override int Read(byte[] buffer, int offset, int count)
{
Throttle(count);
return parent.Read(buffer, offset, count);
}
public override long Seek(long offset, SeekOrigin origin)
{
return parent.Seek(offset, origin);
}
public override void SetLength(long value)
{
parent.SetLength(value);
}
public override void Write(byte[] buffer, int offset, int count)
{
Throttle(count);
parent.Write(buffer, offset, count);
}
#endregion
}
    • Il deviendra de plus en plus précises si vous ne définissez pas processed à 0 lorsque la minuterie tiques, mais de soustraire maxBytesPerSecond d'elle.
    InformationsquelleAutor 0xDEADBEEF