internal static byte[] Compression(byte[] data, int offset, int count)
{
if (null == data)
{
throw new ArgumentNullException(nameof(data));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset), "Non-negative number required.");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), "Non-negative number required.");
}
if (data.Length - offset < count)
{
throw new ArgumentException("Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.");
}
using (var pooledOutputStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledOutputStream.Object;
outputStream.Reinitialize(count);
#if NET40
using (var gzWriter = new GZipStream(outputStream, CompressionMode.Compress, true))
#else
using (var gzWriter = new GZipStream(outputStream, CompressionLevel.Fastest, true))
#endif
{
gzWriter.Write(data, offset, count);
}
return(outputStream.ToByteArray());
}
}
/// <summary>Serializes the specified item.</summary>
/// <param name="formatter">The formatter.</param>
/// <param name="item">The item.</param>
/// <param name="serializerSettings">The <see cref="JsonSerializerSettings"/> used to configure the <see cref="JsonSerializer"/>.</param>
/// <param name="effectiveEncoding">The encoding.</param>
/// <param name="initialBufferSize">The initial buffer size.</param>
/// <returns></returns>
public static ArraySegment <byte> WriteToMemoryPool(this IJsonMessageFormatter formatter, object item,
JsonSerializerSettings serializerSettings, Encoding effectiveEncoding = null, int initialBufferSize = c_initialBufferSize)
{
//#if NET40
using (var pooledStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledStream.Object;
outputStream.Reinitialize(initialBufferSize, BufferManager.Shared);
formatter.WriteToStream(item?.GetType(), item, outputStream, effectiveEncoding, serializerSettings);
return(outputStream.ToArraySegment());
}
//#else
// using (var pooledPipe = PipelineManager.Create())
// {
// var pipe = pooledPipe.Object;
// var outputStream = new PipelineStream(pipe, initialBufferSize);
// formatter.WriteToStream(item?.GetType(), item, outputStream, effectiveEncoding, serializerSettings);
// pipe.Flush();
// var readBuffer = pipe.Reader.ReadAsync().GetResult().Buffer;
// var length = (int)readBuffer.Length;
// if (c_zeroSize == length) { return s_emptySegment; }
// var buffer = BufferManager.Shared.Rent(length);
// readBuffer.CopyTo(buffer);
// return new ArraySegment<byte>(buffer, 0, length);
// }
//#endif
}
internal static ArraySegmentWrapper <byte> Decompression(byte[] compressedData, int offset, int count, BufferManager bufferManager)
{
if (null == bufferManager)
{
throw new ArgumentNullException(nameof(bufferManager));
}
using (var inputStream = new MemoryStream(compressedData, offset, count))
{
var bufferSize = count * 2;
var buffer = bufferManager.TakeBuffer(bufferSize);
try
{
using (var gzReader = new GZipStream(inputStream, CompressionMode.Decompress))
using (var pooledOutputStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledOutputStream.Object;
outputStream.Reinitialize(bufferSize, bufferManager);
var readBytes = 0;
while ((readBytes = gzReader.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, readBytes);
}
return(outputStream.ToArraySegment());
}
}
finally
{
bufferManager.ReturnBuffer(buffer);
}
}
}
internal static ArraySegmentWrapper <byte> Compression(byte[] data, BufferManager bufferManager)
{
if (null == data)
{
throw new ArgumentNullException(nameof(data));
}
if (null == bufferManager)
{
throw new ArgumentNullException(nameof(bufferManager));
}
using (var pooledOutputStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledOutputStream.Object;
outputStream.Reinitialize(data.Length, bufferManager);
#if NET40
using (var gzWriter = new GZipStream(outputStream, CompressionMode.Compress, true))
#else
using (var gzWriter = new GZipStream(outputStream, CompressionLevel.Fastest, true))
#endif
{
gzWriter.Write(data, 0, data.Length);
}
return(outputStream.ToArraySegment());
}
}
internal static byte[] Decompression(byte[] compressedData)
{
if (null == compressedData)
{
throw new ArgumentNullException(nameof(compressedData));
}
var bufferManager = BufferManager.GlobalManager;
var bufferSize = compressedData.Length * 2;
var buffer = bufferManager.TakeBuffer(bufferSize);
try
{
using (var inputStream = new MemoryStream(compressedData, 0, compressedData.Length))
using (var gzReader = new GZipStream(inputStream, CompressionMode.Decompress))
using (var pooledOutputStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledOutputStream.Object;
outputStream.Reinitialize(bufferSize, bufferManager);
var readBytes = 0;
while ((readBytes = gzReader.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, readBytes);
}
return(outputStream.ToByteArray());
}
}
finally
{
bufferManager.ReturnBuffer(buffer);
}
}
internal static byte[] Decompression(byte[] compressedData, int offset, int count)
{
using (var inputStream = new MemoryStream(compressedData, offset, count))
{
var bufferManager = BufferManager.GlobalManager;
var bufferSize = count * 2;
var buffer = bufferManager.TakeBuffer(bufferSize);
try
{
using (var gzReader = new GZipStream(inputStream, CompressionMode.Decompress))
using (var pooledOutputStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledOutputStream.Object;
outputStream.Reinitialize(bufferSize, bufferManager);
var readBytes = 0;
while ((readBytes = gzReader.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, readBytes);
}
return(outputStream.ToByteArray());
}
}
finally
{
bufferManager.ReturnBuffer(buffer);
}
}
}
/// <summary>Serializes the specified object to a JSON string using a type, formatting and <see cref="JsonSerializer"/>.</summary>
/// <param name="jsonSerializerPool">The <see cref="JsonSerializer"/> pool used to serialize the object</param>
/// <param name="value">The object to serialize.</param>
/// <param name="type">The type of the value being serialized.
/// This parameter is used when <see cref="JsonSerializer.TypeNameHandling"/> is <see cref="TypeNameHandling.Auto"/> to write out the type name if the type of the value does not match.
/// Specifying the type is optional.</param>
/// <param name="initialBufferSize"></param>
/// <returns>A JSON string representation of the object.</returns>
public static ArraySegment <byte> SerializeToMemoryPool(this ObjectPool <JsonSerializer> jsonSerializerPool, object value, Type type = null, int initialBufferSize = c_initialBufferSize)
{
var jsonSerializer = jsonSerializerPool.Take();
var outputStream = BufferManagerOutputStreamManager.Take();
outputStream.Reinitialize(initialBufferSize, s_sharedBufferPool);
try
{
using (JsonTextWriter jsonWriter = new JsonTextWriter(new StreamWriterX(outputStream, UTF8NoBOM)))
{
jsonWriter.ArrayPool = JsonConvertX.GlobalCharacterArrayPool;
jsonWriter.CloseOutput = false;
jsonWriter.Formatting = jsonSerializer.Formatting;
jsonSerializer.Serialize(jsonWriter, value, type);
jsonWriter.Flush();
}
return(outputStream.ToArraySegment());
}
finally
{
BufferManagerOutputStreamManager.Return(outputStream);
jsonSerializerPool.Return(jsonSerializer);
}
}
public virtual byte[] SerializeObject(object item, int initialBufferSize)
{
//#if NET40
using (var pooledStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledStream.Object;
outputStream.Reinitialize(initialBufferSize, s_sharedBufferPool);
WriteToStream(item, outputStream);
return(outputStream.ToByteArray());
}
//#else
// using (var pooledPipe = PipelineManager.Create())
// {
// var pipe = pooledPipe.Object;
// var outputStream = new PipelineStream(pipe, initialBufferSize);
// WriteToStream(item, outputStream);
// pipe.Flush();
// var readBuffer = pipe.Reader.ReadAsync().GetResult().Buffer;
// var length = (int)readBuffer.Length;
// if (c_zeroSize == length) { return EmptyArray<byte>.Instance; }
// return readBuffer.ToArray();
// }
//#endif
}
/// <summary>Serializes the specified item.</summary>
/// <param name="item">The item.</param>
/// <param name="initialBufferSize">The initial buffer size.</param>
/// <returns></returns>
public virtual ArraySegment <byte> WriteToMemoryPool(object item, int initialBufferSize)
{
//#if NET40
using (var pooledStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledStream.Object;
outputStream.Reinitialize(initialBufferSize, s_sharedBufferPool);
WriteToStream(item, outputStream);
return(outputStream.ToArraySegment());
}
//#else
// using (var pooledPipe = PipelineManager.Create())
// {
// var pipe = pooledPipe.Object;
// var outputStream = new PipelineStream(pipe, initialBufferSize);
// formatter.WriteToStream(item, outputStream);
// pipe.Flush();
// var readBuffer = pipe.Reader.ReadAsync().GetResult().Buffer;
// var length = (int)readBuffer.Length;
// if (c_zeroSize == length) { return s_emptySegment; }
// var buffer = BufferManager.Shared.Rent(length);
// readBuffer.CopyTo(buffer);
// return new ArraySegment<byte>(buffer, 0, length);
// }
//#endif
}
public virtual byte[] Serialize <T>(T item, int initialBufferSize)
{
using (var pooledStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledStream.Object;
outputStream.Reinitialize(initialBufferSize, s_sharedBufferPool);
WriteToStream <T>(item, outputStream);
return(outputStream.ToByteArray());
}
}
/// <summary>Serializes the specified item.</summary>
/// <param name="item">The item.</param>
/// <param name="initialBufferSize">The initial buffer size.</param>
/// <returns></returns>
public virtual ArraySegment <byte> WriteToMemoryPool <T>(T item, int initialBufferSize)
{
using (var pooledStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledStream.Object;
outputStream.Reinitialize(initialBufferSize, s_sharedBufferPool);
WriteToStream <T>(item, outputStream);
return(outputStream.ToArraySegment());
}
}
public byte[] SystemBufferArrayPool()
{
using (var pooledStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledStream.Object;
outputStream.Reinitialize(c_initialBufferSize, ArrayPool <byte> .Shared);
_formatter.WriteToStream(_persionData, outputStream);
return(outputStream.ToByteArray());
}
}
/// <summary>Serializes the specified object to a JSON string using a type, formatting and <see cref="JsonSerializer"/>.</summary>
/// <param name="jsonSerializer">The <see cref="JsonSerializer"/> used to serialize the object</param>
/// <param name="value">The object to serialize.</param>
/// <param name="type">The type of the value being serialized.
/// This parameter is used when <see cref="JsonSerializer.TypeNameHandling"/> is <see cref="TypeNameHandling.Auto"/> to write out the type name if the type of the value does not match.
/// Specifying the type is optional.</param>
/// <param name="initialBufferSize"></param>
/// <returns>A JSON string representation of the object.</returns>
public static byte[] SerializeToByteArray(this JsonSerializer jsonSerializer, object value, Type type = null, int initialBufferSize = c_initialBufferSize)
{
using (var pooledOutputStream = BufferManagerOutputStreamManager.Create())
{
var outputStream = pooledOutputStream.Object;
outputStream.Reinitialize(initialBufferSize, s_sharedBufferPool);
using (JsonTextWriter jsonWriter = new JsonTextWriter(new StreamWriterX(outputStream, UTF8NoBOM)))
{
jsonWriter.ArrayPool = JsonConvertX.GlobalCharacterArrayPool;
jsonWriter.CloseOutput = false;
jsonWriter.Formatting = jsonSerializer.Formatting;
jsonSerializer.Serialize(jsonWriter, value, type);
jsonWriter.Flush();
}
return(outputStream.ToByteArray());
}
}
