C# - Compactando e descompactando Strings

O namespace namespace Sytem.IO.Compression da .NET Framework contém classes para compactar e descompactar streams (arquivos, sequências de caracteres, bytes, etc) fornecendo recursos para realizar tais tarefas de forma bem simples.

Neste artigo eu volto a falar sobre duas classes muito importantes existentes nesse namespace. São elas:

A classe DeflateStream Fornece métodos e propriedades para compactar e descompactar os fluxos usando o algoritmo Deflate.

Essa classe representa o algoritmo Deflate, um algoritmo padrão de mercado para compressão/descompressão de arquivos com poucas perdas. Ele usa uma combinação do algoritmo LZ77 e a codificação de Huffman mas não fornece funcionalidades para incluir ou extrair arquivos ZIP.

A funcionalidade de compressão de ambas as classes são expostas como um stream onde os dados são lidos byte a byte não sendo por isso possível executar várias passagens para determinar o melhor método para compactar arquivos inteiros ou grandes blocos de dados.

O algoritmo DEFLATE é usado nos utilitários que comprimem ou descomprimem arquivos no padrão ZIP ou no padrão gzip. O formato ZIP se tornou popular através do programa PKZIP, e é hoje usado na maioria dos programas de compressão de dados. Esse algoritmo também é usado para comprimir imagens no formato PNG.

Ambas as classes são melhor utilizadas em descompactação de fontes de dados, se as fontes de dados já estiverem compactas elas irão aumentar o tamanho do arquivo stream resultante.

A classe GZipStream fornece métodos e propriedades usadas para compactar e descompactar streams.

Esta classe representa o formato de dados GZip, que usa um algoritmo padrão Compressão e descompactação de arquivos . Esse formato inclui uma verificação de redundância cíclica para a detectar a corrupção de dados. Essa classe o mesmo algoritmo da classe DeflateStream, mas pode ser estendido para usar outros formatos de Compressão.

Nota: Gzip é a abreviação de GNU zip, um Software Livre de compressão sem perda de dados, criado por Jean-loup Gailly e Mark Adler. O programa é baseado no algoritmo DEFLATE. A extensão gerada pelo gzip é o .gz, e seu formato contém apenas um arquivo comprimido. Em sistemas UNIX é comum gerar um arquivo contendo diversos outros arquivos com o programa tar, e depois comprimi-lo com o gzip, gerando um arquivo .tar.gz.

Não confundir com o formato ZIP, que é mais portável e comporta diversos arquivos sem precisar recorrer a um outro programa externo para isso.

Agora vamos a parte prática onde eu vou mostrar como compactar strings usando a classe GZipStream().

Compactando Strings

Abra o Visual C# 2010 Express Edition e crie um novo projeto Windows Forms Application com o nome CompactandoStrings;

No menu Project -> Add Class , informe o nome CompactaTexto para a classe e clique em Add para incluir uma nova classe no projeto;

Defina os seguintes namespaces na classe:

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

A seguir vamos definir dois métodos nesta classe:

O código do método Compacta é dado a seguir:

  public static string Compacta(string text)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(text);
            MemoryStream ms = new MemoryStream();
            using (GZipStream zip = new GZipStream(ms, CompressionMode.Compress, true))
            {
                zip.Write(buffer, 0, buffer.Length);
            }

            ms.Position = 0;
            MemoryStream outStream = new MemoryStream();

            byte[] compressed = new byte[ms.Length];
            ms.Read(compressed, 0, compressed.Length);

            byte[] gzBuffer = new byte[compressed.Length + 4];
            System.Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length);
            System.Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, gzBuffer, 0, 4);
            return Convert.ToBase64String(gzBuffer);
        }

O método Descompacta possui o seguinte código:

 public static string Descompacta(string compressedText)
        {
            byte[] gzBuffer = Convert.FromBase64String(compressedText);
            using (MemoryStream ms = new MemoryStream())
            {
                int msgLength = BitConverter.ToInt32(gzBuffer, 0);
                ms.Write(gzBuffer, 4, gzBuffer.Length - 4);

                byte[] buffer = new byte[msgLength];

                ms.Position = 0;
                using (GZipStream zip = new GZipStream(ms, CompressionMode.Decompress))
                {
                    zip.Read(buffer, 0, buffer.Length);
                }
                return Encoding.UTF8.GetString(buffer);
            }
        }

Dessa forma já temos a classe com os métodos que vamos usar para compactar e descompactar textos usando a classe GZipStream;

Vamos voltar ao formulário form1.cs e incluir 3 caixas de texto e 3 Button conforme o leiaute da figura abaixo:

O código definido nos botões de comando é o seguinte:

private void btnCompactaString_Click(object sender, System.EventArgs e)
{
     txtTextoCompactado.Text = CompactaTexto.Compacta(txtTexto.Text);
}

private void btnDescompactaString_Click(object sender, System.EventArgs e)
{
    txtTextoDescompactado.Text = CompactaTexto.Descompacta(txtTextoCompactado.Text);
}

Executando o projeto e informando um texto para ser compactado, ao clicar no botão Compactar String vemos o resultado conforme abaixo:

Simples, simples assim...

Pegue o projeto completo aqui: CompactandoStrings.zip

Eu sei é apenas C#, mas eu gosto...

Referências:

José Carlos Macoratti