GZipStream Classe

Définition

Fournit les méthodes et les propriétés utilisées pour compresser et décompresser des flux à l’aide de la spécification de format de données GZip.

public ref class GZipStream : System::IO::Stream
public class GZipStream : System.IO.Stream
type GZipStream = class
    inherit Stream
Public Class GZipStream
Inherits Stream
Héritage
GZipStream
Héritage

Exemples

L’exemple suivant montre comment utiliser la GZipStream classe pour compresser et décompresser un répertoire de fichiers.

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

public class FileCompressionModeExample
{
    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 const string OriginalFileName = "original.txt";
    private const string CompressedFileName = "compressed.gz";
    private const string DecompressedFileName = "decompressed.txt";

    public static void Run()
    {
        CreateFileToCompress();
        CompressFile();
        DecompressFile();
        PrintResults();
        DeleteFiles();

        /*
         Output:

            The original file 'original.txt' is 445 bytes. Contents: "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."

            The compressed file 'compressed.gz' is 283 bytes.

            The decompressed file 'decompressed.txt' is 445 bytes. Contents: "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 void CreateFileToCompress() => File.WriteAllText(OriginalFileName, Message);

    private static void CompressFile()
    {
        using FileStream originalFileStream = File.Open(OriginalFileName, FileMode.Open);
        using FileStream compressedFileStream = File.Create(CompressedFileName);
        using var compressor = new GZipStream(compressedFileStream, CompressionMode.Compress);
        originalFileStream.CopyTo(compressor);
    }

    private static void DecompressFile()
    {
        using FileStream compressedFileStream = File.Open(CompressedFileName, FileMode.Open);
        using FileStream outputFileStream = File.Create(DecompressedFileName);
        using var decompressor = new GZipStream(compressedFileStream, CompressionMode.Decompress);
        decompressor.CopyTo(outputFileStream);
    }

    private static void PrintResults()
    {
        long originalSize = new FileInfo(OriginalFileName).Length;
        long compressedSize = new FileInfo(CompressedFileName).Length;
        long decompressedSize = new FileInfo(DecompressedFileName).Length;

        Console.WriteLine($"The original file '{OriginalFileName}' is {originalSize} bytes. Contents: \"{File.ReadAllText(OriginalFileName)}\"");
        Console.WriteLine($"The compressed file '{CompressedFileName}' is {compressedSize} bytes.");
        Console.WriteLine($"The decompressed file '{DecompressedFileName}' is {decompressedSize} bytes. Contents: \"{File.ReadAllText(DecompressedFileName)}\"");
    }

    private static void DeleteFiles()
    {
        File.Delete(OriginalFileName);
        File.Delete(CompressedFileName);
        File.Delete(DecompressedFileName);
    }
}
Imports System
Imports System.IO
Imports System.IO.Compression

Public Class FileCompressionModeExample
    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 Const OriginalFileName As String = "original.txt"
    Private Const CompressedFileName As String = "compressed.gz"
    Private Const DecompressedFileName As String = "decompressed.txt"

    Public Shared Sub Main()
        CreateFileToCompress()
        CompressFile()
        DecompressFile()
        PrintResults()
        DeleteFiles()

        ' Output:
        '   The original file 'original.txt' weighs 445 bytes. Contents: "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."

        '   The compressed file 'compressed.gz' weighs 283 bytes.

        '   The decompressed file 'decompressed.txt' weighs 445 bytes. Contents: "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."
    End Sub

    Private Shared Sub CreateFileToCompress()
        File.WriteAllText(OriginalFileName, Message)
    End Sub

    Private Shared Sub CompressFile()
        Using originalFileStream As FileStream = File.Open(OriginalFileName, FileMode.Open)
            Using compressedFileStream As FileStream = File.Create(CompressedFileName)
                Using compressor = New GZipStream(compressedFileStream, CompressionMode.Compress)
                    originalFileStream.CopyTo(compressor)
                End Using
            End Using
        End Using
    End Sub

    Private Shared Sub DecompressFile()
        Using compressedFileStream As FileStream = File.Open(CompressedFileName, FileMode.Open)
            Using outputFileStream As FileStream = File.Create(DecompressedFileName)
                Using decompressor = New GZipStream(compressedFileStream, CompressionMode.Decompress)
                    decompressor.CopyTo(outputFileStream)
                End Using
            End Using
        End Using
    End Sub

    Private Shared Sub PrintResults()
        Dim originalSize As Long = New FileInfo(OriginalFileName).Length
        Dim compressedSize As Long = New FileInfo(CompressedFileName).Length
        Dim decompressedSize As Long = New FileInfo(DecompressedFileName).Length

        Console.WriteLine($"The original file '{OriginalFileName}' weighs {originalSize} bytes. Contents: ""{File.ReadAllText(OriginalFileName)}""")
        Console.WriteLine($"The compressed file '{CompressedFileName}' weighs {compressedSize} bytes.")
        Console.WriteLine($"The decompressed file '{DecompressedFileName}' weighs {decompressedSize} bytes. Contents: ""{File.ReadAllText(DecompressedFileName)}""")
    End Sub

    Private Shared Sub DeleteFiles()
        File.Delete(OriginalFileName)
        File.Delete(CompressedFileName)
        File.Delete(DecompressedFileName)
    End Sub
End Class

Remarques

Cette classe représente le format de données gzip, qui utilise un algorithme standard pour la compression et la décompression de fichiers sans perte. Le format inclut une redondance cyclique case activée valeur pour détecter l’altération des données. Le format de données gzip utilise le même algorithme que la DeflateStream classe , mais peut être étendu pour utiliser d’autres formats de compression. Le format peut être facilement mis en œuvre d’une manière qui n’est pas couverte par les brevets.

À compter de .NET Framework 4.5, la DeflateStream classe utilise la bibliothèque zlib pour la compression. Par conséquent, il fournit un meilleur algorithme de compression et, dans la plupart des cas, un fichier compressé plus petit que dans les versions antérieures de .NET Framework.

Les objets compressés GZipStream écrits dans un fichier avec l’extension .gz peuvent être décompressés à l’aide de nombreux outils de compression courants. Toutefois, cette classe ne fournit pas de fonctionnalités pour ajouter des fichiers à des archives zip ou les extraire.

La fonctionnalité de compression dans DeflateStream et GZipStream est exposée en tant que flux. Les données étant lues octet par octet, il n’est pas possible d’effectuer plusieurs passes pour déterminer la meilleure méthode pour compresser des fichiers entiers ou des blocs de données volumineux. Les DeflateStream classes et GZipStream sont mieux utilisées sur les sources de données non compressées. Si les données sources sont déjà compressées, l’utilisation de ces classes peut en fait augmenter la taille du flux.

Notes pour les héritiers

Lorsque vous héritez de GZipStream, vous devez remplacer les membres suivants : CanSeek, CanWriteet CanRead.

Constructeurs

GZipStream(Stream, CompressionLevel)

Initialise une nouvelle instance de la classe GZipStream à l'aide du flux et du niveau de compression spécifiés.

GZipStream(Stream, CompressionLevel, Boolean)

Initialise une nouvelle instance de la classe GZipStream à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert.

GZipStream(Stream, CompressionMode)

Initialise une nouvelle instance de la classe GZipStream à l'aide du flux et du mode de compression spécifiés.

GZipStream(Stream, CompressionMode, Boolean)

Initialise une nouvelle instance de la classe GZipStream à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert.

Propriétés

BaseStream

Obtient une référence au flux sous-jacent.

CanRead

Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier.

CanSeek

Obtient une valeur indiquant si le flux prend en charge la recherche.

CanTimeout

Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente.

(Hérité de Stream)
CanWrite

Obtient une valeur indiquant si le flux prend en charge l'écriture.

Length

Cette propriété n'est pas prise en charge et lève toujours NotSupportedException.

Position

Cette propriété n'est pas prise en charge et lève toujours NotSupportedException.

ReadTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’effectuer la lecture avant dépassement du délai d’attente.

(Hérité de Stream)
WriteTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’écrire des données avant l’expiration du délai d’attente.

(Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération de lecture asynchrone. (Utilisez la méthode ReadAsync(Byte[], Int32, Int32) à la place.)

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération de lecture asynchrone. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone. (Utilisez la méthode WriteAsync(Byte[], Int32, Int32) à la place.)

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé.

(Hérité de Stream)
CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyTo(Stream, Int32)

Lit les octets du flux GZip actuel et les écrit dans un autre flux, à l’aide de la taille de mémoire tampon spécifiée.

CopyTo(Stream, Int32)

Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, Int32)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lit de façon asynchrone les octets du flux GZip actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.

CopyToAsync(Stream, Int32, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. Les positions des deux flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
CreateWaitHandle()
Obsolète.
Obsolète.
Obsolète.

Alloue un objet WaitHandle.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par Stream.

(Hérité de Stream)
Dispose(Boolean)

Libère les ressources non managées utilisées par GZipStream et libère éventuellement les ressources managées.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par GZipStream.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par Stream.

(Hérité de Stream)
EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine. (Utilisez la méthode ReadAsync(Byte[], Int32, Int32) à la place.)

EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
EndWrite(IAsyncResult)

Gère la fin d'une opération d'écriture asynchrone. (Utilisez la méthode WriteAsync(Byte[], Int32, Int32) à la place.)

EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Flush()

Vide les mémoires tampons internes.

FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent.

(Hérité de Stream)
FlushAsync(CancellationToken)

Efface de façon asynchrone toutes les mémoires tampons pour ce flux GZip, provoque l’écriture des données mises en mémoire tampon sur l’appareil sous-jacent et supervise les demandes d’annulation.

FlushAsync(CancellationToken)

Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les requêtes d'annulation.

(Hérité de Stream)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
ObjectInvariant()
Obsolète.

Assure la prise en charge d'un Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

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

Read(Span<Byte>)

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

Read(Span<Byte>)

En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)

Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d’octets du flux GZip actuel dans un tableau d’octets, avance la position dans le flux GZip du nombre d’octets lus et supervise les demandes d’annulation.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.

(Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d’octets du flux GZip actuel dans une région de mémoire d’octets, avance la position dans le flux GZip du nombre d’octets lus et supervise les demandes d’annulation.

ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.

(Hérité de Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)

Lit au moins un nombre minimal d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus.

(Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

Lit de manière asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadByte()

Lit un octet du flux GZip et avance d’un octet la position au sein du flux, ou retourne -1 si la fin du flux GZip a été atteinte.

ReadByte()

Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte.

(Hérité de Stream)
ReadExactly(Byte[], Int32, Int32)

Lit le nombre d’octets count du flux actuel et avance la position dans le flux.

(Hérité de Stream)
ReadExactly(Span<Byte>)

Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que soit buffer rempli.

(Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

Lit de manière asynchrone le nombre d’octets count du flux actuel, avance la position dans le flux et surveille les demandes d’annulation.

(Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)

Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer soit rempli et surveille les demandes d’annulation.

(Hérité de Stream)
Seek(Int64, SeekOrigin)

Cette propriété n'est pas prise en charge et lève toujours NotSupportedException.

SetLength(Int64)

Cette propriété n'est pas prise en charge et lève toujours NotSupportedException.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
Write(Byte[], Int32, Int32)

Écrit les octets compressés dans le flux GZip sous-jacent à partir du tableau d’octets spécifié.

Write(ReadOnlySpan<Byte>)

Écrit une séquence d’octets dans le flux GZip actuel à partir d’une étendue d’octets en lecture seule et avance la position actuelle dans ce flux GZip du nombre d’octets écrits.

Write(ReadOnlySpan<Byte>)

En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone les octets compressés dans le flux GZip sous-jacent à partir du tableau d’octets spécifié.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.

(Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone les octets compressés dans le flux GZip sous-jacent à partir de la région de mémoire d’octets en lecture seule spécifiée.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.

(Hérité de Stream)
WriteByte(Byte)

Écrit un octet dans le flux GZip actuel et avance la position actuelle dans ce flux GZip d’un.

WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.

(Hérité de Stream)

Méthodes d’extension

AsInputStream(Stream)

Convertit un flux managé dans .NET pour les applications du Windows Store en un flux d’entrée Windows Runtime.

AsOutputStream(Stream)

Convertit un flux managé dans .NET pour les applications du Windows Store en un flux de sortie Windows Runtime.

AsRandomAccessStream(Stream)

Convertit le flux spécifié en flux d'accès aléatoire.

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.

S’applique à

Voir aussi