DeflateStream Classe

Définition

Espace de noms:

System.IO.Compression

Assembly:

System.IO.Compression.dll

Source:

DeflateStream.cs

Fournit des méthodes et des propriétés pour compresser et décompresser des flux à l’aide de l’algorithme Deflate.

public ref class DeflateStream : System::IO::Stream

public class DeflateStream : System.IO.Stream

type DeflateStream = class
    inherit Stream

Public Class DeflateStream
Inherits Stream

Héritage

Object

MarshalByRefObject

Stream

DeflateStream

Exemples

L’exemple suivant montre comment utiliser la classe DeflateStream pour compresser et décompresser un fichier.

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

public static 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.dfl";
    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.dfl' is 265 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 DeflateStream(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 DeflateStream(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.IO
Imports System.IO.Compression

Module 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.dfl"
    Private Const DecompressedFileName As String = "decompressed.txt"

    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.dfl' weighs 265 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 Sub CreateFileToCompress()
        File.WriteAllText(OriginalFileName, Message)
    End Sub

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

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

    Private 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 Sub DeleteFiles()
        File.Delete(OriginalFileName)
        File.Delete(CompressedFileName)
        File.Delete(DecompressedFileName)
    End Sub
End Module

Remarques

Cette classe représente l’algorithme Deflate, qui est un algorithme standard pour la compression et la décompression de fichiers sans perte. À compter de .NET Framework 4.5, la classe DeflateStream utilise la bibliothèque zlib. Par conséquent, il fournit un meilleur algorithme de compression et, dans la plupart des cas, un fichier compressé plus petit que celui fourni dans les versions antérieures de .NET Framework.

Cette classe ne fournit pas de fonctionnalités inhérentes pour l’ajout de fichiers aux archives zip ou l’extraction de fichiers. Pour utiliser des archives zip, utilisez les classes ZipArchive et ZipArchiveEntry.

La classe DeflateStream utilise le même algorithme de compression que le format de données gzip utilisé par la classe GZipStream.

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

Constructeurs

DeflateStream(Stream, CompressionLevel)	Initialise une nouvelle instance de la classe DeflateStream à l’aide du flux et du niveau de compression spécifiés.
DeflateStream(Stream, CompressionLevel, Boolean)	Initialise une nouvelle instance de la classe DeflateStream à l’aide du flux et du niveau de compression spécifiés, et laisse éventuellement le flux ouvert.
DeflateStream(Stream, CompressionMode)	Initialise une nouvelle instance de la classe DeflateStream à l’aide du flux et du mode de compression spécifiés.
DeflateStream(Stream, CompressionMode, Boolean)	Initialise une nouvelle instance de la classe DeflateStream à l’aide du flux et du mode de compression spécifiés, et laisse éventuellement 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 lors de 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 expirer. (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 une NotSupportedException.
Position	Cette propriété n’est pas prise en charge et lève toujours une NotSupportedException.
ReadTimeout	Obtient ou définit une valeur, en millisecondes, qui détermine la durée pendant laquelle le flux tente de lire avant l’expiration du délai d’attente. (Hérité de Stream)
WriteTimeout	Obtient ou définit une valeur, en millisecondes, qui détermine la durée pendant laquelle le flux tentera d’écrire avant l’expiration du délai d’attente. (Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. (Envisagez d’utiliser la méthode ReadAsync(Byte[], Int32, Int32) à la place.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération d’écriture asynchrone. (Envisagez d’utiliser la méthode WriteAsync(Byte[], Int32, Int32) à la place.)
Close()	Ferme le flux actuel et libère toutes les ressources (telles que les sockets et les handles de fichiers) associées au flux actuel. Au lieu d’appeler cette méthode, vérifiez 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 deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyTo(Stream, Int32)	Lit les octets du flux de déflate actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée.
CopyToAsync(Stream)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, CancellationToken)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’un jeton d’annulation spécifié. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lit de manière asynchrone les octets du flux Deflate actuel et les écrit dans un autre flux, à l’aide d’une taille de mémoire tampon spécifiée.
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateWaitHandle()	Obsolète. Alloue un objet WaitHandle. (Hérité de Stream)
Dispose()	Libère toutes les ressources utilisées par le Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par le DeflateStream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par le DeflateStream.
EndRead(IAsyncResult)	Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser la méthode ReadAsync(Byte[], Int32, Int32) à la place.)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone. (Envisagez d’utiliser la méthode WriteAsync(Byte[], Int32, Int32) à la place.)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Flush()	L’implémentation actuelle de cette méthode n’a aucune fonctionnalité.
FlushAsync()	Efface de façon asynchrone toutes les mémoires tampons de ce flux et entraîne l’écriture de toutes les 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 de déflate, entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent et surveille les demandes d’annulation.
GetHashCode()	Sert 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 actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient la 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 Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Fournit la prise en charge d’un Contract. (Hérité de Stream)
Read(Byte[], Int32, Int32)	Lit un certain nombre d’octets compressés dans le tableau d’octets spécifié.
Read(Span<Byte>)	Lit une séquence d’octets du flux Deflate actuel dans une étendue d’octets et avance la position dans le flux Deflate par le nombre d’octets lus.
ReadAsync(Byte[], Int32, Int32)	Lit de façon asynchrone une séquence d’octets à partir du flux actuel et avance la position dans le flux en fonction du nombre d’octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone une séquence d’octets à partir du flux de déflate actuel, les écrit dans un tableau d’octets, avance la position dans le flux Deflate par le nombre d’octets lus et surveille les demandes d’annulation.
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence d’octets à partir du flux de déflate actuel, les écrit dans une plage de mémoire d’octets, avance la position dans le flux Deflate par le nombre d’octets lus et surveille les demandes d’annulation.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lit au moins un nombre minimal d’octets 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 façon asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux par le nombre d’octets lus et surveille les demandes d’annulation. (Hérité de Stream)
ReadByte()	Lit un octet à partir du flux Deflate et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux Deflate.
ReadExactly(Byte[], Int32, Int32)	Lit count nombre d’octets 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 le buffer soit rempli. (Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone count nombre d’octets 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 opération n’est pas prise en charge et lève toujours une NotSupportedException.
SetLength(Int64)	Cette opération n’est pas prise en charge et lève toujours une NotSupportedException.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
Write(Byte[], Int32, Int32)	Écrit des octets compressés dans le flux sous-jacent à partir du tableau d’octets spécifié.
Write(ReadOnlySpan<Byte>)	Écrit une séquence d’octets dans le flux de déflate actuel et avance la position actuelle dans ce flux Deflate par le nombre d’octets écrits.
WriteAsync(Byte[], Int32, Int32)	Écrit de façon asynchrone une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits. (Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Écrit de manière asynchrone des octets compressés dans le flux de déflate sous-jacent à partir du tableau d’octets spécifié.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de manière asynchrone des octets compressés dans le flux de déflate sous-jacent à partir de la région de mémoire en lecture seule spécifiée.
WriteByte(Byte)	Écrit un octet dans le flux Deflate actuel et avance la position actuelle dans ce flux Deflate par un.

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lit de manière asynchrone les octets de l'Stream et les écrit dans le PipeWriterspécifié, à l’aide d’un jeton d’annulation.
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.

Voir aussi

• lectures partielles et zéro octets dans DeflateStream, GZipStream et CryptoStream