DeflateStream.Read Methode

Definition

Namespace:

System.IO.Compression

Assemblys:

netstandard.dll, System.IO.Compression.dll

Überlädt

Name	Beschreibung
Read(Span<Byte>)	Liest eine Abfolge von Bytes aus dem aktuellen Deflate-Datenstrom in eine Bytespanne und wechselt die Position innerhalb des Deflate-Datenstroms um die Anzahl der gelesenen Bytes.
Read(Byte[], Int32, Int32)	Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray.

Read(Span<Byte>)

Quelle:

DeflateStream.cs

Liest eine Abfolge von Bytes aus dem aktuellen Deflate-Datenstrom in eine Bytespanne und wechselt die Position innerhalb des Deflate-Datenstroms um die Anzahl der gelesenen Bytes.

public:
 override int Read(Span<System::Byte> buffer);

public override int Read(Span<byte> buffer);

override this.Read : Span<byte> -> int

Public Overrides Function Read (buffer As Span(Of Byte)) As Integer

Parameter

buffer

Span<Byte>

Ein Speicherbereich. Wenn diese Methode zurückgegeben wird, werden die Inhalte dieses Bereichs durch die aus der aktuellen Quelle gelesenen Bytes ersetzt.

Gibt zurück

Int32

Die Gesamtanzahl der in den Puffer gelesenen Bytes. Dies kann kleiner als die Anzahl der im Puffer zugewiesenen Bytes sein, wenn viele Bytes derzeit nicht verfügbar sind, oder Null (0), wenn das Ende des Datenstroms erreicht wurde.

Hinweise

Von Bedeutung

Ab .NET 6 liest diese Methode möglicherweise nicht so viele Bytes wie angefordert. Weitere Informationen finden Sie unter Partial- und Zero-Byte-Lesevorgänge in DeflateStream, GZipStream und CryptoStream.

Verwenden Sie die CanRead Eigenschaft, um zu ermitteln, ob die aktuelle Instanz das Lesen unterstützt. Verwenden Sie die ReadAsync Methode, um asynchron aus dem aktuellen Datenstrom zu lesen.

Diese Methode liest maximal buffer.Length Bytes aus dem aktuellen Datenstrom und speichert sie in buffer. Die aktuelle Position innerhalb des Deflate-Datenstroms wird um die Anzahl der gelesenen Bytes erweitert. Wenn jedoch eine Ausnahme auftritt, bleibt die aktuelle Position innerhalb des Deflate-Datenstroms unverändert. Diese Methode wird blockiert, bis mindestens ein Byte von Daten gelesen werden kann, falls keine Daten verfügbar sind. Read gibt 0 nur zurück, wenn im Datenstrom keine weiteren Daten vorhanden sind und keine weiteren Daten erwartet werden (z. B. ein geschlossener Socket oder ein Ende der Datei). Die Methode kann weniger Bytes zurückgeben als angefordert, auch wenn das Ende des Datenstroms nicht erreicht wurde.

Wird zum Lesen primitiver Datentypen verwendet BinaryReader .

Read(Byte[], Int32, Int32)

Quelle:

DeflateStream.cs

Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray.

public:
 override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);

public override int Read(byte[] buffer, int offset, int count);

override this.Read : byte[] * int * int -> int

Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parameter

buffer

Byte[]

Das Array zum Speichern dekomprimierte Bytes.

offset

Int32

Der Byteoffset, an dem die Lesebytes platziert werden.

count

Int32

Die maximale Anzahl der zu lesenden dekomprimierten Bytes.

Gibt zurück

Int32

Die Anzahl der Bytes, die in das Bytearray gelesen wurden.

Ausnahmen

ArgumentNullException

array oder buffer ist null.

InvalidOperationException

Der CompressionMode Wert war Compress , als das Objekt erstellt wurde.

- oder -

Der zugrunde liegende Datenstrom unterstützt das Lesen nicht.

ArgumentOutOfRangeException

offset oder count ist kleiner als Null.

- oder -

array oder buffer Die Länge minus dem Index-Anfangspunkt ist kleiner als count.

InvalidDataException

Die Daten haben ein ungültiges Format.

ObjectDisposedException

Der Datenstrom wird geschlossen.

Hinweise

Von Bedeutung

Ab .NET 6 liest diese Methode möglicherweise nicht so viele Bytes wie angefordert. Weitere Informationen finden Sie unter Partial- und Zero-Byte-Lesevorgänge in DeflateStream, GZipStream und CryptoStream.

Das folgende Beispiel zeigt, wie Byte mithilfe der und Write der Read Methoden komprimiert und dekomprimiert werden.

using System;
using System.IO;
using System.IO.Compression;
using System.Text;

public static class MemoryWriteReadExample
{
    private const string Message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
    private static readonly byte[] s_messageBytes = Encoding.ASCII.GetBytes(Message);

    public static void Run()
    {
        Console.WriteLine($"The original string length is {s_messageBytes.Length} bytes.");
        using var stream = new MemoryStream();
        CompressBytesToStream(stream);
        Console.WriteLine($"The compressed stream length is {stream.Length} bytes.");
        int decompressedLength = DecompressStreamToBytes(stream);
        Console.WriteLine($"The decompressed string length is {decompressedLength} bytes, same as the original length.");
        /*
         Output:
            The original string length is 445 bytes.
            The compressed stream length is 265 bytes.
            The decompressed string length is 445 bytes, same as the original length.
        */
    }

    private static void CompressBytesToStream(Stream stream)
    {
        using var compressor = new DeflateStream(stream, CompressionMode.Compress, leaveOpen: true);
        compressor.Write(s_messageBytes, 0, s_messageBytes.Length);
    }

    private static int DecompressStreamToBytes(Stream stream)
    {
        stream.Position = 0;
        int bufferSize = 512;
        byte[] buffer = new byte[bufferSize];
        using var deflateStream = new DeflateStream(stream, CompressionMode.Decompress);

        int totalRead = 0;
        while (totalRead < buffer.Length)
        {
            int bytesRead = deflateStream.Read(buffer.AsSpan(totalRead));
            if (bytesRead == 0) break;
            totalRead += bytesRead;
        }

        return totalRead;
    }
}

module MemoryWriteReadExample

open System.IO
open System.IO.Compression
open System.Text

let message =
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."

let s_messageBytes = Encoding.ASCII.GetBytes message

let compressBytesToStream stream =
    use compressor = new DeflateStream(stream, CompressionMode.Compress, true)
    compressor.Write(s_messageBytes, 0, s_messageBytes.Length)

let decompressStreamToBytes (stream: Stream) =
    stream.Position <- 0
    let bufferSize = 512
    let decompressedBytes = Array.zeroCreate bufferSize
    use decompressor = new DeflateStream(stream, CompressionMode.Decompress)
    decompressor.Read(decompressedBytes, 0, bufferSize)

[<EntryPoint>]
let main _ =
    printfn $"The original string length is {s_messageBytes.Length} bytes."
    use stream = new MemoryStream()
    compressBytesToStream stream
    printfn $"The compressed stream length is {stream.Length} bytes."
    let decompressedLength = decompressStreamToBytes stream
    printfn $"The decompressed string length is {decompressedLength} bytes, same as the original length."
    0

// Output:
//     The original string length is 445 bytes.
//     The compressed stream length is 265 bytes.
//     The decompressed string length is 445 bytes, same as the original length.

Imports System.IO
Imports System.IO.Compression
Imports System.Text

Module MemoryWriteReadExample
    Private Const Message As String = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
    Private ReadOnly s_messageBytes As Byte() = Encoding.ASCII.GetBytes(Message)

    Sub Main()
        Console.WriteLine($"The original string length is {s_messageBytes.Length} bytes.")

        Using stream = New MemoryStream()
            CompressBytesToStream(stream)
            Console.WriteLine($"The compressed stream length is {stream.Length} bytes.")
            Dim decompressedLength As Integer = DecompressStreamToBytes(stream)
            Console.WriteLine($"The decompressed string length is {decompressedLength} bytes, same as the original length.")
        End Using
        ' Output:
        '   The original string length is 445 bytes.
        '   The compressed stream length is 265 bytes.
        '   The decompressed string length is 445 bytes, same as the original length.
    End Sub

    Private Sub CompressBytesToStream(ByVal stream As Stream)
        Using compressor = New DeflateStream(stream, CompressionMode.Compress, leaveOpen:=True)
            compressor.Write(s_messageBytes, 0, s_messageBytes.Length)
        End Using
    End Sub

    Private Function DecompressStreamToBytes(ByVal stream As Stream) As Integer
        stream.Position = 0
        Dim bufferSize As Integer = 512
        Dim decompressedBytes As Byte() = New Byte(bufferSize - 1) {}
        Using decompressor = New DeflateStream(stream, CompressionMode.Decompress)
            Dim length As Integer = decompressor.Read(decompressedBytes, 0, bufferSize)
            Return length
        End Using
    End Function
End Module