Overførsel hastighed

Efter hver Read beregner du forskellen på Now og sidste Read's Now, og sammenholder
med bytes read og hvis det er for stort så laver du en Sleep som bringer dig ned
på den ønskede hastighed.

t1 = 0;
while( byteRead != 0 && status == STATUS.ONLINE )
{
    byte[] buffer = new Byte[128];
    byteRead = reader.Read( buffer, 0, buffer.Length );
    t2 = DateTime.Now.Ticks;
    if(bytesRead/(t2-t1) > limit)
    {
        Thread.Sleep(bytes/limit + t1 - t2);
    }
    stream.Write( buffer, 0, byteRead );
}

Du må lige selv få styr på 1/1000000 sekunder, 1/1000 sekunder, hvad du måler
limit i etc..

Hov t1 skal naturligvis sættes til t2:

t1 = 0;
while( byteRead != 0 && status == STATUS.ONLINE )
{
    byte[] buffer = new Byte[128];
    byteRead = reader.Read( buffer, 0, buffer.Length );
    t2 = DateTime.Now.Ticks;
    if(bytesRead/(t2-t1) > limit)
    {
        Thread.Sleep(bytes/limit + t1 - t2);
    }
    t1 = t2;
    stream.Write( buffer, 0, byteRead );
}

Hej igen tak for det hurtige svar, har prøvet noget lignende, men synes ikke det giver et præcist resultat. Har forresten sat bufferen op til 4096, da det andet var alt for lidt. Har prøvet to ting:

1)
int limit = 1024 * 10;

Thread.Sleep( (int) ( 1000 * ( (double) byteRead / limit ) ) );

Her giver det præcise resultat op til 150 ca. så begynder det at afvige.

- 150 = 152
- 200 = 195
- 1000 = 809-819


2)
nTime = DateTime.Now.Ticks;
if( wTime != 0 )
{
    double t = 1000 - ( ( nTime - wTime ) / (double) 10000 );
    Thread.Sleep( (int) ( ( t < 0 ? 0 : t ) * ( (double) byteRead / limit ) ) );
}
wTime = nTime;

Samme problem, viser 4-5 for meget ved 0-200, herefter begynder det også at varriere meget.

Den her SlowServer:

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;

public class SlowServer
{
    private const int SIZE = 1000000;
    private const double SPEED = 10000;
    private const string LINE = "123456789012345678";
    private const int CHUNK = 100;
    public static void Main(string[] args)
    {
        TcpListener server = new TcpListener(IPAddress.Any, 80);
        server.Start();
        while(true)
        {
            try
            {
                TcpClient client = server.AcceptTcpClient();
                StreamReader rdr = new StreamReader(client.GetStream());
                StreamWriter wrt = new StreamWriter(client.GetStream());
                string line;
                while((line = rdr.ReadLine()) != "")
                {
                    Console.WriteLine(line);
                }
                wrt.WriteLine("HTTP/1.0 200 OK");
                wrt.WriteLine("Content-Length: " + SIZE);
                wrt.WriteLine("Content-Type: text/plain");
                wrt.WriteLine("Content-Disposition: attachment; filename=\"test.txt\"");
                wrt.WriteLine();
                wrt.Flush();
                int bytes = CHUNK * (LINE.Length + 2);
                for(int i = 0; i < SIZE / bytes; i++)
                {
                    long t1 = DateTime.Now.Ticks;
                    for(int j = 0; j < CHUNK; j++)
                    {
                        wrt.WriteLine(LINE);
                    }
                    long t2 = DateTime.Now.Ticks;
                    double secs = (t2 - t1) / 10000000.0;
                    if(bytes / secs > SPEED)
                    {
                        double wait = bytes / SPEED - secs;
                        Thread.Sleep((int)(1000 * wait));
                    }
                    wrt.Flush();
                }
                rdr.Close();
                wrt.Close();
                client.Close();
            }
            catch(Exception e)
            {
                Console.WriteLine(e);
            }
        }
        server.Stop();
    }
}

starter også lidt højt men stabiliserer sig hurtigt på de korrekte 9.76 KB/s
(10000 / 1024).

OK ?

??

Undskyld, havde glemt spørgsmålet. Har løst problemet. Problemet var at når den skal sove i meget kort tid, vil den ofte sove i længere tid.

Løsningen: Jeg gemte tiden den har sovet for meget, herefter sover den først, når den gemte tid blevet godt gjort.