web-dev-qa-db-fra.com

Compressez et décompressez un flux avec Compression.DeflateStream

J'essaie de compresser et de décompresser un flux en utilisant Compression.DeflateStream . La compression semble fonctionner correctement puisque le code ci-dessous compresse mon Stream dans un tableau de 110 octets de long. Cependant, la lecture du flux décompressé entraîne une chaîne vide.

class Program
{
    static void Main(string[] args)
    {
        // Compress a random string value
        string value = Path.GetRandomFileName();
        byte[] compressedBytes;

        using (var writer = new StreamWriter(new MemoryStream()))
        {
            writer.Write(value);
            writer.Flush();
            writer.BaseStream.Position = 0;

            compressedBytes = Compress(writer.BaseStream);
        }

        // Decompress compressed bytes
        Stream decompressedStream = Decompress(compressedBytes);
        // here already applies: decompressedStream.Length == 0

        using (var reader = new StreamReader(decompressedStream))
        {
            string decompressedValue = reader.ReadToEnd();

            if (value == decompressedValue)
                Console.WriteLine("Success");
            else
                Console.WriteLine("Failed");
        }
    }

    private static byte[] Compress(Stream input)
    {
        using (var compressStream = new MemoryStream())
        using (var compressor = new DeflateStream(compressStream, CompressionMode.Compress))
        {
            input.CopyTo(compressor);
            return compressStream.ToArray();
        }
    }

    private static Stream Decompress(byte[] input)
    {
        var output = new MemoryStream();

        using (var compressStream = new MemoryStream(input))
        using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
            decompressor.CopyTo(output);

        output.Position = 0;
        return output;
    }
}

Quelq'un peut-il m'aider avec cela? Merci beaucoup.

19
greijner

Corrigez votre fonction Compress:

private static byte[] Compress(Stream input)
{
    using(var compressStream = new MemoryStream())
    using(var compressor = new DeflateStream(compressStream, CompressionMode.Compress))
    {
        input.CopyTo(compressor);
        compressor.Close();
        return compressStream.ToArray();
    }
}

le flux compressé n'a pas été vidé avant de renvoyer le tableau d'octets résultant.

31
max

Essayez de fermer les flux:

class Program
{
    static void Main(string[] args)
    {
        // Compress a random string value
        string value = DateTime.Now.ToLongTimeString();
        byte[] compressedBytes;

        using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(value)))
        {
            compressedBytes = Compress(stream);
        }


        // Decompress compressed bytes
        using (var decompressedStream = Decompress(compressedBytes))
        using (var reader = new StreamReader(decompressedStream))
        {
            string decompressedValue = reader.ReadToEnd();

            if (value == decompressedValue)
                Console.WriteLine("Success");
            else
                Console.WriteLine("Failed");
        }
    }

    public static byte[] Compress(Stream input)
    {
        using (var compressedStream = new MemoryStream())
        using (var zipStream = new GZipStream(compressedStream, CompressionMode.Compress))
        {
            input.CopyTo(zipStream);
            zipStream.Close();
            return compressedStream.ToArray();
        }
    }

    public static Stream Decompress(byte[] data)
    {
        var output = new MemoryStream();
        using(var compressedStream = new MemoryStream(data))
        using(var zipStream = new GZipStream(compressedStream, CompressionMode.Decompress))
        {
            zipStream.CopyTo(output);
            zipStream.Close();
            output.Position = 0;
            return output;
        }
    }
}
11
Darin Dimitrov

Toutes ces réponses sont loin d'être idéales car vous avez tous oublié que "l'utilisation" de la suppression et de la fermeture des flux signifie que Close () supplémentaire n'est pas nécessaire. Je pense que le code idéal sera comme ceci:

public static class CompressionHelper
{
    public static byte[] Compress(byte[] data)
    {
        byte[] compressArray = null;
        try
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress))
                {
                    deflateStream.Write(data, 0, data.Length);
                }
                compressArray = memoryStream.ToArray();
            }
        }
        catch (Exception exception)
        {
            // do something !
        }
        return compressArray;
    }

    public static byte[] Decompress(byte[] data)
    {
        byte[] decompressedArray = null;
        try
        {
            using (MemoryStream decompressedStream = new MemoryStream())
            {
                using (MemoryStream compressStream = new MemoryStream(data))
                {
                    using (DeflateStream deflateStream = new DeflateStream(compressStream, CompressionMode.Decompress))
                    {
                        deflateStream.CopyTo(decompressedStream);
                    }
                }
                decompressedArray = decompressedStream.ToArray();
            }
        }
        catch (Exception exception)
        {
            // do something !
        }

        return decompressedArray;
    }
}
8
Tymek