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 }