DeflateStream Osztály

Definíció

Névtér:

System.IO.Compression

Szerelvények:

netstandard.dll, System.IO.Compression.dll

Forrás:

DeflateStream.cs

Metódusokat és tulajdonságokat biztosít a streamek tömörítéséhez és tömörítéséhez a Deflate algoritmus használatával.

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

public class DeflateStream : System.IO.Stream

type DeflateStream = class
    inherit Stream

Public Class DeflateStream
Inherits Stream

Öröklődés

Object

MarshalByRefObject

Stream

DeflateStream

Példák

Az alábbi példa bemutatja, hogyan használható az osztály egy DeflateStream fájl tömörítésére és kibontására.

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

Megjegyzések

Ez az osztály a Deflate algoritmust jelöli, amely egy iparági szabványnak megfelelő algoritmus a veszteségmentes fájltömörítéshez és a tömörítéshez. A .NET Framework 4.5-től kezdve a DeflateStream osztály a zlib könyvtárat használja. Ennek eredményeképpen jobb tömörítési algoritmust és a legtöbb esetben kisebb tömörített fájlt biztosít, mint a .NET Framework korábbi verzióiban.

Ez az osztály eredendően nem biztosít funkciókat fájlok zip-archívumokhoz való hozzáadásához vagy kinyeréséhez. A zip archívumok használatához használja az osztályokat és az ZipArchiveZipArchiveEntry osztályokat.

Az DeflateStream osztály ugyanazt a tömörítési algoritmust használja, mint az osztály által GZipStream használt gzip adatformátum.

A tömörítési funkció streamként DeflateStreamGZipStream van közzétéve. Az adatok bájtonként olvashatók, így nem lehet több bérletet végrehajtani a teljes fájlok vagy nagy méretű adatblokkok tömörítésének legjobb módszerének meghatározásához. Az DeflateStream osztályokat és GZipStream az osztályokat leginkább tömörítetlen adatforrásokon használják. Ha a forrásadatok már tömörítve vannak, ezek az osztályok ténylegesen növelhetik a stream méretét.

A DeflateStream által visszaadott pontos tömörített bájtsorozat .NET kiadások, platformok és mögöttes tömörítési motorok között változhat. A zlib-verziók, az algoritmusok finomhangolása és a teljesítményoptimalizálás változásai eltérő kimeneteket eredményezhetnek ugyanahhoz a bemeneti adathoz. A tömörített DeflateStream adatok azonban mindig az eredeti formájukba bonthatók veszteség nélkül.

Konstruktorok

Name	Description
DeflateStream(Stream, CompressionLevel, Boolean)	Inicializálja az osztály új példányát a DeflateStream megadott stream- és tömörítési szinttel, és opcionálisan nyitva hagyja a streamet.
DeflateStream(Stream, CompressionLevel)	Inicializálja az osztály új példányát a DeflateStream megadott stream- és tömörítési szinttel.
DeflateStream(Stream, CompressionMode, Boolean)	Inicializálja az osztály új példányát a DeflateStream megadott stream- és tömörítési móddal, és opcionálisan nyitva hagyja a streamet.
DeflateStream(Stream, CompressionMode)	Inicializálja az osztály új példányát a DeflateStream megadott stream- és tömörítési móddal.
DeflateStream(Stream, ZLibCompressionOptions, Boolean)	Inicializálja az osztály új példányát a DeflateStream megadott stream, tömörítési beállítások használatával, és opcionálisan nyitva hagyja a streamet.

Tulajdonságok

Name	Description
BaseStream	Lekéri a mögöttes streamre mutató hivatkozást.
CanRead	Egy értéket kap, amely jelzi, hogy a stream támogatja-e az olvasást egy fájl kibontása közben.
CanSeek	Egy értéket kap, amely jelzi, hogy a stream támogatja-e a keresést.
CanTimeout	Olyan értéket kap, amely meghatározza, hogy az aktuális stream időtúllépést okozhat-e. (Öröklődés forrása Stream)
CanWrite	Értéket kap, amely jelzi, hogy a stream támogatja-e az írást.
Length	Ez a tulajdonság nem támogatott, és mindig egy NotSupportedException.
Position	Ez a tulajdonság nem támogatott, és mindig egy NotSupportedException.
ReadTimeout	Ezredmásodpercben lekéri vagy beállítja azt az értéket, amely meghatározza, hogy a stream mennyi ideig kísérel meg olvasni, mielőtt túllépi az időkorlátot. (Öröklődés forrása Stream)
WriteTimeout	Ezredmásodpercben lekéri vagy beállít egy értéket, amely meghatározza, hogy a stream mennyi ideig kísérel meg írni, mielőtt időtúllépést végezne. (Öröklődés forrása Stream)

Metódusok

Name	Description
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Aszinkron olvasási műveletet kezd. (Fontolja meg inkább a ReadAsync(Byte[], Int32, Int32) metódus használatát.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Aszinkron írási műveletet kezd. (Fontolja meg inkább a WriteAsync(Byte[], Int32, Int32) metódus használatát.)
Close()	Bezárja az aktuális streamet, és felszabadítja az aktuális adatfolyamhoz társított összes erőforrást (például szoftvercsatornákat és fájlfogópontokat). A metódus meghívása helyett győződjön meg arról, hogy a stream megfelelően van elosztva. (Öröklődés forrása Stream)
CopyTo(Stream, Int32)	Beolvassa a bájtokat az aktuális deflátumfolyamból, és egy megadott pufferméret használatával egy másik streambe írja őket.
CopyTo(Stream)	Beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy megadott lemondási jogkivonat használatával egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális deflátumfolyamból, és egy megadott puffermérettel egy másik streambe írja őket.
CopyToAsync(Stream, Int32)	Aszinkron módon beolvassa a bájtokat az aktuális adatfolyamból, és egy megadott puffermérettel egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CreateWaitHandle()	Elavult. Objektum lefoglalása WaitHandle . (Öröklődés forrása Stream)
Dispose()	Felszabadítja a .-hez használt összes erőforrást Stream. (Öröklődés forrása Stream)
Dispose(Boolean)	Felszabadítja a felügyelt erőforrások által DeflateStream használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
DisposeAsync()	Aszinkron módon felszabadítja a nem felügyelt erőforrásokat, amelyeket a DeflateStream.
EndRead(IAsyncResult)	Megvárja, amíg a függőben lévő aszinkron olvasás befejeződik. (Fontolja meg inkább a ReadAsync(Byte[], Int32, Int32) metódus használatát.)
EndWrite(IAsyncResult)	Aszinkron írási művelet befejezése. (Fontolja meg inkább a WriteAsync(Byte[], Int32, Int32) metódus használatát.)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Flush()	Kiüríti a belső puffert a mögöttes adatfolyamba.
FlushAsync()	Aszinkron módon törli az adatfolyam összes pufferét, és a pufferelt adatokat a mögöttes eszközre írja. (Öröklődés forrása Stream)
FlushAsync(CancellationToken)	Aszinkron módon törli a deflátumfolyam összes pufferét, a pufferelt adatokat a mögöttes eszközre írja, és figyeli a lemondási kérelmeket.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Elavult. Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Elavult. Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
ObjectInvariant()	Elavult. Támogatja a Contract. (Öröklődés forrása Stream)
Read(Byte[], Int32, Int32)	Több tömörített bájtot olvas be a megadott bájttömbbe.
Read(Span<Byte>)	Az aktuális deflátumfolyam bájtsorozatát beolvassa bájttartományba, és az olvasási bájtok számával növeli a deflátumfolyamon belüli pozíciót.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtok sorozatát az aktuális deflátumfolyamból, beírja őket egy bájttömbbe, a deflátumfolyamon belüli pozíciót az olvasási bájtok számával növeli, és figyeli a lemondási kérelmeket.
ReadAsync(Byte[], Int32, Int32)	Aszinkron módon beolvassa az aktuális adatfolyamból származó bájtok sorozatát, és az olvasási bájtok számával előrelépteti a streamen belüli pozíciót. (Öröklődés forrása Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Aszinkron módon beolvassa a bájtok sorozatát az aktuális Deflate streamből, beírja őket egy bájtos memóriatartományba, a deflátumfolyamon belüli pozíciót az olvasási bájtok számával növeli, és figyeli a lemondási kérelmeket.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Legalább egy bájtot olvas be az aktuális adatfolyamból, és az olvasási bájtok számával előrelép a streamen belül. (Öröklődés forrása Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Aszinkron módon legalább egy minimális bájtszámot olvas be az aktuális streamből, az olvasási bájtok számával előrelép a streamen belül, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
ReadByte()	Beolvas egy bájtot a Deflate streamből, és egy bájttal növeli a streamen belüli pozíciót, vagy -1 ad vissza, ha a deflátumfolyam végén van.
ReadExactly(Byte[], Int32, Int32)	Beolvassa a bájtok count számát az aktuális streamből, és előrelép a streamen belüli pozíción. (Öröklődés forrása Stream)
ReadExactly(Span<Byte>)	Beolvassa a bájtokat az aktuális adatfolyamból, és a streamen belüli pozíciót a feltöltésig buffer előrelépteti. (Öröklődés forrása Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtok count számát az aktuális streamből, előrelép a streamben, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális adatfolyamból, a streamen belüli pozíciót a feltöltésig buffer , és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
Seek(Int64, SeekOrigin)	Ez a művelet nem támogatott, és mindig egy NotSupportedException.
SetLength(Int64)	Ez a művelet nem támogatott, és mindig egy NotSupportedException.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
Write(Byte[], Int32, Int32)	Tömörített bájtokat ír a mögöttes adatfolyamba a megadott bájttömbből.
Write(ReadOnlySpan<Byte>)	Bájtok sorozatát írja az aktuális deflátumfolyamba, és a megírt bájtok számával növeli a deflátumfolyam aktuális pozícióját.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon tömörített bájtokat ír a mögöttes deflátumfolyamba a megadott bájttömbből.
WriteAsync(Byte[], Int32, Int32)	Aszinkron módon bájtok sorozatát írja az aktuális adatfolyamba, és a megírt bájtok számával előrelépteti a stream aktuális pozícióját. (Öröklődés forrása Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Aszinkron módon tömörített bájtokat ír a mögöttes Deflate streambe a megadott írásvédett memóriarégióból.
WriteByte(Byte)	Bájtot ír az aktuális deflátumfolyamra, és egy lépéssel előrelép a deflátumfolyam aktuális pozícióján.

Bővítő metódusok

Name	Description
ConfigureAwait(IAsyncDisposable, Boolean)	Konfigurálja, hogy az aszinkron eldobható feladatok hogyan lesznek végrehajtva.
CopyToAsync(Stream, PipeWriter, CancellationToken)	Aszinkron módon beolvassa a bájtokat a Stream megadottból, és egy lemondási jogkivonat használatával írja őket a megadottba PipeWriter.

Lásd még

• Részleges és nulla bájtos olvasások a DeflateStreamben, a GZipStreamben és a CryptoStreamben