Télécharger le fichier progressivement en utilisant TIdHttp

Je veux implémenter un simple http downloader aide TIdHttp (Indy10). J'ai trouvé deux exemples de code à partir de l'internet. Malheureusement aucun d'eux ne me satisfait à 100%. Voici le code et je veux quelques conseils.

Variante 1

var
  Buffer: TFileStream;
  HttpClient: TIdHttp;
begin
  Buffer := TFileStream.Create('somefile.exe', fmCreate or fmShareDenyWrite);
  try
    HttpClient := TIdHttp.Create(nil);
    try
      HttpClient.Get('http://somewhere.com/somefile.exe', Buffer); // wait until it is done
    finally
      HttpClient.Free;
    end;
  finally
    Buffer.Free;
  end;
end;

Le code est compact et très facile à comprendre. Le problème est qu'il alloue de l'espace disque lorsque le téléchargement commence. Un autre problème est que nous ne pouvons pas afficher la progression du téléchargement dans l'interface utilisateur directement, sauf si le code est exécuté dans un thread d'arrière-plan (sinon, nous pouvons lier HttpClient.OnWork événement).

Variante 2:

const
  RECV_BUFFER_SIZE = 32768;
var
  HttpClient: TIdHttp;
  FileSize: Int64;
  Buffer: TMemoryStream;
begin
  HttpClient := TIdHttp.Create(nil);
  try
    HttpClient.Head('http://somewhere.com/somefile.exe');
    FileSize := HttpClient.Response.ContentLength;

    Buffer := TMemoryStream.Create;
    try
      while Buffer.Size < FileSize do
      begin
        HttpClient.Request.ContentRangeStart := Buffer.Size;
        if Buffer.Size + RECV_BUFFER_SIZE < FileSize then
          HttpClient.Request.ContentRangeEnd := Buffer.Size + RECV_BUFFER_SIZE - 1
        else
          HttpClient.Request.ContentRangeEnd := FileSize;

        HttpClient.Get(HttpClient.URL.URI, Buffer); // wait until it is done
        Buffer.SaveToFile('somefile.exe');
      end;
    finally
      Buffer.Free;
    end;
  finally
    HttpClient.Free;
  end;
end;

Nous avons d'abord interroger la taille de fichier du serveur, puis nous télécharger le contenu du fichier en morceaux. (Extrait le contenu du fichier sera enregistré sur le disque lorsqu'ils sont reçus correctement. Le problème potentiel est que nous avons à envoyer plusieurs demandes pour le serveur. Je ne sais pas si certains serveurs (megaupload) peut limiter le nombre de demandes dans un délai de période de temps donnée.

Mes attentes

L'utilisateur doit envoyer un seul GET-demande au serveur.
L'espace disque ne doit pas être attribuée lorsque le téléchargement commence.

Tous les conseils sont appréciés.

Si vous voulez une mise en cache TFileStream, regardez David contribution ici: Tampon fichiers (pour les accès disque plus rapide).

InformationsquelleAutor stanleyxu2005 | 2012-11-30

Variante #1 est la plus simple, et est comment Indy est destiné à être utilisé.

Concernant l'allocation de l'espace disque, vous pouvez dériver une nouvelle classe de TFileStream et de remplacer son SetSize() méthode pour ne rien faire. TIdHTTP va encore tenter de pré-allouer le fichier lorsque cela est approprié, mais il ne sera pas réellement allouer de l'espace disque. Écrit à TFileStream augmentera le fichier en tant que de besoin.

Concernant les rapports d'état, TIdHTTP a OnWork... événements à cette fin. Le AWorkCountMax paramètre de la OnWorkBegin sera la taille réelle du fichier si elle est connue (la réponse n'est pas mémorisé en bloc), ou 0 si pas connue. Le AWorkCount paramètre de la OnWork événement sera le nombre total d'octets qui ont été transférés jusqu'à présent. Si la taille du fichier est connu, vous pouvez afficher le pourcentage total en divisant simplement le AWorkCount par le AWorkCountMax et en multipliant le résultat par 100, sinon il suffit d'afficher le AWorkCount valeur par lui-même. Si vous souhaitez afficher la vitesse de transfert, vous pouvez calculer que de la différence de AWorkCount valeurs et les intervalles de temps entre plusieurs OnWork événements.

Essayez ceci:

type
  TNoPresizeFileStream = class(TFileStream)
  procedure
    procedure SetSize(const NewSize: Int64); override;
  end;

procedure TNoPresizeFileStream.SetSize(const NewSize: Int64);
begin
end;

type
TSomeClass = class(TSomething)
...
TotalBytes: In64;
LastWorkCount: Int64;
LastTicks: LongWord;
procedure Download;
procedure HttpWorkBegin(ASender: TObject; AWorkMode: TWorkMode; AWorkCountMax: Int64);
procedure HttpWork(ASender: TObject; AWorkMode: TWorkMode; AWorkCount: Int64);
procedure HttpWorkEnd(ASender: TObject; AWorkMode: TWorkMode);
...
end;
procedure TSomeClass.Download;
var
Buffer: TNoPresizeFileStream;
HttpClient: TIdHttp;
begin
Buffer := TNoPresizeFileStream.Create('somefile.exe', fmCreate or fmShareDenyWrite);
try
HttpClient := TIdHttp.Create(nil);
try
HttpClient.OnWorkBegin := HttpWorkBegin;
HttpClient.OnWork := HttpWork;
HttpClient.OnWorkEnd := HttpWorkEnd;
HttpClient.Get('http://somewhere.com/somefile.exe', Buffer); // wait until it is done
finally
HttpClient.Free;
end;
finally
Buffer.Free;
end;
end;
procedure TSomeClass.HttpWorkBegin(ASender: TObject; AWorkMode: TWorkMode; AWorkCountMax: Int64);
begin
if AWorkMode <> wmRead then Exit;
// initialize the status UI as needed...
//
// If TIdHTTP is running in the main thread, update your UI
// components directly as needed and then call the Form's
// Update() method to perform a repaint, or Application.ProcessMessages()
// to process other UI operations, like button presses (for
// cancelling the download, for instance).
//
// If TIdHTTP is running in a worker thread, use the TIdNotify
// or TIdSync class to update the UI components as needed, and
// let the OS dispatch repaints and other messages normally...
TotalBytes := AWorkCountMax;
LastWorkCount := 0;
LastTicks := Ticks;
end;
procedure TSomeClass.HttpWork(ASender: TObject; AWorkMode: TWorkMode; AWorkCount: Int64);
var
PercentDone: Integer;
ElapsedMS: LongWord;
BytesTransferred: Int64;
BytesPerSec: Int64;
begin
if AWorkMode <> wmRead then Exit;
ElapsedMS := GetTickDiff(LastTicks, Ticks);
if ElapsedMS = 0 then ElapsedMS := 1; // avoid EDivByZero error
if TotalBytes > 0 then
PercentDone := (Double(AWorkCount) / TotalBytes) * 100.0;
else
PercentDone := 0.0;
BytesTransferred := AWorkCount - LastWorkCount;
// using just BytesTransferred and ElapsedMS, you can calculate
// all kinds of speed stats - b/kb/mb/gm per sec/min/hr/day ...
BytesPerSec := (Double(BytesTransferred) * 1000) / ElapsedMS;
// update the status UI as needed...
LastWorkCount := AWorkCount;
LastTicks := Ticks;
end;
procedure TSomeClass.HttpWorkEnd(ASender: TObject; AWorkMode: TWorkMode);
begin
if AWorkMode <> wmRead then Exit;
// finalize the status UI as needed...
end;

Juste quelque chose sans rapport mais j'ai vu dans votre code: Vous utilisez les Tiques pour calculer le laps de temps. Il n'est pas grand-chose dans cet exemple. Mais je suggère d'utiliser TDateTime pour représenter StartTime et StopTime et l'utilisation TTimeSpan.Soustraire(StopTime, StartTime) afin de calculer le laps de temps. Parce que MSDN dit les tiques seront remis à zéro si le système est exécuté en continu pendant 49,7 jours. Si votre application s'exécute sur un serveur, la durée peut-être mal calculé.
J'ai volontairement choisi de ne pas utiliser TDateTime parce que je ne voulais pas le code affecté par d'éventuelles modifications de l'horloge (heure d'été, manipulation,etc). En outre, le code est le moment les intervalles entre les événements, qui ne viendra jamais à proximité de la 49.7 jour limite de LongWord. GetTickDiff() comptes pour le wrap-around qui se produit chaque fois GetTickCount() revient à zéro, de sorte que n'est pas un problème.
Comme je l'ai dit hier, j'ai essayé d'Indy nouveau, cette fois en version 10 et je me sens comme v10 est vraiment beaucoup mieux que 9, et fonctionne très bien. J'ai déjà la reprise, la journalisation via HTTP POST et j'ai utilisé des idées à partir de votre code ci-dessus pour faire quelques stats donc oui, - d'Indy est génial, merci man!

InformationsquelleAutor Remy Lebeau

4

Voici un exemple qui montre comment utiliser les composants OnWork pour afficher une barre de progression:

Télécharger un Fichier à partir d'internet par programmation avec une Progression de l'événement à l'aide de Delphi et Indy

Vous ne devriez pas vous inquiéter au sujet de l'allocation de l'espace disque. L'espace disque qui vous est alloué n'est pas écrit, donc il ne sera pas endommager vos disques. Être heureux qu'il est affecté de sorte qu'il n'est pas possible qu'un autre processus de revendications de l'espace disque et laissez vous manquez d'espace!

InformationsquelleAutor Birger

N'oubliez pas d'ajouter ce pour la Variante 2

 : Else HttpClient.Request.ContentRangeEnd := FileSize;

Remplacer

   if Buffer.Size + RECV_BUFFER_SIZE < FileSize then
HttpClient.Request.ContentRangeEnd := Buffer.Size + RECV_BUFFER_SIZE - 1;

Par

   if Buffer.Size + RECV_BUFFER_SIZE < FileSize then
HttpClient.Request.ContentRangeEnd := Buffer.Size + RECV_BUFFER_SIZE - 1;
Else HttpClient.Request.ContentRangeEnd := FileSize;

Merci, vous êtes de droite. Le Code est mis à jour.

InformationsquelleAutor Abdelkrim

Vous devez vous connecter pour publier un commentaire.