[erledigt] String Compress: Welche Variante ist perfomanter/besser?

Hallo Leute 😃

Kann mir jemand sagen was perfomanter/besser ist ?
(Man nehme an beide Varianten geben Base65 oder UTF8 zurück (irrelevant))

**Variante 1 😗*

 private string CompressString(string inputString)
        {
            byte[] outputBytes = null;
            byte[] inputBytes = AsciiEncoding.GetBytes(inputString);

            using (var ms = new MemoryStream())
            {
                using (var zipStream = new GZipStream(ms, CompressionMode.Compress))
                {
                    zipStream.Write(inputBytes, 0, inputBytes.Length);
                }
                outputBytes = ms.ToArray();
            }

            return Convert.ToBase64String(AddDataCount(outputBytes, inputBytes.Length));
        }

        private string DecompressString(string inputString)
        {
            string outputString = String.Empty;
            byte[] inputBytes = Convert.FromBase64String(inputString);
            Int32 lengthDataArray = BitConverter.ToInt32(inputBytes, inputBytes.Length - LengthDataByteCount);
            var outputBytes = new byte[lengthDataArray];

            using (var ms = new MemoryStream(RemoveDataCount(inputBytes)))
            {
                using (var zipStream = new GZipStream(ms, CompressionMode.Decompress))
                {
                    zipStream.Read(outputBytes, 0, outputBytes.Length);
                }
                outputString = AsciiEncoding.GetString(outputBytes);
            }

            return outputString;
        }

**Variante 2 😗*

 public static byte[] Zip(string str)
        {
            var bytes = Encoding.UTF8.GetBytes(str);

            using (var msi = new MemoryStream(bytes))
            using (var mso = new MemoryStream())
            {
                using (var gs = new GZipStream(mso, CompressionMode.Compress))
                {
                    msi.CopyTo(gs);
                }

                return mso.ToArray();
            }
        }

        public static string Unzip(byte[] bytes)
        {
            using (var msi = new MemoryStream(bytes))
            using (var mso = new MemoryStream())
            {
                using (var gs = new GZipStream(msi, CompressionMode.Decompress))
                {
                    gs.CopyTo(mso);
                }

                return Encoding.UTF8.GetString(mso.ToArray());
            }
        }

Besten Dank und beste Grüsse

Diräkt

Was hält Dich davon ab ein Performance Test zu machen?

Besser oder schlechter ist wohl Geschmackssache.. ich finde die untere übersichtlicher, obwohl da ja noch die Convertierung zu base64 fehlt im Vergleich zur oberen.

Schliesse mich unconnected an. Mach nen Performance test, wenn es dir um die Performance geht.
Wenn es dir um das Datenvolumen geht, ist der Ansatz mit Base64 eher kontraproduktiv, da dadurch das Datenvolumen um etwa 1/3 erhöht wird.
Es kommt natürlich auch drauf an, in welchem Format du die komprimierten Daten dann speicherst (string, byte[] etc.). Wenn es ein string sein muss, dann wäre Base64 die option.

Hallo unconnected,
Hallo Sarc

Besten Dank für Eure Mitteilungen.

Mach nen Performance test, wenn es dir um die Performance geht.

Damit ich nicht Äpfel mit Birnen vergleiche habe ich beides getestet :

=> Test 1:

Beide Compress methoden geben ein String zurück, 10'000 Compress ; Decompress:

Variante 1 :

10'000 Tests => 00:00:00.3196391

Variante 2 :

10'000 Tests => 00:00:00.4225765

=> Test 2:

Beide Compress methoden geben ein byte[] zurück, 10'000 Compress ; Decompress:

Variante 1 :

10'000 Tests => 00:00:00.3111186

Variante 2 :

10'000 Tests => 00:00:00.4206573

Somit werde ich wohl Variante 1 benutzen 😃 (die mit byte[] so aussieht:)

private byte[] CompressString(string inputString)
        {
            byte[] outputBytes = null;
            byte[] inputBytes = AsciiEncoding.GetBytes(inputString);

            using (var ms = new MemoryStream())
            {
                using (var zipStream = new GZipStream(ms, CompressionMode.Compress))
                {
                    zipStream.Write(inputBytes, 0, inputBytes.Length);
                }
                outputBytes = ms.ToArray();
            }

            return outputBytes;
        }

        private string DecompressString(byte[] inputBytes)
        {
            string outputString = String.Empty;
            Int32 lengthDataArray = BitConverter.ToInt32(inputBytes, inputBytes.Length - LengthDataByteCount);
            var outputBytes = new byte[lengthDataArray];

            using (var ms = new MemoryStream(inputBytes))
            {
                using (var zipStream = new GZipStream(ms, CompressionMode.Decompress))
                {
                    zipStream.Read(outputBytes, 0, outputBytes.Length);
                }
                outputString = AsciiEncoding.GetString(outputBytes);
            }

            return outputString;
        }

Beste Grüsse

Diräkt

Wenn es dir rein um Performance geht, solltest du den DeflateStream im Vergleich zum GZipStream untersuchen. Die Compression beim DeflateStream scheint deutlich schneller zu sein: GZip vs. Deflate - Compression and Performance