Wie schreibt man super-schnelle Datei-streaming von code in C#?

Ich glaube nicht, dass es etwas gibt, innerhalb .NET ermöglicht das kopieren eines Abschnitts von einer Datei ohne Zwischenspeicherung im Arbeitsspeicher. Allerdings fällt mir auf, dass es ineffizient ist sowieso, wie es braucht, um öffnen Sie die input-Datei und suchen Sie viele Male. Wenn Sie nur Aufteilung der Datei, warum nicht öffnen der Eingabedatei einmal, und dann schreiben Sie einfach etwas wie:

public static void CopySection(Stream input, string targetFile, int length)
{
    byte[] buffer = new byte[8192];

    using (Stream output = File.OpenWrite(targetFile))
    {
        int bytesRead = 1;
        //This will finish silently if we couldn't read "length" bytes.
        //An alternative would be to throw an exception
        while (length > 0 && bytesRead > 0)
        {
            bytesRead = input.Read(buffer, 0, Math.Min(length, buffer.Length));
            output.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
    }
}

Dieser hat eine kleine Ineffizienz bei der Schaffung einer Puffer bei jedem Aufruf einer - möglicherweise möchten Sie erstellen den Puffer einmal und pass, die in der Methode als auch:

public static void CopySection(Stream input, string targetFile,
                               int length, byte[] buffer)
{
    using (Stream output = File.OpenWrite(targetFile))
    {
        int bytesRead = 1;
        //This will finish silently if we couldn't read "length" bytes.
        //An alternative would be to throw an exception
        while (length > 0 && bytesRead > 0)
        {
            bytesRead = input.Read(buffer, 0, Math.Min(length, buffer.Length));
            output.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
    }
}

Beachten Sie, dass diese auch schließt den Ausgabe-stream (durch die using-Anweisung), die Ihre ursprüngliche code nicht.

Der wichtige Punkt ist, dass das Betriebssystem die Datei-Pufferung effizienter, weil Sie die Wiederverwendung der gleichen input-stream, anstelle von erneuten öffnen der Datei am Anfang und dann suchen.

Ich denke werde es deutlich schneller, aber natürlich werden Sie brauchen, um zu versuchen, um zu sehen,...

Dieser übernimmt die zusammenhängenden Stücke, natürlich. Wenn Sie brauchen, um zu überspringen bits der Datei, können Sie tun, aus außerhalb der Methode. Auch, wenn Sie das schreiben von sehr kleinen Dateien, möchten Sie vielleicht, um die Optimierung für die situation zu - der einfachste Weg, dies zu tun wäre wahrscheinlich die Einführung einer BufferedStream Verpackung der input-stream.

InformationsquelleAutor der Antwort Jon Skeet

Wie groß ist length? Sie können besser tun, um zu re-verwenden Sie eine Feste Größe (nicht allzu großes, aber nicht obszön) Puffer, und vergessen BinaryReader... verwenden Sie einfach Stream.Read und Stream.Write.

(edit) so etwas wie:

private static void copy(string srcFile, string dstFile, int offset,
     int length, byte[] buffer)
{
    using(Stream inStream = File.OpenRead(srcFile))
    using (Stream outStream = File.OpenWrite(dstFile))
    {
        inStream.Seek(offset, SeekOrigin.Begin);
        int bufferLength = buffer.Length, bytesRead;
        while (length > bufferLength &&
            (bytesRead = inStream.Read(buffer, 0, bufferLength)) > 0)
        {
            outStream.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
        while (length > 0 &&
            (bytesRead = inStream.Read(buffer, 0, length)) > 0)
        {
            outStream.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
    }        
}

InformationsquelleAutor der Antwort Marc Gravell

Haben Sie sich überlegt mit der CCR, da Sie schriftlich sind separate Dateien, die Sie tun können, alles parallel (Lesen und schreiben) und der CCR-macht es sehr einfach, dies zu tun.

static void Main(string[] args)
    {
        Dispatcher dp = new Dispatcher();
        DispatcherQueue dq = new DispatcherQueue("DQ", dp);

        Port<long> offsetPort = new Port<long>();

        Arbiter.Activate(dq, Arbiter.Receive<long>(true, offsetPort,
            new Handler<long>(Split)));

        FileStream fs = File.Open(file_path, FileMode.Open);
        long size = fs.Length;
        fs.Dispose();

        for (long i = 0; i < size; i += split_size)
        {
            offsetPort.Post(i);
        }
    }

    private static void Split(long offset)
    {
        FileStream reader = new FileStream(file_path, FileMode.Open, 
            FileAccess.Read);
        reader.Seek(offset, SeekOrigin.Begin);
        long toRead = 0;
        if (offset + split_size <= reader.Length)
            toRead = split_size;
        else
            toRead = reader.Length - offset;

        byte[] buff = new byte[toRead];
        reader.Read(buff, 0, (int)toRead);
        reader.Dispose();
        File.WriteAllBytes("c:\\out" + offset + ".txt", buff);
    }

Dieser code posten offsets zu einem CCR-port was bewirkt, dass ein Thread erstellt werden, um den code auszuführen, der in der Split-Methode. Dies bewirkt, dass Sie, die Datei zu öffnen mehrere Male, aber beseitigt die Notwendigkeit für die Synchronisation. Sie können machen Sie mehr Speicher effizient, aber Sie müssen zu opfern Geschwindigkeit.

InformationsquelleAutor der Antwort SpaceghostAli

Verwendung von FileStream - + StreamWriter ich weiß, es ist möglich erstellen Sie riesige Dateien in wenig Zeit (weniger als 1 min 30 Sekunden). Ich erzeugt drei Dateien mit insgesamt 700+ MB von einer Datei mit diesem Technik.

Ihre primäre problem mit dem code, die Sie verwenden ist, dass Sie das öffnen einer Datei jedes mal. , Erstellen von Datei-I/O-overhead.

Wenn Sie wusste, dass die Namen der Dateien, die Sie würde die Generierung vor der Zeit, können Sie extrahieren Sie die Datei.OpenWrite in eine separate Methode; es wird die Geschwindigkeit erhöhen. Ohne zu sehen, den code, der bestimmt, wie Sie die Aufteilung der Dateien, ich glaube nicht, können Sie viel schneller.

InformationsquelleAutor der Antwort mcauthorn

(Für zukünftige Referenz.)

Wahrscheinlich der Schnellste Weg, dies zu tun wäre, um memory-mapped-Dateien (also vor allem das kopieren von Speicher, und die OS-Behandlung die Datei liest/schreibt über seine paging - /Speicher-management).

Memory-Mapped-Dateien sind in verwaltetem code unterstützt .NET 4.0.

Aber wie gesagt, Sie brauchen ein Profil, und erwarten, dass der switch von native-code für maximale Leistung.

InformationsquelleAutor der Antwort Richard