An Easy-to-Use and Optimized compression library for .NET that unified several compression algorithms including LZ4, Snappy, Zstd, LZMA, Brotli, GZip, ZLib, and Deflate.
This library aids in Improving Performance by Reducing Memory Usage and Bandwidth Usage.
<img src="/src/EasyCompressor.png" width="100" height="100" align="left"/>An Easy-to-Use and Optimized compression library for .NET that unified several compression algorithms including LZ4, Snappy, Zstd, LZMA, Brotli, GZip, ZLib, and Deflate.
Compress your BLOB data for Archiving and Saving the Storage (on average from 30% to 90%)
Compress your Caching objects for Saving the Memory Usage (it also has a nice integration with EasyCaching)
Reduce the Bandwidth Usage of your network by reducing the volume of data sent or received. (see How)
Improve the Performance of your I/O Operations like Service-to-Service Communication. (see How)
Features
Offers a range of compression algorithms, including LZ4, Snappy, Zstd, LZMA, Brotli, GZip, ZLib, and Deflate.
Support for async/await operations with support of CancellationToken.
Stream operations are fully supported.
Optimized and implemented with a focus on performance.
Note
The default comparison levels are carefully configured based on extensive benchmarking to ensure the highest level of efficiency and speed at a reasonable compression ratio.
Improving Data Transfer Speed by Sending/Receiving Less
Compression/Decompression has overhead but it reduces the size of your data, which can potentially result in faster transfer times, even when accounting for the additional time required for compression and decompression.
When a file is compressed, it becomes smaller in size, which means it requires less bandwidth to transfer. If the compression ratio is significant, the reduced file size can compensate for the extra time needed for compression and decompression.
For example, let's say you have an uncompressed file that takes 10 seconds to transfer. If you compress this file using a fast compressor like LZ4, Snappy, or Zstd, the compression time might be around 1 second. However, the compressed file size is significantly smaller, let's say it's only 20% of the original size. Now, when you transfer the compressed file, it will only take 2 seconds (20% of the original transfer time). In this scenario, the total time (compression time + transfer time) would be 3 seconds (1 second for compression + 2 seconds for transfer), which is less than the original 10 seconds it would have taken to transfer the uncompressed file.
It's important to note that the actual time savings will depend on various factors, such as the compression ratio achieved, the speed of the compression and decompression algorithms, the network bandwidth, and other system-specific considerations. However, with fast compressors like LZ4, Snappy, or Zstd and significant compression ratios, it is possible to achieve overall time savings when transferring compressed files compared to transferring uncompressed files.
Including Algorithms :<br/>- Brotli (Highest compression ratio - the Smallest size) (Only available in .NETCoreApp2.1, .NETStandard2.1 and above)<br/>- GZip<br/>- Deflate<br/>- ZLib (Only available in .NET6.0 and above)
Instead, use BrotliCompressor in EasyCompressor itself (base package)<br/>(Use only if your project targets .NETFramework462 and above or .NETCoreApp2.0)
A winning combination by integrating with EasyCaching to compress your cache data. (Recommended)<br/>See How to use
Note :
All of these packages are cross-platform except EasyCompressor.Zstd and EasyCompressor.Snappy which are not cross-platform because their underlying library are just a wrapper around the native dlls only for windows.
using EasyCompressor;
public class YourClass
{
private readonly ICompressor _compressor;
public YourClass(ICompressor compressor) //Inject using dependency injection
{
_compressor = compressor;
//Or resolve it using IServiceProvider
//_compressor = serviceProvider.GetService<ICompressor>()
}
public void ProcessData(byte[] bytes)
{
// Compress your original byte[] and return compressed byte[]
var compressedBytes = _compressor.Compress(bytes);
// Decompress compressed byte[] and return uncompressed byte[]
var uncompressedBytes = _compressor.Decompress(compressedBytes);
}
public void ProcessStream(Stream input, stream output)
{
// Read input stream and Compress into output stream
_compressor.Compress(input, output);
// Read input stream and Decompress into output stream
_compressor.Decompress(input, output);
}
}
The default compression levels have changed and are carefully configured based on extensive benchmarking to ensure the highest level of efficiency and speed at a reasonable compression ratio.
Three new LZ4 binary compression modes added:
LZ4BinaryCompressionMode.Optimal (new Default mode)
Default compression mode. (NOT compatible with other modes neither LegacyCompatible nor StreamCompatible modes)
But it's fast and most efficient in memory allocation. (Best Performance overall - Fast_GCEfficient)
It applies only to binary Compress/Decompress and does not affect Stream/Stream[Async] methods.
LZ4BinaryCompressionMode.LegacyCompatible (legacy Default mode)
Legacy compatibility with old/legacy versions. (NOT compatible with other modes neither StreamCompatible nor Optimal modes)
It's the fastest mode (a bit faster than Optimal) but less efficient in memory allocation. (Fast_GCInefficient)
It prepends 4 bytes to the beginning of the array to define the original array length.
It applies only to binary Compress/Decompress and does not affect Stream/Stream[Async] methods.
LZ4BinaryCompressionMode.StreamCompatible
StreamCompatible which is compatible with Stream's output. (NOT compatible with other modes neither LegacyCompatible nor Optimal modes)
It's slower than other modes but moderate in memory allocation. (Slow_GCModerated)
