Dieser stream unterstützt keine seek-Operationen. HttpWebResponse

Mache ich ein Programm, das herunterladen von Dateien über http.

Ich habe es heruntergeladen, aber ich möchte in der Lage sein, um zu pausieren die downloads, das Programm schließen und fortsetzen Sie zu einem späteren Zeitpunkt erneut.

Ich wissen, wo ich bin, Sie herunterladen aus und unterstützt diese.

Bin ich den Download der Datei durch HttpWebResponse und Lesen die Antwort in ein Stream mit GetResponseStream.

Wenn ich die app schließen und neu starten, ich bin stecken, wie den download fortzusetzen. Ich habe versucht zu tun eine Suche auf dem stream, aber es Staaten, Ihre nicht unterstützt.

Was wäre der beste Weg, dies zu tun?

Beachten Sie, dass Sie sagen, die server neu zu starten - Sie können nicht einfach tun es selbst. Das ist der Grund für die AddRange Antwort unten.

InformationsquelleAutor | 2009-09-17

  1. 9

    Wenn der server dies unterstützt, müssen Sie senden die Angebot Http-header mit Ihrer Anfrage über das AddRange Methode:

    request.AddRange(1024);

    Dieser wird Sie anweisen, den server zu starten, das senden der Datei nach der 1. Kb. Dann Lesen Sie einfach die Antwort-stream als normal.

    Um zu testen, ob ein server unterstützt das fortsetzen Sie können senden Sie eine HEAD anfordern und testen, ob es sendet die Accept-Ranges: bytes header.

    Möchten Sie einen link auf die MSDN docs? msdn.microsoft.com/en-us/library/...

    InformationsquelleAutor Darin Dimitrov

  2. 2

    Wie wäre es mit einem HTTPRangeStream Klasse? 

    using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;

namespace Ionic.Kewl
{
    public class HTTPRangeStream : Stream
    {
        private string url;
        private long length;
        private long position;
        private long totalBytesRead;
        private int totalReads;

        public HTTPRangeStream(string URL)
        {
            url = URL;
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
            HttpWebResponse result = (HttpWebResponse)request.GetResponse();
            length = result.ContentLength;
        }

        public long TotalBytesRead    { get { return totalBytesRead; } }
        public long TotalReads        { get { return totalReads; } }
        public override bool CanRead  { get { return true; } }
        public override bool CanSeek  { get { return true; } }
        public override bool CanWrite { get { return false; } }
        public override long Length   { get { return length; } }

        public override bool CanTimeout
        {
            get
            {
                return base.CanTimeout;
            }
        }


        public override long Position
        {
            get
            {
                return position;
            }
            set
            {
                if (value < 0) throw new ArgumentException();
                position = value;
            }
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.Begin:
                    position = offset;
                    break;
                case SeekOrigin.Current:
                    position += offset;
                    break;
                case SeekOrigin.End:
                    position = Length + offset;
                    break;
                default:
                    break;
            }
            return Position;
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
            request.AddRange(Convert.ToInt32(position), Convert.ToInt32(position) + count);
            HttpWebResponse result = (HttpWebResponse)request.GetResponse();
            using (Stream stream = result.GetResponseStream())
            {
                stream.Read(buffer, offset, count);
                stream.Close();
            }
            totalBytesRead += count;
            totalReads++;
            Position += count;
            return count;
        }


        public override void Write(byte[] buffer, int offset, int count)
        {
            throw new NotSupportedException();
        }

        public override void SetLength(long value)
        {
            throw new NotSupportedException();
        }
        public override void Flush()
        {
            throw new NotSupportedException();
        }

    }
}
    Funktioniert dieser Klasse funktionieren, auch wenn der server nicht akzeptieren, die Wiederaufnahme?
    Ich weiß nicht, was "Wiederaufnahme" ist. HTTP 1.1 definiert ein Range-header, die diese Klasse setzt auf. wenn der server HTTP 1.1, dann macht er Bereich und kann kontaktiert werden, die von dieser Klasse.
    durch resuming ich meinte range header danke für die Aufklärung

    InformationsquelleAutor Cheeso

  3. 0

    Ihre Lösung ist gut, aber es funktioniert nur für die Fälle, in denen der server sendet den Content-Length-header. Dieser header nicht in dynamisch generierte Inhalte.

    Auch für diese Lösung ist, senden Sie eine Anforderung für jeder Lesen. Wenn sich der Inhalt ändert, die auf dem server zwischen den Anfragen, dann erhalten Sie inkonsistente Ergebnisse.

    Ich würde verbessert werden, durch speichern der Daten-lokal - entweder auf der Festplatte oder im Arbeitsspeicher. Dann können Sie versuchen, in alles, was Sie wollen. Es werden nicht jedes problem der Inkonsistenz, und Sie brauchen nur eines HttpWebRequest herunterladen.

    InformationsquelleAutor feroze

Schreibe einen Kommentar