static Patch processChunk(byte[] orig, byte[] mod, int chunkStart, int chunkEnd)
{
int patchSize = chunkEnd - chunkStart;
Debug.Assert(patchSize < Patch.MaxPatchSize);
int matchAreaSize = Patch.MatchAreaSize(patchSize);
int matchBefore = (matchAreaSize - patchSize) / 2;
int matchAfter = matchAreaSize - (patchSize + matchBefore);
Debug.Assert(matchBefore <= chunkStart);
Debug.Assert(chunkEnd + matchAfter <= orig.Length);
byte[] origBytes = new byte[matchAreaSize];
byte[] patchBytes = new byte[patchSize];
Array.ConstrainedCopy(orig, chunkStart - matchBefore, origBytes, 0, matchAreaSize);
Array.ConstrainedCopy(mod, chunkStart, patchBytes, 0, patchSize);
MemoryStream ms = new MemoryStream();
DeflateStream comp = new DeflateStream(ms, CompressionMode.Compress);
comp.WriteByte(0);
comp.Flush();
long base_len = ms.Length;
comp.Write(origBytes, 0, origBytes.Length);
comp.Flush();
return(new Patch(origBytes, patchBytes, matchBefore, Convert.ToInt32(ms.Length - base_len)));
}
public void DoubleFlush()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Flush();
ds.Flush();
}
[Category("StaticLinkedAotNotWorking")] // Native MPH loading issues
public void Bug28777_DoubleFlush()
{
byte[] buffer = new byte [4096];
MemoryStream backing = new MemoryStream();
DeflateStream compressing = new DeflateStream(backing, CompressionLevel.Fastest, true);
compressing.Write(buffer, 0, buffer.Length);
compressing.Flush();
compressing.Flush();
compressing.Close();
backing.Close();
}
// netz.compress.ICompress implementation
public long Compress(string file, string zipFile)
{
long length = -1;
FileStream ifs = null;
FileStream ofs = null;
try
{
ifs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read);
ofs = File.Open(zipFile, FileMode.Create, FileAccess.Write, FileShare.None);
DeflateStream dos = new DeflateStream(ofs, CompressionMode.Compress, true);
byte[] buff = new byte[ifs.Length];
while(true)
{
int r = ifs.Read(buff, 0, buff.Length);
if(r <= 0) break;
dos.Write(buff, 0, r);
}
dos.Flush();
dos.Close();
length = ofs.Length;
}
finally
{
if(ifs != null) ifs.Close();
if(ofs != null) ofs.Close();
}
return length;
}
public void Save(Stream stream, bool compress)
{
char[] header = new char[2] {
'X', '1'
};
using (var outStream = new MemoryStream()) {
outStream.WriteByte((byte)header[0]);
outStream.WriteByte((byte)header[1]);
var serializer = new SerialWriter(new BinaryWriter(outStream));
Serialize(document.Root, serializer);
outStream.Position = 0;
string data = new StreamReader(outStream).ReadToEnd();
outStream.Position = 0;
if (compress)
{
var writer = new BinaryWriter(stream);
writer.Write(Encoding.UTF8.GetBytes("l33t"));
writer.Write((int)outStream.Length);
writer.Write((byte)0x78);
writer.Write((byte)0x9C);
using (var decompStream = new DeflateStream(stream, CompressionMode.Compress, true)) {
outStream.CopyTo(decompStream);
decompStream.Flush();
}
}
else
{
outStream.CopyTo(stream);
}
}
}
public void Dispose()
{
ZipStream.Flush();
ZipStream.Close();
ZipStream.Dispose();
FileStream.Dispose();
}
public override void Flush()
{
if (deflateStream != null)
{
deflateStream.Flush();
}
}
/// <summary>
/// Send data to the web socket
/// </summary>
/// <param name="buffer">the buffer containing data to send</param>
/// <param name="messageType">The message type. Can be Text or Binary</param>
/// <param name="endOfMessage">True if this message is a standalone message (this is the norm)
/// If it is a multi-part message then false (and true for the last message)</param>
/// <param name="cancellationToken">the cancellation token</param>
public override async Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
using (MemoryStream stream = _recycledStreamFactory())
{
WebSocketOpCode opCode = GetOppCode(messageType);
if (_usePerMessageDeflate)
{
// NOTE: Compression is currently work in progress and should NOT be used in this library.
// The code below is very inefficient for small messages. Ideally we would like to have some sort of moving window
// of data to get the best compression. And we don't want to create new buffers which is bad for GC.
using (MemoryStream temp = new MemoryStream())
{
DeflateStream deflateStream = new DeflateStream(temp, CompressionMode.Compress);
deflateStream.Write(buffer.Array, buffer.Offset, buffer.Count);
deflateStream.Flush();
ArraySegment <byte> compressedBuffer = new ArraySegment <byte>(temp.ToArray());
WebSocketFrameWriter.Write(opCode, compressedBuffer, stream, endOfMessage, _isClient);
Events.Log.SendingFrame(_guid, opCode, endOfMessage, compressedBuffer.Count, true);
}
}
else
{
WebSocketFrameWriter.Write(opCode, buffer, stream, endOfMessage, _isClient);
Events.Log.SendingFrame(_guid, opCode, endOfMessage, buffer.Count, false);
}
await WriteStreamToNetwork(stream, cancellationToken);
// TODO: is this correct??
_isContinuationFrame = !endOfMessage;
}
}
/// <summary>
/// Send data to the web socket
/// </summary>
/// <param name="buffer">the buffer containing data to send</param>
/// <param name="messageType">The message type. Can be Text or Binary</param>
/// <param name="endOfMessage">True if this message is a standalone message (this is the norm)
/// If it is a multi-part message then false (and true for the last message)</param>
/// <param name="cancellationToken">the cancellation token</param>
public override async Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
using (MemoryStream stream = _recycledStreamFactory())
{
WebSocketOpCode opCode = GetOppCode(messageType);
if (_usePerMessageDeflate)
{
using (MemoryStream temp = new MemoryStream())
{
DeflateStream deflateStream = new DeflateStream(temp, CompressionMode.Compress);
deflateStream.Write(buffer.Array, buffer.Offset, buffer.Count);
deflateStream.Flush();
var compressedBuffer = new ArraySegment <byte>(temp.ToArray());
WebSocketFrameWriter.Write(opCode, compressedBuffer, stream, endOfMessage, _isClient);
Events.Log.SendingFrame(_guid, opCode, endOfMessage, compressedBuffer.Count, true);
}
}
else
{
WebSocketFrameWriter.Write(opCode, buffer, stream, endOfMessage, _isClient);
Events.Log.SendingFrame(_guid, opCode, endOfMessage, buffer.Count, false);
}
await WriteStreamToNetwork(stream, cancellationToken);
_isContinuationFrame = !endOfMessage;
}
}
/// <summary>
/// Serializes an object as a base 64 encoded string.
/// </summary>
/// <typeparam name="T">Type of object to serialize.</typeparam>
/// <param name="obj">The object to serialize.</param>
/// <returns>The object serialized as a base 64 encoded string.</returns>
public static string Serialize <T>(this T obj) where T : class
{
if (obj == null)
{
return(null);
}
using (var stream = new MemoryStream())
{
using (var compressionStream = new DeflateStream(stream, CompressionMode.Compress, true))
{
var formatter = new BinaryFormatter();
var surrogateSelector = new SurrogateSelector();
// Add the serialization surrogate to allow SelectListItem to be serialized
surrogateSelector.AddSurrogate(typeof(SelectListItem), new StreamingContext(StreamingContextStates.All), new SelectListItemSerializationSurrogate());
formatter.SurrogateSelector = surrogateSelector;
// Serialize object to stream
formatter.Serialize(compressionStream, obj);
compressionStream.Flush();
}
stream.Position = 0;
return(Convert.ToBase64String(stream.ToArray()));
}
}
/// <summary>
/// 解压缩二进制格式数据,得到数据集
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
public static DataSet DecompressionDataSet1(byte[] bytes)
{
// 初始化流，设置读取位置
MemoryStream mStream = new MemoryStream(bytes);
mStream.Seek(0, SeekOrigin.Begin);
// 解压缩流得到byte[]格式数据
DeflateStream unZipStream = new DeflateStream(mStream, CompressionMode.Decompress, true);
byte[] unzipBytes = StreamOperator.ReadWholeStream(unZipStream);
unZipStream.Flush();
unZipStream.Close();
// 将数据装入内存
MemoryStream resultStream = new MemoryStream(unzipBytes);
resultStream.Seek(0, SeekOrigin.Begin);
// 反序列化
DataSet resultDataSet = new DataSet();
resultDataSet.RemotingFormat = SerializationFormat.Binary;
BinaryFormatter bFormatter = new BinaryFormatter();
resultDataSet = (DataSet)bFormatter.Deserialize(resultStream, null);
//
return(resultDataSet);
}
// Binary serialization
public byte[] Serialize()
{
using (MemoryStream stream = new MemoryStream())
{
using (DeflateStream ds = new DeflateStream(stream, CompressionMode.Compress, true))
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(ds, this);
ds.Flush();
}
byte[] bytes = stream.GetBuffer();
byte[] bytes2 = new byte[stream.Length];
Buffer.BlockCopy(bytes, 0, bytes2, 0, (int)stream.Length);
// Array.Copy(bytes, bytes2, stream.Length);
if (this.MustEncrypt)
{
bytes2 = RijndaelEncrptor.Instance.Encrypt(bytes2);
}
// Create a buffer large enough to hold the encrypted message and size bytes
byte[] data = new byte[8 + bytes2.Length];
// Add the message size
BitConverter.GetBytes(bytes2.Length).CopyTo(data, 0);
BitConverter.GetBytes(this.MustEncrypt).CopyTo(data, 4);
// Add the message data
bytes2.CopyTo(data, 8);
return(data);
}
}
public DataSet DecompressDataSet(byte[] bytDs)
{
DataSet outDs = new DataSet();
MemoryStream inMs = new MemoryStream(bytDs);
inMs.Seek(0, 0); //스트림으로 가져오기
//1. 압축객체 생성- 압축 풀기
DeflateStream zipStream = new DeflateStream(inMs,
CompressionMode.Decompress, true);
byte[] outByt = ReadFullStream(zipStream);
zipStream.Flush();
zipStream.Close();
MemoryStream outMs = new MemoryStream(outByt);
outMs.Seek(0, 0); //2. 스트림으로 다시변환
outDs.RemotingFormat = SerializationFormat.Binary;
//3. 데이터셋으로 Deserialize
BinaryFormatter bf = new BinaryFormatter();
outDs = (DataSet)bf.Deserialize(outMs, null);
return(outDs);
}
/// <summary>
/// 문자열을 받아 데이터 셋을 리턴합니다.
/// </summary>
/// <param name="str">압축문자열.</param>
/// <returns>데이터 셋</returns>
public static DataSet DecompressDataSet(string str)
{
try
{
byte[] bytDs = Convert.FromBase64String(str);
DataSet outDs = new DataSet();
MemoryStream inMs = new MemoryStream(bytDs);
inMs.Seek(0, 0);
DeflateStream zipStream = new DeflateStream(inMs, CompressionMode.Decompress, true);
byte[] outByt = ReadFullStream(zipStream);
zipStream.Flush();
zipStream.Close();
MemoryStream outMs = new MemoryStream(outByt);
outMs.Seek(0, 0);
outDs.RemotingFormat = SerializationFormat.Binary;
BinaryFormatter bf = new BinaryFormatter();
outDs = (DataSet)bf.Deserialize(outMs, null);
return(outDs);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 데이터 셋을 받아 바이트로 리턴합니다.
/// </summary>
/// <param name="ds">The ds.</param>
/// <returns></returns>
private static byte[] CompressDataSet(DataSet ds)
{
try
{
//1. 데이터셋 Serialize
ds.RemotingFormat = SerializationFormat.Binary;
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
bf.Serialize(ms, ds);
byte[] inbyt = ms.ToArray();
//2. 데이터 압축
System.IO.MemoryStream objStream = new MemoryStream();
DeflateStream objZS = new DeflateStream(objStream, CompressionMode.Compress);
objZS.Write(inbyt, 0, inbyt.Length);
objZS.Flush();
objZS.Close();
//3. 데이터 리턴
return(objStream.ToArray());
}
catch (Exception ex)
{
throw ex;
}
}
//------------------------------------------------------------------------------------------
/// <summary>
/// Compress and returns the supplied source bytes-array data. Optionally the use of the GZip algorithm can be specified (default is Deflate).
/// NOTE: Usage of the GZip algorithm adds cyclic-redudancy checks, which is well suitted for publishing the result externally (as in files).
/// </summary>
public static byte[] Compress(byte[] Source, bool AsGZip = false)
{
using (var Result = new MemoryStream())
{
if (AsGZip)
{
using (var Compressor = new GZipStream(Result, CompressionMode.Compress))
{
Compressor.Write(Source, 0, Source.Length);
Compressor.Flush();
Compressor.Close();
return(Result.ToArray());
}
}
else
{
using (var Compressor = new DeflateStream(Result, CompressionMode.Compress))
{
Compressor.Write(Source, 0, Source.Length);
Compressor.Flush();
Compressor.Close();
return(Result.ToArray());
}
}
}
}
public static byte[] CompressPacketsForWrapper(List <Packet> packets, CompressionLevel compressionLevel = CompressionLevel.Fastest)
{
long length = 0;
foreach (Packet packet in packets)
{
length += packet.Encode().Length;
}
compressionLevel = length > 1000 ? compressionLevel : CompressionLevel.NoCompression;
using (MemoryStream stream = MiNetServer.MemoryStreamManager.GetStream())
{
int checksum;
using (var compressStream = new DeflateStream(stream, compressionLevel, true))
{
foreach (Packet packet in packets)
{
byte[] bs = packet.Encode();
if (bs != null && bs.Length > 0)
{
BatchUtils.WriteLength(compressStream, bs.Length);
compressStream.Write(bs, 0, bs.Length);
}
packet.PutPool();
}
compressStream.Flush();
}
byte[] bytes = stream.ToArray();
return(bytes);
}
}
static unsafe byte[] CompressFlipRb3(byte[] data, int height, int stride)
{
using var compressStream = new MemoryStream();
compressStream.Write(FakeDeflateHeader, 0, FakeDeflateHeader.Length);
using (var compressor = new DeflateStream(compressStream, CompressionLevel.Fastest))
{
fixed(byte *srcPtr = data)
{
byte *srcPtrOff = srcPtr;
for (int v = 0; v < height; v++)
{
compressor.WriteByte(0);
for (int u = 0; u < stride; u += 3, srcPtrOff += 3)
{
byte tmp = srcPtrOff[0];
srcPtrOff[0] = srcPtrOff[2];
srcPtrOff[2] = tmp;
}
compressor.Write(data, v * stride, stride);
}
}
compressor.Flush();
compressor.Close();
}
return(compressStream.ToArray());
}
public byte[] Decompress(byte[] byteArray_DeflateCompressedData)
{
MemoryStream memoryStream_CompressedData = new MemoryStream(byteArray_DeflateCompressedData, 0, byteArray_DeflateCompressedData.Length);
memoryStream_DecompressedData.SetLength(0);
memoryStream_CompressedData.Position = 0;
DeflateStream deflateStream_obj = new DeflateStream(memoryStream_CompressedData, CompressionMode.Decompress, true);
int int_DecompressedByte = 0;
for (; ;)
{
int_DecompressedByte = deflateStream_obj.ReadByte();
if (int_DecompressedByte == -1)
{
break;
}
memoryStream_DecompressedData.WriteByte((byte)int_DecompressedByte);
}
deflateStream_obj.Flush();
deflateStream_obj.Close();
memoryStream_CompressedData.Close();
memoryStream_DecompressedData.SetLength(memoryStream_DecompressedData.Position);
return(memoryStream_DecompressedData.ToArray());
}
public static byte[] GZipDecompress(this byte[] bin)
{
try
{
using (System.IO.MemoryStream msCommpressed = new System.IO.MemoryStream())
{
msCommpressed.Write(bin, 0, bin.Length);
msCommpressed.Flush();
msCommpressed.Position = 0;
//msCommpressed.Position = 0;
using (DeflateStream zip = new DeflateStream(msCommpressed, CompressionMode.Decompress))
{
using (System.IO.MemoryStream msDecompressed = new MemoryStream())
{
zip.CopyTo(msDecompressed);
zip.Flush();
zip.Close();
//msDecompressed.Position = 0;
msDecompressed.Flush();
msCommpressed.Close();
return(msDecompressed.ToArray());
}
}
}
}
catch (Exception x)
{
throw x;
}
}
public void OnSerialize(BinaryWriter writer)
{
using (MemoryStream memoryStream1 = new MemoryStream())
{
using (BinaryWriter blockWriter = new BinaryWriter(memoryStream1))
{
blockWriter.Write(xStart);
blockWriter.Write(yStart);
blockWriter.Write(width);
blockWriter.Write(height);
WriteTileBlock(blockWriter, xStart, yStart, width, height);
memoryStream1.Position = 0L;
MemoryStream memoryStream2 = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(memoryStream2, CompressionMode.Compress, true))
{
memoryStream1.CopyTo(deflateStream);
deflateStream.Flush();
}
if (memoryStream1.Length <= memoryStream2.Length)
{
writer.Write((byte)0);
writer.BaseStream.Write(memoryStream1.GetBuffer(), 0, (int)memoryStream2.Length);
}
else
{
writer.Write((byte)1);
writer.BaseStream.Write(memoryStream2.GetBuffer(), 0, (int)memoryStream2.Length);
}
}
}
}
public static byte[] Deflate(byte[] data, bool compress)
{
if (compress)
{
using (MemoryStream ms = new MemoryStream())
{
using (DeflateStream zs = new DeflateStream(ms, CompressionMode.Compress))
{
zs.Write(data, 0, data.Length);
zs.Flush();
}
return(ms.ToArray());
}
}
else
{
using (MemoryStream ms = new MemoryStream(data))
using (MemoryStream md = new MemoryStream())
{
using (DeflateStream zs = new DeflateStream(ms, CompressionMode.Decompress))
{
byte[] buf = new byte[4096];
int len = 0;
while ((len = zs.Read(buf, 0, buf.Length)) > 0)
{
md.Write(buf, 0, len);
}
}
return(md.ToArray());
}
}
}
// BEGIN CALLOUT A
public static SqlBytes fn_compress(SqlBytes blob)
// END CALLOUT A
{
if (blob.IsNull)
{
return(blob);
}
// BEGIN CALLOUT B
// Retrieve the BLOB's data.
byte[] blobData = blob.Buffer;
// END CALLOUT B
// BEGIN CALLOUT C
// Prepare for compression.
MemoryStream compressedData = new MemoryStream();
DeflateStream compressor = new DeflateStream(compressedData,
CompressionMode.Compress, true);
// Write the uncompressed data using a DeflateStream compressor.
compressor.Write(blobData, 0, blobData.Length);
// Close the compressor to allow all the compressed bytes to be written.
compressor.Flush();
compressor.Close();
compressor = null;
// END CALLOUT C
// Return the compressed blob.
return(new SqlBytes(compressedData));
}
/// <summary>压缩数据流</summary>
/// <param name="inStream">输入流</param>
/// <param name="outStream">输出流。如果不指定，则内部实例化一个内存流</param>
/// <remarks>返回输出流，注意此时指针位于末端</remarks>
public static Stream Compress(this Stream inStream, Stream outStream = null)
{
var ms = outStream ?? new MemoryStream();
// 第三个参数为true，保持数据流打开，内部不应该干涉外部，不要关闭外部的数据流
#if NET4
using (var stream = new DeflateStream(ms, CompressionMode.Compress, true))
{
inStream.CopyTo(stream);
stream.Flush();
}
#else
using (var stream = new DeflateStream(ms, CompressionLevel.Optimal, true))
{
inStream.CopyTo(stream);
stream.Flush();
}
#endif
// 内部数据流需要把位置指向开头
if (outStream == null)
{
ms.Position = 0;
}
return(ms);
}
DeflateStream CompressedStream = null;//压缩流
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="filepath">源文件</param>
/// <param name="dir">目标目录</param>
/// <returns></returns>
public MemoryStream SerFileZip(string filepath)
{
FileStream SourceFile = null;
MemoryStream SerFile = new MemoryStream();
try
{
byte[] buffer;
string filename = System.IO.Path.GetFileNameWithoutExtension(filepath);//获取文件名
SourceFile = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read);
buffer = new byte[SourceFile.Length];
SourceFile.Read(buffer, 0, buffer.Length);//读取源文件
CompressedStream = new DeflateStream(SerFile, CompressionMode.Compress, true);
CompressedStream.Write(buffer, 0, buffer.Length);//压缩
CompressedStream.Flush();
return(SerFile);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (SourceFile != null)
{
SourceFile.Close();
}
if (CompressedStream != null)
{
CompressedStream.Close();
}
}
}
static public DataTable DecompressionDataTable(byte[] bytes)
{
MemoryStream mStream = new MemoryStream(bytes);
mStream.Seek(0, SeekOrigin.Begin);
DeflateStream unZipStream = new DeflateStream(mStream, CompressionMode.Decompress, true);
byte[] unZipBytes = StreamOperator.ReadWholeStream(unZipStream);
unZipStream.Flush();
unZipStream.Close();
MemoryStream resultStream = new MemoryStream(unZipBytes);
resultStream.Seek(0, SeekOrigin.Begin);
DataTable dtResult = new DataTable();
dtResult.RemotingFormat = SerializationFormat.Binary;
BinaryFormatter bFormatter = new BinaryFormatter();
dtResult = (DataTable)bFormatter.Deserialize(resultStream, null);
return(dtResult);
}
//**********************************************************************************************************//
// Object
//**********************************************************************************************************//
/// <summary>
/// Object를 Base64 형태의 스트링으로 압축하여 리턴한다.
/// </summary>
/// <param name="type"></param>
/// <param name="object_value"></param>
/// <returns></returns>
public string CompressObject(Type type, object object_value)
{
var _result = "";
//1. 데이터셋 Serialize
using (MemoryStream _is = new MemoryStream())
{
XmlSerializer _xs = new XmlSerializer(type);
_xs.Serialize(_is, object_value);
//2. 데이터 압축
using (MemoryStream _os = new MemoryStream())
{
using (DeflateStream _zs = new DeflateStream(_os, CompressionMode.Compress))
{
byte[] _pbuff = _is.ToArray();
_zs.Write(_pbuff, 0, _pbuff.Length);
_zs.Flush();
}
//3. 데이터 리턴
byte[] _zbuff = _os.ToArray();
_result = Convert.ToBase64String(_zbuff, 0, _zbuff.Length);
}
}
return(_result);
}
/// Send data to the web socket
public void Send(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage)
{
using (MemoryStream stream = _recycledStreamFactory())
{
WebSocketOpCode opCode = GetOppCode(messageType);
if (_usePerMessageDeflate)
{
// NOTE: Compression is currently work in progress and should NOT be used in this library.
// The code below is very inefficient for small messages. Ideally we would like to have some sort of moving window
// of data to get the best compression. And we don't want to create new buffers which is bad for GC.
using (MemoryStream temp = new MemoryStream())
{
DeflateStream deflateStream = new DeflateStream(temp, CompressionMode.Compress);
deflateStream.Write(buffer.Array, buffer.Offset, buffer.Count);
deflateStream.Flush();
var compressedBuffer = new ArraySegment <byte>(temp.ToArray());
WebSocketFrameWriter.Write(opCode, compressedBuffer, stream, endOfMessage, _isClient);
_logger(LogLevel.Debug, $"websocket.SendingFrame: {opCode}, {endOfMessage}, {compressedBuffer.Count}, compressed");
}
}
else
{
WebSocketFrameWriter.Write(opCode, buffer, stream, endOfMessage, _isClient);
_logger(LogLevel.Debug, $"websocket.SendingFrame: {opCode}, {endOfMessage}, {buffer.Count}, uncompressed");
}
WriteStreamToNetwork(stream);
_isContinuationFrame = !endOfMessage; // TODO: is this correct??
}
}
//**********************************************************************************************************//
// DataSet
//**********************************************************************************************************//
/// <summary>
/// DataSet을 Base64 형태의 스트링으로 압축하여 리턴한다.
/// </summary>
/// <param name="plain_data_set"></param>
/// <returns></returns>
public string CompressDataSet(DataSet plain_data_set)
{
var _result = "";
using (MemoryStream _is = new MemoryStream())
{
//1. 데이터셋 Serialize
plain_data_set.RemotingFormat = SerializationFormat.Binary;
BinaryFormatter _bform = new BinaryFormatter();
_bform.Serialize(_is, plain_data_set);
//2. 데이터 압축
using (MemoryStream _os = new MemoryStream())
{
using (DeflateStream _zs = new DeflateStream(_os, CompressionMode.Compress))
{
byte[] _pbuff = _is.ToArray();
_zs.Write(_pbuff, 0, _pbuff.Length);
_zs.Flush();
}
//3. 데이터 리턴
byte[] _zbuff = _os.ToArray();
_result = Convert.ToBase64String(_zbuff, 0, _zbuff.Length);
}
}
return(_result);
}
private void EncodeTextMessage(WebSocketPackage package)
{
var encoder = _encoding.GetEncoder();
var text = package.Message.AsSpan();
var completed = false;
var outputStream = new WritableSequenceStream();
using (var stream = new DeflateStream(outputStream, CompressionMode.Compress))
{
while (!completed)
{
var buffer = _arrayPool.Rent(_deflateBufferSize);
Span <byte> span = buffer;
encoder.Convert(text, span, false, out int charsUsed, out int bytesUsed, out completed);
if (charsUsed > 0)
{
text = text.Slice(charsUsed);
}
stream.Write(buffer, 0, bytesUsed);
}
stream.Flush();
}
package.Data = outputStream.GetUnderlyingSequence();
}
public async Task Flush()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Flush();
await ds.FlushAsync();
// Just ensuring Flush doesn't throw
}
public void FlushFailsAfterDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Dispose();
Assert.Throws<ObjectDisposedException>(() => { ds.Flush(); });
}
public void DoubleFlush()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Flush();
ds.Flush();
}
public void FlushThenDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Flush();
ds.Dispose();
}
public async Task Flush()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Flush();
await ds.FlushAsync();
}
