Compresser et décompresser un Flux de Compression.DeflateStream

Je suis en train de compresser et de décompresser un Flux de données à l'aide de La Compression.DeflateStream. La compression semble fonctionner correctement depuis le code ci-dessous compresse mon Flux de 110 octets de long tableau. Cependant, la lecture du Flux décompressé résultats dans 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;
    }
}

Quelqu'un peut m'aider sur ce coup?
Merci beaucoup.

OriginalL'auteur greijner | 2012-05-15

  1. 28

    Fixer votre Compress fonction:

    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();
    }
}

    flux compressé n'a pas été vidé avant de retourner l'résultant du tableau d'octets.

    Les travaux de cette. Merci beaucoup
    Devez appeler que si vous appelez Flush au lieu de Close il ne fonctionne pas. J'ai pensé Close appel Flush à l'interne est pourquoi cela fonctionne, mais non.
    à partir de la documentation de DeflateStream.Flush(): "La mise en œuvre de cette méthode de ne pas vider la mémoire tampon interne. La mémoire tampon interne est vidé lorsque l'objet est supprimé." pourquoi c'est la conception, la Stream.Flush() est prévu pour vider les tampons internes, mais un dégonfler flux ne peut pas être finalisé jusqu'à ce qu'il sait que vous êtes à la fin, ce qui n'est possible que lorsque le flux est fermé.
    Évident rétrospectivement, bien fait.
    J'ai dû ajouter un 3ème paramètre de DeflateStream constructeur pour obtenir que cela fonctionne. new DeflateStream(compressStream, CompressionMode.Compress, true) La bool leaveOpen empêche le flux de mémoire à partir de la fermeture lorsque le compresseur est fermé.

    OriginalL'auteur max

  2. 9

    Essayez de fermer les volets:

    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;
}
}
}
    Je suis en utilisant le même compresser Décompresser fonctions. Décompresser fonctionne très bien, mais le retour de l'objet Stream me donne. Impossible d'accéder à un fermé de Flux. message alors que je suis en train de travailler sur elle. même code fonctionne avant de compresser décompresser fonctions. une idée?

    OriginalL'auteur Darin Dimitrov

  3. 8

    Toutes ces réponses sont loin de l'idéal, car tous vous avez oublié que "l'aide" de l'élimination et de clôture, les flux de ses moyens supplémentaires Close() n'est pas nécessaire. Je pense que l'idéal de code 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;
}
}

    OriginalL'auteur Tymek