public void CanDisposeGZipStream()
{
var ms = new MemoryStream();
var zip = new GZipStream(ms, CompressionMode.Compress);
zip.Dispose();
Assert.Null(zip.BaseStream);
zip.Dispose(); // Should be a no-op
}
public static bool UncompressGZ(string filePath, byte[] content)
{
FileStream fileStream = null;
GZipStream gzStream = null;
try
{
fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write);
gzStream = new GZipStream(new MemoryStream(content), CompressionMode.Decompress, false);
// Because the uncompressed size of the file is unknown, we are using an arbitrary buffer size.
byte[] buffer = new byte[4096];
int count;
while ((count = gzStream.Read(buffer, 0, buffer.Length)) > 0)
{
fileStream.Write(buffer, 0, count);
}
gzStream.Close();
fileStream.Close();
}
catch (Exception)
{
return(false);
}
finally
{
gzStream?.Dispose();
fileStream?.Dispose();
}
return(true);
}
public void SaveToStream(Stream Target)
{
var Header = new NoteDocumentHeader();
MemoryStream EncodedString;
GZipStream Smallstring = null;
byte[] CompressedBytes;
try
{
Smallstring = new GZipStream(EncodedString = new MemoryStream(), CompressionLevel.Fastest);
byte[] UncompressedBytes = Encoding.UTF8.GetBytes(CoreString);
Smallstring.Write(UncompressedBytes, 0, UncompressedBytes.Length);
}
finally
{
Smallstring?.Dispose();
}
CompressedBytes = EncodedString.GetBuffer();
Header.StringEncoding = EncodingData;
Header.EncodingLength = CompressedBytes.Length;
Header.WriteBytes(Target);
Target.Write(CompressedBytes, 0, CompressedBytes.Length);
}
public void CompressCanWrite()
{
var ms = new MemoryStream();
var zip = new GZipStream(ms, CompressionMode.Compress);
Assert.True(zip.CanWrite, "GZipStream not CanWrite with CompressionMode.Compress");
zip.Dispose();
Assert.False(zip.CanWrite, "GZipStream CanWrite after dispose");
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
GZipStream gzipStream = new GZipStream(stream, CompressionMode.Compress, leaveOpen: true);
return(_originalContent.CopyToAsync(gzipStream).ContinueWith(task =>
{
gzipStream?.Dispose();
}));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var gzipStream = new GZipStream(stream, CompressionMode.Compress, leaveOpen: true);
return(sb.WriteToAsync(gzipStream).ContinueWith(_ =>
{
gzipStream?.Dispose();
}));
}
public void DecompressCanRead()
{
var ms = new MemoryStream();
var zip = new GZipStream(ms, CompressionMode.Decompress);
Assert.True(zip.CanRead, "GZipStream not CanRead in Decompress");
zip.Dispose();
Assert.False(zip.CanRead, "GZipStream CanRead after dispose in Decompress");
}
public void Dispose()
{
_records.CompleteAdding();
if (_thread?.IsAlive == true)
{
_thread.Join();
}
_csvWriter?.Dispose();
_streamWriter?.Dispose();
_gzipStream?.Dispose();
_stream?.Dispose();
}
public void Dispose()
{
_writer?.WriteEndObject();
_writer?.Flush();
_streamWriter?.Flush();
_streamWriter?.Dispose();
_gZipStream?.Dispose();
if (_leaveOpen == false)
{
_stream?.Flush();
_stream?.Dispose();
}
}
private bool disposedValue = false; // Pour détecter les appels redondants
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
//_data?.Clear();
//_data = null;
_streamReader?.Dispose();
_fileStream?.Dispose();
_gzipStream?.Dispose();
}
disposedValue = true;
}
}
private void DisposeStreams()
{
currentStreamWriter?.Flush();
// the first stream is the original instance, the caller is responsible to dispose it
// the newer instances are created here and should be disposed
if (splitsCount > 0)
{
currentStreamWriter?.Dispose();
currentStreamWriter = null;
currentGzipStream?.Dispose();
currentGzipStream = null;
currentCountingStream?.Dispose();
currentCountingStream = null;
currentStream?.Dispose();
currentStream = null;
}
}
public static void CompressFile(string toCompressFileName,string targetFileName,bool IsDeleteSourceFile)
{
FileStream reader;
reader = File.Open(toCompressFileName, FileMode.Open);
FileStream writer;
writer = File.Create(targetFileName);
//压缩相关的流
MemoryStream ms = new MemoryStream();
GZipStream zipStream = new GZipStream(ms, CompressionMode.Compress, true);
//往压缩流中写数据
byte[] sourceBuffer = new byte[reader.Length];
reader.Read(sourceBuffer, 0, sourceBuffer.Length);
zipStream.Write(sourceBuffer, 0, sourceBuffer.Length);
//一定要在内存流读取之前关闭压缩流
zipStream.Close();
zipStream.Dispose();
//从内存流中读数据
ms.Position = 0; //注意，不要遗漏此句
byte[] destBuffer = new byte[ms.Length];
ms.Read(destBuffer, 0, destBuffer.Length);
writer.Write(destBuffer, 0, destBuffer.Length);
//关闭并释放内存流
ms.Close();
ms.Dispose();
//关闭并释放文件流
writer.Close();
writer.Dispose();
reader.Close();
reader.Dispose();
if (IsDeleteSourceFile)
{
File.Delete(toCompressFileName);
}
}
/// <summary>
/// Serializes the HTTP content to a stream as an asynchronous operation.
/// </summary>
/// <param name="stream">The target stream.</param>
/// <param name="context">Information about the transport (channel binding token, for example). This parameter may be null.</param>
/// <returns>
/// The task object representing the asynchronous operation.
/// </returns>
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Stream compressedStream;
switch (_encodingType)
{
case EncodingType.Deflate:
compressedStream = new DeflateStream(stream, CompressionMode.Compress, true);
break;
case EncodingType.GZip:
default:
compressedStream = new GZipStream(stream, CompressionMode.Compress, true);
break;
}
return(_uncompressedContent.CopyToAsync(compressedStream)
.ContinueWith(t => {
compressedStream?.Dispose();
}));
}
public static void Compress(string fileName, string destFile)
{
MemoryStream ms = new MemoryStream();
GZipStream compressedStream = new GZipStream(ms, CompressionMode.Compress, true);
FileStream fs = new FileStream(fileName, FileMode.Open);
byte[] buf = new byte[1024 * 64];
int count = 0;
do
{
count = fs.Read(buf, 0, buf.Length);
compressedStream.Write(buf, 0, count);
}while (count > 0);
try
{
fs.Close();
compressedStream.Close();
File.WriteAllBytes(destFile, ms.ToArray());
}
catch (Exception e)
{
writeLog("压缩日志文件[" + destFile + "]时出现异常：" + e.ToString());
}
finally
{
if (fs != null)
{
fs.Dispose();
fs.Close();
}
if (compressedStream != null)
{
compressedStream.Dispose();
compressedStream.Close();
}
}
}
/// <summary>
/// 反序列化压缩的object
/// </summary>
/// <param name="_filePath"></param>
/// <returns></returns>
public static object Deserialize(byte[] bytes)
{
MemoryStream msNew = new MemoryStream(bytes);
msNew.Position = 0;
//return (object)new BinaryFormatter().Deserialize(msNew);//反序列化
GZipStream gzipStream = new GZipStream(msNew, CompressionMode.Decompress); //创建解压对象
byte[] buffer = new byte[1024000]; //定义数据缓冲
int offset = 0; //定义读取位置
MemoryStream ms = new MemoryStream(); //定义内存流
while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
{
ms.Write(buffer, 0, offset); //解压后的数据写入内存流
}
BinaryFormatter sfFormatter = new BinaryFormatter(); //定义BinaryFormatter以反序列化object对象
ms.Position = 0; //设置内存流的位置
object obj;
try
{
obj = (object)sfFormatter.Deserialize(ms);//反序列化
}
catch
{
throw;
}
finally
{
ms.Close(); //关闭内存流
ms.Dispose(); //释放资源
}
gzipStream.Close(); //关闭解压缩流
gzipStream.Dispose(); //释放资源
msNew.Close();
msNew.Dispose();
return(obj);
}
public static void Main()
{
var sysObject = new Sys();
sysObject.InitializeComponent();
AppDomain.CurrentDomain.UnhandledException += sysObject.CurrentDomainOnUnhandledException;
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
{
try
{
var culture = "";
var embeddedAssembly = new AssemblyName(args.Name);
if (!string.IsNullOrEmpty(embeddedAssembly.CultureName) &&
embeddedAssembly.CultureName != "neutral")
{
culture = embeddedAssembly.CultureName + ".";
}
var resourceName = "SpintiresModsLoader.Resources.dll." + culture + embeddedAssembly.Name + ".dll.gz";
var streamRes = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
if (streamRes != null)
{
using (var stream = new GZipStream(streamRes, CompressionMode.Decompress, false))
using (var outstream = new MemoryStream())
{
CopyTo(stream, outstream);
stream.Dispose();
streamRes.Dispose();
return(Assembly.Load(outstream.GetBuffer()));
}
}
return(null);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
return(null);
}
};
sysObject.Run();
}
/// <summary>
/// ZIP解压
/// </summary>
/// <param name="zippedData"></param>
/// <returns></returns>
public static byte[] Decompress(byte[] zippedData)
{
MemoryStream ms = new MemoryStream(zippedData);
GZipStream compressedzipStream = new GZipStream(ms, CompressionMode.Decompress);
MemoryStream outBuffer = new MemoryStream();
byte[] block = new byte[1024];
while (true)
{
int bytesRead = compressedzipStream.Read(block, 0, block.Length);
if (bytesRead <= 0)
{
break;
}
else
{
outBuffer.Write(block, 0, bytesRead);
}
}
compressedzipStream.Dispose();
return(outBuffer.ToArray());
}
/// <summary>
/// 反序列化压缩的DataSet
/// </summary>
/// <param name="FilePath">待反序列化的文件地址</param>
public static DataSet DataSetDeserialize(string FilePath)
{
try
{
Stream _Stream = File.Open(FilePath, FileMode.Open); //打开文件
_Stream.Position = 0; //设置文件流的位置
GZipStream gzipStream = new GZipStream(_Stream, CompressionMode.Decompress); //创建解压对象
byte[] buffer = new byte[4096]; //定义数据缓冲
int offset = 0; //定义读取位置
MemoryStream ms = new MemoryStream(); //定义内存流
while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
{
ms.Write(buffer, 0, offset); //解压后的数据写入内存流
}
IFormatter formatter = new BinaryFormatter(); //定义BinaryFormatter以反序列化DataSet对象
ms.Position = 0; //设置内存流的位置
DataSet ds;
try
{
ds = (DataSet)formatter.Deserialize(ms);//反序列化
}
catch
{
ds = null;
}
ms.Close(); //关闭内存流
ms.Dispose(); //释放资源
_Stream.Flush(); //释放内存
_Stream.Close(); //关闭文件流
_Stream.Dispose(); //释放资源
gzipStream.Close(); //关闭解压缩流
gzipStream.Dispose(); //释放资源
return(ds);
}
catch
{
return(null);
}
}
public override void Save()
{
if (ViewState != null || ControlState != null)
{
StringWriter writer = new StringWriter();
StateFormatter.Serialize(writer, new Pair(ViewState, ControlState));
byte[] bytes = Convert.FromBase64String(writer.ToString());
using (MemoryStream output = new MemoryStream())
{
using (GZipStream gzip = new GZipStream(output, CompressionMode.Compress, true))
{
gzip.Write(bytes, 0, bytes.Length);
gzip.Close();
gzip.Dispose();
}
string viewState = Convert.ToBase64String(output.ToArray());
ScriptManager.RegisterHiddenField(Page, m_ViewStateHiddenFieldName, viewState);
}
}
}
public static byte[] Decompress(byte[] B)
{
try
{
MemoryStream ms = new MemoryStream(B);
GZipStream gzipStream = new GZipStream((Stream)ms, CompressionMode.Decompress);
byte[] buffer = new byte[4];
ms.Position = checked (ms.Length - 5L);
ms.Read(buffer, 0, 4);
int count = BitConverter.ToInt32(buffer, 0);
ms.Position = 0L;
byte[] AR = new byte[checked (count - 1 + 1)];
gzipStream.Read(AR, 0, count);
gzipStream.Dispose();
ms.Dispose();
return(AR);
}
catch
{
return(null);
}
}
public static Task Output(this IOwinContext context, Byte[] content, bool enableCompress = true)
{
IOwinResponse rep = context.Response;
//如果启用压缩
if (enableCompress && IsAllowCompress(context.Request))
{
rep.Headers["Content-Encoding"] = "gzip";
var gzStream = new GZipStream(rep.Body, CompressionMode.Compress);
return(gzStream.WriteAsync(content, 0, content.Length)
.ContinueWith(t =>
{
gzStream.Close();
gzStream.Dispose();
}));
}
else
{
rep.ContentLength = content.Length;
return(rep.WriteAsync(content));
}
}
public async Task CopyWithCompression(Stream source, Stream target)
{
source.Position = 0;
var startPos = target.Position;
await target.WriteLongAsync(source.Length);
GZipStream gzip = null;
try
{
gzip = new GZipStream(target, CompressionMode.Compress, true);
await source.CopyToAsync(gzip);
}
finally
{
gzip?.Dispose();
}
await target.WriteLongAsync(startPos);
}
/// <summary>
/// 反序列化压缩的DataSet
/// </summary>
/// <param name="_filePath"></param>
/// <returns></returns>
static DataSet DataSetDeserializeDecompress(string _filePath)
{
FileStream fs = File.OpenRead(_filePath); //打开文件
fs.Position = 0; //设置文件流的位置
GZipStream gzipStream = new GZipStream(fs, CompressionMode.Decompress); //创建解压对象
byte[] buffer = new byte[4096]; //定义数据缓冲
int offset = 0; //定义读取位置
MemoryStream ms = new MemoryStream(); //定义内存流
while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
{
ms.Write(buffer, 0, offset); //解压后的数据写入内存流
}
BinaryFormatter sfFormatter = new BinaryFormatter(); //定义BinaryFormatter以反序列化DataSet对象
ms.Position = 0; //设置内存流的位置
DataSet ds;
try
{
ds = (DataSet)sfFormatter.Deserialize(ms);//反序列化
}
catch
{
throw;
}
finally
{
ms.Close(); //关闭内存流
ms.Dispose(); //释放资源
}
fs.Close(); //关闭文件流
fs.Dispose(); //释放资源
gzipStream.Close(); //关闭解压缩流
gzipStream.Dispose(); //释放资源
return(ds);
}
private static string DecodeHttpContentToString(HttpResponseMessage response)
{
// Read in the input stream, then decompress in to the outputstream.
// Doing this asynronously, but not really required at this point
// since we end up waiting on it right after this.
MemoryStream outputStream = new MemoryStream();
var task2 = response.Content.ReadAsStreamAsync().ContinueWith(t =>
{
Stream inputStream = t.Result;
var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress);
gzipStream.CopyTo(outputStream);
gzipStream.Dispose();
outputStream.Seek(0, SeekOrigin.Begin);
});
task2.Wait();
var responseContent = Encoding.ASCII.GetString(outputStream.ToArray());
return(responseContent);
}
void ExtractGZipFile(string a_Packed, string a_Destination)
{
FileStream packedFile = File.Open(a_Packed, FileMode.Open);
FileStream destFile = File.Create(a_Destination);
GZipStream gzipStream = new GZipStream(packedFile, CompressionMode.Decompress);
byte[] buffer = new byte[4096];
for (;;)
{
int bytesRead = gzipStream.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
break;
}
destFile.Write(buffer, 0, bytesRead);
}
gzipStream.Dispose();
destFile.Dispose();
packedFile.Dispose();
}
public byte[] Encode(byte[] src, int level = 0)
{
byte[] buf = null;
if (src == null)
{
return(buf);
}
try
{
MemoryStream ms = new MemoryStream();
GZipStream zipstream = new GZipStream(ms, CompressionMode.Compress, true);
zipstream.Write(src, 0, src.Length);
zipstream.Close();
zipstream.Dispose();
buf = ms.ToArray();
}
catch (Exception)
{
buf = null;
}
return(buf);
}
/// <summary>
/// 序列化压缩
/// </summary>
/// <param name="obj">需要压缩的对象</param>
/// <returns>Byte[]</returns>
public static byte[] Serializer(object obj)
{
IFormatter formatter = new BinaryFormatter(); //定义BinaryFormatter以序列化object对象
MemoryStream ms = new MemoryStream(); //创建内存流对象
formatter.Serialize(ms, obj); //把object对象序列化到内存流
byte[] buffer = ms.ToArray(); //把内存流对象写入字节数组
ms.Close(); //关闭内存流对象
ms.Dispose(); //释放资源
MemoryStream msNew = new MemoryStream();
GZipStream gzipStream = new GZipStream(msNew, CompressionMode.Compress, true); //创建压缩对象
gzipStream.Write(buffer, 0, buffer.Length); //把压缩后的数据写入文件
gzipStream.Close(); //关闭压缩流,这里要注意：一定要关闭，要不然解压缩的时候会出现小于4K的文件读取不到数据，大于4K的文件读取不完整
gzipStream.Dispose(); //释放对象
var bufferNew = msNew.ToArray();
msNew.Close();
msNew.Dispose();
return(bufferNew);
}
/* INPUT 1:
* ../../Milioni.mp4
* ../../
* 5
* INPUT 2:
* ../../text.txt
* ../../
* 3
*
* * * */
private static void Slice(string sourceFile, string destinationDirectory, int parts)
{
FileStream reader = new FileStream(sourceFile, FileMode.Open);
FileInfo file = new FileInfo(sourceFile);
long chunkSize = (long)(file.Length / parts);
BigInteger counter = -1;
if (file.Length % 2 == 1)
{
counter = 0;
}
int fileCounter = 1;
int readBytesVariable = reader.ReadByte();
List <byte> lsBytes = new List <byte>();
lsBytes.Add((byte)readBytesVariable);
while (readBytesVariable != -1)
{
if ((counter % chunkSize == 0 && counter != 0) || counter == file.Length)
{
string fileName = destinationDirectory + "Part-" + fileCounter + ".gz";
FileStream writer = new FileStream(fileName, FileMode.Create, FileAccess.Write);
GZipStream gzip = new GZipStream(writer, CompressionMode.Compress);
gzip.Write(lsBytes.ToArray(), 0, lsBytes.Count);
gzip.Flush();
gzip.Dispose();
writer.Dispose();
lsBytes.Clear();
fileCounter++;
}
readBytesVariable = reader.ReadByte();
lsBytes.Add((byte)readBytesVariable);
counter++;
}
}
private void SerializeItem(T graph, bool shallow)
{
MemoryStream stream = new MemoryStream();
GZipStream zipStream = new GZipStream(stream, CompressionMode.Compress);
//Serialize into the stream
try
{
XmlFormatter serializer = Singleton.Instance.XmlFormatter;
serializer.Shallow = shallow;
serializer.Serialize(zipStream, graph);
zipStream.Close();
_bytes = stream.ToArray();
}
finally
{
zipStream.Dispose();
stream.Dispose();
}
}
void IDataResponse.Write(PipeStream stream)
{
if (GZip)
{
var mb = stream.Allocate(16);
stream.Write(HeaderTypeFactory.LINE_BYTES);
int len = stream.CacheLength;
if (gZipStream == null)
{
gZipStream = new GZipStream(stream, CompressionMode.Compress, true);
}
gZipStream.Write(Data.Array, Data.Offset, Data.Count);
gZipStream.Flush();
if (Offset == mFileResource.Length)
{
if (gZipStream != null)
{
using (stream.LockFree())
{
gZipStream.Dispose();
}
}
}
string lenstr = (stream.CacheLength - len).ToString("X");
mb.Full(Encoding.UTF8.GetBytes(lenstr.PadRight(16)));
}
else
{
int len = Data.Count;
stream.Write(len.ToString("X"));
stream.Write(HeaderTypeFactory.LINE_BYTES);
stream.Write(Data.Array, Data.Offset, Data.Count);
}
stream.WriteLine("");
if (Offset == mFileResource.Length)
{
stream.Write(HeaderTypeFactory.CHUNKED_BYTES);
}
}
public static void Decompress(byte[] compressed, int compressedOffset, int compressedSize, byte[] uncompressed, int uncompressedOffset, int uncompressedSize, CompressionMethod method, FArchive?reader = null)
{
using var srcStream = new MemoryStream(compressed, compressedOffset, compressedSize, false)
{
Position = 0
};
switch (method)
{
case CompressionMethod.None:
Buffer.BlockCopy(compressed, compressedOffset, uncompressed, uncompressedOffset, compressedSize);
return;
case CompressionMethod.Zlib:
var zlib = new ZlibStream(srcStream, CompressionMode.Decompress);
zlib.Read(uncompressed, uncompressedOffset, uncompressedSize);
zlib.Dispose();
return;
case CompressionMethod.Gzip:
var gzip = new GZipStream(srcStream, CompressionMode.Decompress);
gzip.Read(uncompressed, uncompressedOffset, uncompressedSize);
gzip.Dispose();
return;
case CompressionMethod.Oodle:
Oodle.Decompress(compressed, compressedOffset, compressedSize, uncompressed, uncompressedOffset, uncompressedSize, reader);
return;
default:
if (reader != null)
{
throw new OodleException(reader, $"Compression method \"{method}\" is unknown");
}
else
{
throw new OodleException($"Compression method \"{method}\" is unknown");
}
}
}
public static Task <byte[]> WriteGZipAsync(byte[] data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var dataStream = new MemoryStream();
var compressionStream = new GZipStream(dataStream, CompressionMode.Compress);
return(compressionStream.WriteAsync(data, 0, data.Length)
.ContinueWith(task =>
{
using (dataStream)
{
//Must manually dispose before returning
//https://github.com/dotnet/runtime/issues/15371
compressionStream.Dispose();
return dataStream.ToArray();
}
}));
}
/// <summary>
/// 解压字符串
/// </summary>
public static string Decompress(string source)
{
// get a stream
MemoryStream ms = null;
GZipStream zip = null;
try
{
// get string as bytes
byte[] gzBuffer = Convert.FromBase64String(source);
// prepare stream to do uncompression
ms = new MemoryStream();
// get the length of compressed data
int msgLength = BitConverter.ToInt32(gzBuffer, 0);
// uncompress everything besides the header
ms.Write(gzBuffer, 4, gzBuffer.Length - 4);
// prepare final buffer for just uncompressed data
byte[] buffer = new byte[msgLength];
// reset our position in stream since we're starting over
ms.Position = 0;
// unzip the data through stream
zip = new GZipStream(ms, CompressionMode.Decompress);
// do the unzip
zip.Read(buffer, 0, buffer.Length);
// convert back to string and return
return(Encoding.UTF8.GetString(buffer));
}
finally
{
if (ms != null)
{
ms.Dispose();
}
if (zip != null)
{
zip.Dispose();
}
}
}
public static string Decompress(string compressedText)
{
byte[] byteArray;
//Transform string into byte[]
try
{
byteArray = Convert.FromBase64String(compressedText);
}
catch
{
return(compressedText);
}
//Prepare for decompress
MemoryStream ms = new MemoryStream(byteArray);
GZipStream gzip = new GZipStream(ms, CompressionMode.Decompress);
//Decompress
byte[] buffer = StreamToByteArray(gzip);
//Transform byte[] unzip data to string
StringBuilder sb = new StringBuilder();
//Read the number of bytes GZipStream red and do not a for each bytes in resultByteArray;
for (int i = 0; i < buffer.Length; i++)
{
sb.Append((char)buffer[i]);
}
gzip.Close();
ms.Close();
gzip.Dispose();
ms.Dispose();
return(sb.ToString());
}
public void CopyToAsyncArgumentValidation()
{
using (GZipStream gs = new GZipStream(new MemoryStream(), CompressionMode.Decompress))
{
Assert.Throws<ArgumentNullException>("destination", () => { gs.CopyToAsync(null); });
Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () => { gs.CopyToAsync(new MemoryStream(), 0); });
Assert.Throws<NotSupportedException>(() => { gs.CopyToAsync(new MemoryStream(new byte[1], writable: false)); });
gs.Dispose();
Assert.Throws<ObjectDisposedException>(() => { gs.CopyToAsync(new MemoryStream()); });
}
using (GZipStream gs = new GZipStream(new MemoryStream(), CompressionMode.Compress))
{
Assert.Throws<NotSupportedException>(() => { gs.CopyToAsync(new MemoryStream()); });
}
}
public override void FromXML(XmlNode node)
{
if (node != null && node.Name == "layer")
{
XmlAttributeCollection attrs = node.Attributes;
m_name = attrs["name"].Value;
m_layerDimensions.first = Convert.ToInt32(attrs["width"].Value);
m_layerDimensions.second = Convert.ToInt32(attrs["height"].Value);
foreach(XmlNode child in node.ChildNodes)
{
if (child.Name == "properties")
{
foreach (XmlNode propertyNode in child)
{
if (propertyNode.Name != "property")
continue;
XmlAttributeCollection propertyAtts = propertyNode.Attributes;
m_properties[propertyAtts["name"].Value] = propertyAtts["value"].Value;
}
}
else if (child.Name == "data")
{
m_data = new TileData();
attrs = child.Attributes;
if (attrs["encoding"]!= null)
{
string[] encodings = { "", "csv", "base64" };
string encodingValue = attrs["encoding"].Value;
int encodingIdx = Array.IndexOf(encodings, encodingValue);
if (encodingIdx >= 0)
{
m_data.m_encoding = (TileEncodingType)encodingIdx;
}
string[] compressions = { "", "gzip", "zlib" };
string compression = attrs["compression"].Value;
int compressionIdx = Array.IndexOf(compressions, compression);
if (compressionIdx >= 0)
{
m_data.m_compression = (TileCompressionType)compressionIdx;
}
switch(m_data.m_encoding)
{
case TileEncodingType.kCSV:
{
string text = child.InnerText;
string[] values = text.Split(',');
foreach (string v in values)
{
uint value = Convert.ToUInt32(v);
TileInfo info = new TileInfo();
info.m_horizontalFlip = (value & FLIPPED_HORIZONTALLY_FLAG) != 0;
info.m_verticalFlip = (value & FLIPPED_VERTICALLY_FLAG) != 0;
info.m_diagonalFlip = (value & FLIPPED_DIAGONALLY_FLAG) != 0;
value = value & ~(FLIPPED_DIAGONALLY_FLAG | FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG);
info.m_gid = value;
m_data.m_tiles.Add(info);
}
break;
}
case TileEncodingType.kBase64:
{
byte[] bytes = null;
switch(m_data.m_compression)
{
case TileCompressionType.kNone:
{
bytes = Convert.FromBase64String(child.InnerText);
break;
}
case TileCompressionType.kGzip:
{
//Transform string into byte[]
string str = child.InnerText;
byte[] byteArray = new byte[str.Length];
int indexBA = 0;
foreach (char item in str.ToCharArray())
{
byteArray[indexBA++] = (byte)item;
}
MemoryStream ms = new MemoryStream(byteArray);
GZipStream gzip = new GZipStream(ms, CompressionMode.Decompress);
byteArray = new byte[byteArray.Length];
int rBytes = gzip.Read(byteArray, 0, byteArray.Length);
StringBuilder sb = new StringBuilder(rBytes);
for (int i = 0; i < rBytes; ++i)
{
sb.Append((char)byteArray[i]);
}
gzip.Close();
ms.Close();
gzip.Dispose();
ms.Dispose();
bytes = Convert.FromBase64String(sb.ToString());
break;
}
case TileCompressionType.kZlib:
{
//Transform string into byte[]
string str = child.InnerText;
byte[] byteArray = new byte[str.Length];
int indexBA = 0;
foreach (char item in str.ToCharArray())
{
byteArray[indexBA++] = (byte)item;
}
MemoryStream ms = new MemoryStream(byteArray);
DeflateStream zlib = new DeflateStream(ms, CompressionMode.Decompress);
byteArray = new byte[byteArray.Length];
int rBytes = zlib.Read(byteArray, 0, byteArray.Length);
StringBuilder sb = new StringBuilder(rBytes);
for (int i = 0; i < rBytes; ++i)
{
sb.Append((char)byteArray[i]);
}
zlib.Close();
ms.Close();
zlib.Dispose();
ms.Dispose();
bytes = Convert.FromBase64String(sb.ToString());
break;
}
}
for (int i = 0; i < bytes.Length; i += 4)
{
uint value = (uint)bytes[i] | ((uint)bytes[i + 1] << 8) | ((uint)bytes[i + 2] << 16) | ((uint)bytes[i + 3] << 24);
TileInfo info = new TileInfo();
info.m_horizontalFlip = (value & FLIPPED_HORIZONTALLY_FLAG) != 0;
info.m_verticalFlip = (value & FLIPPED_VERTICALLY_FLAG) != 0;
info.m_diagonalFlip = (value & FLIPPED_DIAGONALLY_FLAG) != 0;
value = value & ~(FLIPPED_DIAGONALLY_FLAG | FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG);
info.m_gid = value;
m_data.m_tiles.Add(info);
}
break;
}
default:
{
break;
}
}
}
else
{
m_data.m_encoding = TileEncodingType.kNone;
m_data.m_compression = TileCompressionType.kNone;
m_data.m_tiles.Clear();
foreach(XmlNode tileNode in child.ChildNodes)
{
if (tileNode.Name != "tile")
{
continue;
}
TileInfo info = new TileInfo();
uint value = Convert.ToUInt32(tileNode.Attributes["gid"].Value);
info.m_horizontalFlip = (value & FLIPPED_HORIZONTALLY_FLAG) != 0;
info.m_verticalFlip = (value & FLIPPED_VERTICALLY_FLAG) != 0;
info.m_diagonalFlip = (value & FLIPPED_DIAGONALLY_FLAG) != 0;
value = value & ~(FLIPPED_DIAGONALLY_FLAG | FLIPPED_HORIZONTALLY_FLAG |FLIPPED_VERTICALLY_FLAG);
info.m_gid = value;
m_data.m_tiles.Add(info);
}
}
}
}
}
}
public static void DecompressFile(string toDecompressFileName, string targetFileName, bool IsDeleteSourceFile)
{
//文件流
FileStream reader;
reader = File.Open(toDecompressFileName, FileMode.Open);
FileStream writer;
writer = File.Create(targetFileName);
//解压相关的流，同时向内存流中写数据
byte[] sourceBuffer = new byte[reader.Length];
reader.Read(sourceBuffer, 0, sourceBuffer.Length);
MemoryStream ms = new MemoryStream(sourceBuffer);
GZipStream zipStream = new GZipStream(ms, CompressionMode.Decompress, true);
byte[] destBuffer = new byte[1];
while (zipStream.Read(destBuffer, 0, destBuffer.Length) > 0)
{
writer.Write(destBuffer, 0, destBuffer.Length);
}
//释放并关闭解压流和内存流
zipStream.Close();
zipStream.Dispose();
ms.Close();
ms.Dispose();
//关闭并释放文件流
writer.Close();
writer.Dispose();
reader.Close();
reader.Dispose();
if (IsDeleteSourceFile)
{
File.Delete(toDecompressFileName);
}
}
public void TestSeekMethodsCompress()
{
var ms = new MemoryStream();
var zip = new GZipStream(ms, CompressionMode.Compress);
Assert.False(zip.CanSeek);
Assert.Throws<NotSupportedException>(delegate { long value = zip.Length; });
Assert.Throws<NotSupportedException>(delegate { long value = zip.Position; });
Assert.Throws<NotSupportedException>(delegate { zip.Position = 100L; });
Assert.Throws<NotSupportedException>(delegate { zip.SetLength(100L); });
Assert.Throws<NotSupportedException>(delegate { zip.Seek(100L, SeekOrigin.Begin); });
zip.Dispose();
Assert.False(zip.CanSeek);
}
public async Task FlushAsyncFailsAfterDispose()
{
var ms = new MemoryStream();
var ds = new GZipStream(ms, CompressionMode.Compress);
ds.Dispose();
await Assert.ThrowsAsync<ObjectDisposedException>(async () =>
{
await ds.FlushAsync();
});
}
public void FlushFailsAfterDispose()
{
var ms = new MemoryStream();
var ds = new GZipStream(ms, CompressionMode.Compress);
ds.Dispose();
Assert.Throws<ObjectDisposedException>(() => { ds.Flush(); });
}
public async Task CanReadBaseStreamAfterDispose()
{
var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
var zip = new GZipStream(ms, CompressionMode.Decompress, true);
var baseStream = zip.BaseStream;
zip.Dispose();
int size = 1024;
Byte[] bytes = new Byte[size];
baseStream.Read(bytes, 0, size); // This will throw if the underlying stream is not writeable as expected
}