DeflateStream.Write Methode

Definition

Namespace:

System.IO.Compression

Assemblys:

netstandard.dll, System.IO.Compression.dll

Überlädt

Name	Beschreibung
Write(ReadOnlySpan<Byte>)	Schreibt eine Folge von Bytes in den aktuellen Deflate-Datenstrom und wechselt die aktuelle Position innerhalb dieses Deflate-Datenstroms um die Anzahl der geschriebenen Bytes.
Write(Byte[], Int32, Int32)	Schreibt komprimierte Bytes in den zugrunde liegenden Datenstrom aus dem angegebenen Bytearray.

Write(ReadOnlySpan<Byte>)

Quelle:

DeflateStream.cs

Schreibt eine Folge von Bytes in den aktuellen Deflate-Datenstrom und wechselt die aktuelle Position innerhalb dieses Deflate-Datenstroms um die Anzahl der geschriebenen Bytes.

public:
 override void Write(ReadOnlySpan<System::Byte> buffer);

public override void Write(ReadOnlySpan<byte> buffer);

override this.Write : ReadOnlySpan<byte> -> unit

Public Overrides Sub Write (buffer As ReadOnlySpan(Of Byte))

Parameter

buffer

ReadOnlySpan<Byte>

Ein Speicherbereich. Diese Methode kopiert den Inhalt dieses Bereichs in den aktuellen Deflate-Datenstrom.

Hinweise

Verwenden Sie die CanWrite Eigenschaft, um zu bestimmen, ob die aktuelle Instanz das Schreiben unterstützt. Verwenden Sie die WriteAsync Methode, um asynchron in den aktuellen Datenstrom zu schreiben.

Wenn der Schreibvorgang erfolgreich ist, wechselt die Position innerhalb des Verzögerungsdatenstroms um die Anzahl der geschriebenen Bytes. Wenn eine Ausnahme auftritt, bleibt die Position innerhalb des Verzögerungsdatenstroms unverändert.

Write(Byte[], Int32, Int32)

Quelle:

DeflateStream.cs

Schreibt komprimierte Bytes in den zugrunde liegenden Datenstrom aus dem angegebenen Bytearray.

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

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

override this.Write : byte[] * int * int -> unit

Public Overrides Sub Write (buffer As Byte(), offset As Integer, count As Integer)

Parameter

buffer

Byte[]

Der Puffer, der die zu komprimierenden Daten enthält.

offset

Int32

Der Byteoffset, von dem die Bytes gelesen werden.

count

Int32

Die maximale Anzahl von Bytes, die geschrieben werden sollen.

Hinweise

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