GZipStream.Read Méthode

Définition

Espace de noms:

System.IO.Compression

Assemblys:

netstandard.dll, System.IO.Compression.dll

Surcharges

Nom	Description
Read(Span<Byte>)	Lit une séquence d’octets du flux GZip actuel dans une étendue d’octets et avance la position dans le flux GZip par le nombre d’octets lus.
Read(Byte[], Int32, Int32)	Lit un certain nombre d’octets compressés dans le tableau d’octets spécifié.

Read(Span<Byte>)

Source:

GZipStream.cs

Lit une séquence d’octets du flux GZip actuel dans une étendue d’octets et avance la position dans le flux GZip par le nombre d’octets lus.

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

Paramètres

buffer

Span<Byte>

Une région de mémoire. Lorsque cette méthode est retournée, le contenu de cette région est remplacé par les octets lus à partir de la source actuelle.

Retours

Int32

Nombre total d’octets lus dans la mémoire tampon. Cela peut être inférieur au nombre d’octets alloués dans la mémoire tampon si de nombreux octets ne sont pas actuellement disponibles, ou zéro (0) si la fin du flux a été atteinte.

Remarques

Important

À compter de .NET 6, cette méthode peut ne pas lire autant d’octets que demandés. Pour plus d’informations, consultez lectures partielles et de zéro octets dans DeflateStream, GZipStream et CryptoStream.

Utilisez la CanRead propriété pour déterminer si l’instance actuelle prend en charge la lecture. Utilisez la ReadAsync méthode pour lire de manière asynchrone à partir du flux actuel.

Cette méthode lit un maximum d’octets buffer.Length à partir du flux actuel et les stocke dans buffer. La position actuelle dans le flux GZip est avancée par le nombre d’octets lus ; Toutefois, si une exception se produit, la position actuelle dans le flux GZip reste inchangée. Si aucune donnée n’est disponible, cette méthode bloque jusqu’à ce qu’au moins un octet de données puisse être lu. Read retourne 0 uniquement lorsqu’il n’y a plus de données dans le flux et qu’il n’en est plus attendu (par exemple, un socket fermé ou une fin de fichier). La méthode est libre de retourner moins d’octets que demandé même si la fin du flux n’a pas été atteinte.

Permet BinaryReader de lire les types de données primitifs.

Read(Byte[], Int32, Int32)

Source:

GZipStream.cs

Lit un certain nombre d’octets compressés dans le tableau d’octets spécifié.

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

Paramètres

buffer

Byte[]

Tableau utilisé pour stocker les octets compressés.

offset

Int32

Décalage d’octet auquel les octets de lecture seront placés.

count

Int32

Nombre maximal d’octets compressés à lire.

Retours

Int32

Nombre d’octets qui ont été compressés dans le tableau d’octets. Si la fin du flux a été atteinte, zéro ou le nombre d’octets lus est retourné.

Exceptions

ArgumentNullException

array ou buffer est null.

InvalidOperationException

La CompressionMode valeur était Compress lors de la création de l’objet.

- ou -

Le flux sous-jacent ne prend pas en charge la lecture.

ArgumentOutOfRangeException

offset ou count est inférieur à zéro.

- ou -

array ou buffer longueur moins le point de départ de l’index est inférieur à count.

InvalidDataException

Les données sont dans un format non valide.

ObjectDisposedException

Le flux est fermé.

Exemples

L’exemple suivant montre comment compresser et décompresser des octets à l’aide des méthodes et Write des Read méthodes.

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 282 bytes.
            The decompressed string length is 445 bytes, same as the original length.
        */
    }

    private static void CompressBytesToStream(Stream stream)
    {
        using var compressor = new GZipStream(stream, CompressionLevel.SmallestSize, 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 gzipStream = new GZipStream(stream, CompressionMode.Decompress);

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

        return totalRead;
    }
}

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 GZipStream(stream, CompressionLevel.SmallestSize, leaveOpen = 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 GZipStream(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 282 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 282 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 GZipStream(stream, CompressionLevel.SmallestSize, 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 GZipStream(stream, CompressionMode.Decompress)
            Dim length As Integer = decompressor.Read(decompressedBytes, 0, bufferSize)
            Return length
        End Using
    End Function
End Module

Remarques

Important

À compter de .NET 6, cette méthode peut ne pas lire autant d’octets que demandés. Pour plus d’informations, consultez lectures partielles et de zéro octets dans DeflateStream, GZipStream et CryptoStream.

Si les données sont trouvées dans un format non valide, une InvalidDataException valeur est levée. Une vérification de redondance cyclique (CRC) est effectuée comme l’une des dernières opérations de cette méthode.