GrindCore.SharpCompress 0.48.0

GrindCore.SharpCompress

GrindCore.SharpCompress is an enhanced version of SharpCompress that integrates GrindCore native compression. This project delivers native compression support built using the System.IO.Compression pattern, utilizing compression algorithms directly from their original C implementations.

This fork replaces GZip, LZMA, Deflate, ZStandard, LZ4, and Brotli implementations with native C streams from GrindCore, providing significant performance improvements while maintaining full API compatibility.

Based on SharpCompress 0.48.0 — includes all upstream features plus native compression.

For more in-depth information, see .

Installation

<PackageReference Include="GrindCore.SharpCompress" Version="0.48.0" />

Format Support

Compression Algorithms

Key Features

Native Compression via GrindCore

• Native C implementations compiled from original algorithm authors' code
• No external DLL dependencies — native libraries bundled per platform
• Multiplatform: Windows (x64/x86/ARM64), Linux (x64/ARM64/ARM), macOS (x64/ARM64)
• AOT/Trimming compatible on .NET 8+

7-Zip Writing (New in 0.48.0)

• SevenZipWriter for creating 7z archives with LZMA or LZMA2 compression
• Non-solid mode (each file compressed independently)
• Async writing support via WriterFactory.OpenAsyncWriter
• Requires seekable output stream

Archive Detection API (New in 0.48.0)

• ArchiveFactory.GetArchiveInformation() — detect archive type without fully opening
• Consolidated factory helpers for format detection

PooledMemoryStream (New in 0.48.0)

• ArrayPool<byte>-backed memory stream for reduced GC pressure
• Used internally for 7zip writing and CRC computation

Zip-Slip Protection (New in 0.48.0)

• Path traversal protection on extraction
• Consolidated extraction options via ExtractionOptions

Stream APIs

• Archive API: Random access with seekable streams (ZipArchive, TarArchive, SevenZipArchive, etc.)
• Reader API: Forward-only reading on non-seekable streams (ZipReader, TarReader, etc.)
• Writer API: Forward-only writing (ZipWriter, TarWriter, SevenZipWriter, etc.)
• Full async/await support with CancellationToken throughout
• Auto-detection via ReaderFactory.OpenReader() / ArchiveFactory.OpenArchive()

LZMA2 Modes

• Block Mode: Configurable block sizes for compression/speed balance
• Solid Mode: Maximum compression (CompressionBufferSize = -1)

Framework Support

• .NET 10, 9, 8, 7, 6, 5
• .NET Standard 2.1, 2.0
• .NET Framework 4.8, 4.8.1
• NativeAOT compatible (.NET 8+)

Performance

GrindCore native implementations provide measurable improvements over managed C#:

• Deflate/GZip: 3-5x faster than managed implementation
• LZ4: 400+ MB/s compression, 1500+ MB/s decompression
• ZStandard Level 6: 100+ MB/s compression, 400+ MB/s decompression
• LZMA2 Solid: 95%+ compression ratio on text data
• Brotli Level 9: Excellent web compression with 85%+ ratio on text

Native implementations leverage modern CPU instruction sets (AVX2, SSE4) where available.

Migration from SharpCompress

This is a drop-in replacement. Change your package reference:

<PackageReference Include="SharpCompress" Version="0.48.0" />


<PackageReference Include="GrindCore.SharpCompress" Version="0.48.0" />

No code changes required. Existing SharpCompress code benefits from native performance automatically.

Usage Examples

// Write a ZIP with ZStandard compression
var options = new WriterOptions(CompressionType.ZStandard) { CompressionLevel = 6 };
using var writer = WriterFactory.OpenWriter(outputStream, ArchiveType.Zip, options);
writer.Write("file.txt", inputStream, DateTime.Now);

// Write a 7zip archive with LZMA2
var options7z = new WriterOptions(CompressionType.LZMA2) { CompressionLevel = 9 };
using var writer7z = WriterFactory.OpenWriter(outputStream, ArchiveType.SevenZip, options7z);
writer7z.Write("data.bin", inputStream, DateTime.Now);

// LZMA2 Solid Mode for maximum compression
var solidOptions = new WriterOptions(CompressionType.LZMA2)
{
    CompressionBufferSize = -1 // Solid mode
};

// Read any archive format (auto-detect)
using var archive = ArchiveFactory.OpenArchive(inputStream);
foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
{
    entry.WriteToDirectory(outputDir);
}

Architecture

GrindCore.SharpCompress.dll
  → GrindCore.net.dll (.NET stream wrappers)
    → GrindCore.dll (Native C library)

When UseGrindCore=true (default), native stream implementations replace the managed ones at compile time. Set UseGrindCore=false to build with pure managed implementations (matching upstream SharpCompress behaviour).

Documentation

• Supported Formats
• Basic Usage
• API Reference
• Architecture
• Performance

Related Projects

• GrindCore: Multiplatform native C compression library
• GrindCore.net: .NET wrapper for GrindCore (.NET Framework 3.5 through .NET 10)
• GrindCore NuGet: Standalone GrindCore package
• SharpCompress: The upstream library this fork enhances

Contributing

Contributions welcome. Areas of interest:

• Performance benchmarking
• Platform-specific testing
• Additional native algorithm integration (BZip2, PPMd)
• Real-world usage feedback

Please use GitHub issues for support requests.

License

MIT License — same as the original SharpCompress project. Native libraries are licensed as specified in GrindCore documentation.