C# GZipStream.CopyToAsync方法代码示例

 public async Task<byte[]> BeforeDeserialization(IEnvelope envelope, byte[] serializedMessage)
 {
     using (var inputStream = new MemoryStream(serializedMessage))
     using (var decompressionStream = new GZipStream(inputStream, CompressionMode.Decompress))
     using (var outputStream = new MemoryStream())
     {
         await decompressionStream.CopyToAsync(outputStream).ConfigureAwait(false);
         return outputStream.ToArray();
     }
 }

 /// <inheritdoc />
 protected async override Task SerializeToStreamAsync(Stream stream, TransportContext context)
 {
     using (content)
     {
         var compressedStream = await content.ReadAsStreamAsync();
         using (var uncompressedStream = new GZipStream(compressedStream, CompressionMode.Decompress))
         {
             await uncompressedStream.CopyToAsync(stream);
         }
     }
 }

 /// <summary>
 /// Asychronously Decompresses a string using System.IO.Compression.GZipStream
 /// </summary>
 /// <param name="s">String to decompress</param>
 /// <returns>Decompressed string</returns>
 public static async Task<string> DecompressAsync(string s)
 {
     var bytes = Convert.FromBase64String(s);
     using (var msi = new MemoryStream(bytes))
     using (var mso = new MemoryStream())
     {
         using (var gs = new GZipStream(msi, CompressionMode.Decompress))
         {
             await gs.CopyToAsync(mso);
         }
         return Encoding.Unicode.GetString(mso.ToArray());
     }
 }

        /// <summary>
        /// Downloads an xml file from AniDB which contains all of the titles for every anime, and their IDs,
        /// and saves it to disk.
        /// </summary>
        /// <param name="titlesFile">The destination file name.</param>
        private async Task DownloadTitles(string titlesFile)
        {
            _logger.Debug("Downloading new AniDB titles file.");

            var client = new WebClient();

            await AniDbSeriesProvider.RequestLimiter.Tick();

            using (var stream = await client.OpenReadTaskAsync(TitlesUrl))
            using (var unzipped = new GZipStream(stream, CompressionMode.Decompress))
            using (var writer = File.Open(titlesFile, FileMode.Create, FileAccess.Write))
            {
                await unzipped.CopyToAsync(writer).ConfigureAwait(false);
            }
        }

 public static async Task<string> DecompressAsync(string input)
 {
     using (var inputStream = new MemoryStream(Convert.FromBase64String(input)))
     {
         using (var stream = new GZipStream(inputStream, CompressionMode.Decompress))
         {
             using (var outputStream = new MemoryStream())
             {
                 await stream.CopyToAsync(outputStream);
                 var output = outputStream.ToArray();
                 return Encoding.UTF8.GetString(output, 0, output.Length);
             }
         }
     }
 }

 public static async Task WriteFlotAppAsync(Stream output, bool decompress = false)
 {
     if (!decompress)
     {
         using (var stream = Assembly.GetAssembly(typeof(FlotWebApp)).GetManifestResourceStream("Metrics.Visualization.index.full.html.gz"))
         {
             await stream.CopyToAsync(output).ConfigureAwait(false);
         }
     }
     else
     {
         using (var stream = Assembly.GetAssembly(typeof(FlotWebApp)).GetManifestResourceStream("Metrics.Visualization.index.full.html.gz"))
         using (var gzip = new GZipStream(stream, CompressionMode.Decompress))
         {
             await gzip.CopyToAsync(output).ConfigureAwait(false);
         }
     }
 }

        /// <summary>
        /// Decrompresses Given File
        /// </summary>
        /// <param name="File">File to Decompress</param>
        public static async Task<String> Decrompress(String file)
        {
            FileInfo Info = new FileInfo(file);
            string newFileName;

            using (FileStream originalFileStream = Info.OpenRead())
            {
                string currentFile = Info.FullName;
                 newFileName = currentFile.Remove(currentFile.Length - Info.Extension.Length);

                using (FileStream decompressed = File.Create(newFileName))
                {
                    using (GZipStream decompression = new GZipStream(originalFileStream, CompressionMode.Decompress))
                    {
                        await decompression.CopyToAsync(decompressed);
                    }
                }
            }

            Info.Delete();

            return newFileName;
        }

		/// <summary>
		/// takes byte array and decompress it into Content
		/// </summary>
		public async Task Decompress()
		{
			if (CompressedContent != null && CompressedContent.Length != 0)
			{
				using (MemoryStream inStream = new MemoryStream(CompressedContent))
				using (MemoryStream outStream = new MemoryStream())
				{
					using (GZipStream gz = new GZipStream(inStream, CompressionMode.Decompress))
					{
						await gz.CopyToAsync(outStream);
					}
					Content = Encoding.Unicode.GetString(outStream.ToArray());
				}
			}
			else
			{
				Content = "";
			}
		}

        /// <summary>
        /// Saves content of this attachment to a temp file.
        /// </summary>
        /// <returns></returns>
        public async Task<IStorageFile> SaveToFile()
        {
            var target = await ApplicationData.Current.TemporaryFolder
                .CreateFolderAsync("Attachments",
                    CreationCollisionOption.OpenIfExists);

            var file = await target.CreateFileAsync(Key,
                CreationCollisionOption.ReplaceExisting);

            var value = Value;
            var compressed = value.Attribute("Compressed");
            var isCompressed = compressed != null && (bool)compressed;


            if (!isCompressed)
            {
                var buffer = CryptographicBuffer
                    .DecodeFromBase64String(value.Value);
                await FileIO.WriteBufferAsync(file, buffer);
            }
            else
            {
                var bytes = Convert.FromBase64String(value.Value);

                using (var buffer = new MemoryStream(bytes))
                using (var gz = new GZipStream(buffer, CompressionMode.Decompress))
                using (var output = await file.OpenStreamForWriteAsync())
                {
                    await gz.CopyToAsync(output);
                }
            }

            return file;
        }