DeflateStream Classe

Definizione

Spazio dei nomi:

System.IO.Compression

Assembly:

System.IO.Compression.dll

Origine:

DeflateStream.cs

Fornisce metodi e proprietà per la compressione e la decompressione dei flussi tramite l'algoritmo Deflate.

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

public class DeflateStream : System.IO.Stream

type DeflateStream = class
    inherit Stream

Public Class DeflateStream
Inherits Stream

Ereditarietà

Object

MarshalByRefObject

Stream

DeflateStream

Esempio

Nell'esempio seguente viene illustrato come usare la classe DeflateStream per comprimere e decomprimere un file.

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

Commenti

Questa classe rappresenta l'algoritmo Deflate, che è un algoritmo standard di settore per la compressione e la decompressione dei file senza perdita. A partire da .NET Framework 4.5, la classe DeflateStream usa la libreria zlib. Di conseguenza, fornisce un algoritmo di compressione migliore e, nella maggior parte dei casi, un file compresso più piccolo rispetto a quello fornito nelle versioni precedenti di .NET Framework.

Questa classe non fornisce intrinsecamente funzionalità per l'aggiunta di file o l'estrazione di file dagli archivi ZIP. Per usare gli archivi ZIP, usare le classi ZipArchive e ZipArchiveEntry.

La classe DeflateStream usa lo stesso algoritmo di compressione del formato di dati gzip usato dalla classe GZipStream.

La funzionalità di compressione in DeflateStream e GZipStream viene esposta come flusso. I dati vengono letti in base a byte, pertanto non è possibile eseguire più passaggi per determinare il metodo migliore per comprimere interi file o blocchi di dati di grandi dimensioni. Le classi DeflateStream e GZipStream vengono usate meglio nelle origini di dati non compresse. Se i dati di origine sono già compressi, l'uso di queste classi può effettivamente aumentare le dimensioni del flusso.

Costruttori

DeflateStream(Stream, CompressionLevel)	Inizializza una nuova istanza della classe DeflateStream utilizzando il flusso e il livello di compressione specificati.
DeflateStream(Stream, CompressionLevel, Boolean)	Inizializza una nuova istanza della classe DeflateStream utilizzando il flusso e il livello di compressione specificati e, facoltativamente, lascia aperto il flusso.
DeflateStream(Stream, CompressionMode)	Inizializza una nuova istanza della classe DeflateStream utilizzando il flusso e la modalità di compressione specificati.
DeflateStream(Stream, CompressionMode, Boolean)	Inizializza una nuova istanza della classe DeflateStream utilizzando il flusso e la modalità di compressione specificati e, facoltativamente, lascia aperto il flusso.

Proprietà

BaseStream	Ottiene un riferimento al flusso sottostante.
CanRead	Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file.
CanSeek	Ottiene un valore che indica se il flusso supporta la ricerca.
CanTimeout	Ottiene un valore che determina se il flusso corrente può verificarsi un timeout. (Ereditato da Stream)
CanWrite	Ottiene un valore che indica se il flusso supporta la scrittura.
Length	Questa proprietà non è supportata e genera sempre un NotSupportedException.
Position	Questa proprietà non è supportata e genera sempre un NotSupportedException.
ReadTimeout	Ottiene o imposta un valore, espresso in millisecondi, che determina per quanto tempo il flusso tenterà di leggere prima del timeout. (Ereditato da Stream)
WriteTimeout	Ottiene o imposta un valore, espresso in millisecondi, che determina per quanto tempo il flusso tenterà di scrivere prima del timeout. (Ereditato da Stream)

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di lettura asincrona. Prendere in considerazione l'uso del metodo ReadAsync(Byte[], Int32, Int32).
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di scrittura asincrona. Prendere in considerazione l'uso del metodo WriteAsync(Byte[], Int32, Int32).
Close()	Chiude il flusso corrente e rilascia tutte le risorse (ad esempio socket e handle di file) associate al flusso corrente. Invece di chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente. (Ereditato da Stream)
CopyTo(Stream)	Legge i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyTo(Stream, Int32)	Legge i byte dal flusso Deflate corrente e li scrive in un altro flusso, usando una dimensione del buffer specificata.
CopyToAsync(Stream)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del buffer specificata. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Legge in modo asincrono i byte dal flusso Deflate corrente e li scrive in un altro flusso, usando una dimensione del buffer specificata.
CreateObjRef(Type)	Crea un oggetto che contiene tutte le informazioni pertinenti necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleti. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate dal Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate dal DeflateStream e, facoltativamente, rilascia le risorse gestite.
DisposeAsync()	Rilascia in modo asincrono le risorse non gestite usate dal DeflateStream.
EndRead(IAsyncResult)	Attende il completamento della lettura asincrona in sospeso. Prendere in considerazione l'uso del metodo ReadAsync(Byte[], Int32, Int32).
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona. Prendere in considerazione l'uso del metodo WriteAsync(Byte[], Int32, Int32).
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Flush()	L'implementazione corrente di questo metodo non ha funzionalità.
FlushAsync()	Cancella in modo asincrono tutti i buffer per questo flusso e determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da Stream)
FlushAsync(CancellationToken)	Cancella in modo asincrono tutti i buffer per questo flusso Deflate, determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Obsoleti. Fornisce il supporto per un Contract. (Ereditato da Stream)
Read(Byte[], Int32, Int32)	Legge un numero di byte decompressi nella matrice di byte specificata.
Read(Span<Byte>)	Legge una sequenza di byte dal flusso Deflate corrente in un intervallo di byte e sposta in avanti la posizione all'interno del flusso Deflate in base al numero di byte letti.
ReadAsync(Byte[], Int32, Int32)	Legge in modo asincrono una sequenza di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso Deflate corrente, li scrive in una matrice di byte, sposta in avanti la posizione all'interno del flusso Deflate in base al numero di byte letti e monitora le richieste di annullamento.
ReadAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso Deflate corrente, li scrive in un intervallo di memoria di byte, sposta in avanti la posizione all'interno del flusso Deflate in base al numero di byte letti e monitora le richieste di annullamento.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Legge almeno un numero minimo di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Legge in modo asincrono almeno un numero minimo di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da Stream)
ReadByte()	Legge un byte dal flusso Deflate e sposta in avanti la posizione all'interno del flusso di un byte oppure restituisce -1 se alla fine del flusso Deflate.
ReadExactly(Byte[], Int32, Int32)	Legge count numero di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso. (Ereditato da Stream)
ReadExactly(Span<Byte>)	Legge i byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso fino a quando il buffer non viene riempito. (Ereditato da Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono count numero di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso e monitora le richieste di annullamento. (Ereditato da Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente, sposta la posizione all'interno del flusso fino a quando il buffer non viene riempito e monitora le richieste di annullamento. (Ereditato da Stream)
Seek(Int64, SeekOrigin)	Questa operazione non è supportata e genera sempre un NotSupportedException.
SetLength(Int64)	Questa operazione non è supportata e genera sempre un NotSupportedException.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Write(Byte[], Int32, Int32)	Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata.
Write(ReadOnlySpan<Byte>)	Scrive una sequenza di byte nel flusso Deflate corrente e sposta in avanti la posizione corrente all'interno del flusso Deflate in base al numero di byte scritti.
WriteAsync(Byte[], Int32, Int32)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Scrive in modo asincrono i byte compressi nel flusso Deflate sottostante dalla matrice di byte specificata.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Scrive in modo asincrono i byte compressi nel flusso Deflate sottostante dall'area di memoria di sola lettura specificata.
WriteByte(Byte)	Scrive un byte nel flusso Deflate corrente e sposta in avanti di uno la posizione corrente all'interno del flusso Deflate.

Metodi di estensione

CopyToAsync(Stream, PipeWriter, CancellationToken)	Legge in modo asincrono i byte dal Stream e li scrive nel PipeWriterspecificato usando un token di annullamento.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura il modo in cui verranno eseguite le attese nelle attività restituite da un oggetto eliminabile asincrono.

Vedi anche

• letture parziali e zero byte in DeflateStream, GZipStream e CryptoStream