C# MemoryStream.CopyToAsync方法代码示例

        /// <summary>
        /// Save the current <see cref="SessionState"/>.  Any <see cref="Frame"/> instances
        /// registered with <see cref="RegisterFrame"/> will also preserve their current
        /// navigation stack, which in turn gives their active <see cref="Page"/> an opportunity
        /// to save its state.
        /// </summary>
        /// <returns>An asynchronous task that reflects when session state has been saved.</returns>
        public static async Task SaveAsync()
        {
            try
            {
                // Save the navigation state for all registered frames
                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                // Serialize the session state synchronously to avoid asynchronous access to shared
                // state
                MemoryStream sessionData = new MemoryStream();
                DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                serializer.WriteObject(sessionData, _sessionState);

                // Get an output stream for the SessionState file and write the state asynchronously
                StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
                using (Stream fileStream = await file.OpenStreamForWriteAsync())
                {
                    sessionData.Seek(0, SeekOrigin.Begin);
                    await sessionData.CopyToAsync(fileStream);
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }

        public static async Task WriteResponseAsync(IOwinContext context, HttpStatusCode statusCode, Action<JsonWriter> writeContent)
        {
            /*
             * If an exception is thrown when building the response body, the exception must be handled before returning
             * a 200 OK (and presumably return a 500 Internal Server Error). If this approach becomes a memory problem,
             * we can write directly to the response stream. However, we must be sure to a) have proper validation to
             * avoid service exceptions (which is never a sure thing) or b) be okay with returning 200 OK on service
             * exceptions. Another approach could also separate "do business logic" with "build response body". Since
             * most exceptions will likely happen during the "do business logic" step, this would reduce the change of
             * a 200 OK on service exception. However, this means that the whole result of the business logic is in
             * memory.
             */
            var content = new MemoryStream();
            WriteToStream(content, writeContent);
            content.Position = 0;

            // write the response
            context.Response.StatusCode = (int)statusCode;
            context.Response.Headers.Add("Pragma", new[] { "no-cache" });
            context.Response.Headers.Add("Cache-Control", new[] { "no-cache" });
            context.Response.Headers.Add("Expires", new[] { "0" });
            var callback = context.Request.Query["callback"];
            if (string.IsNullOrEmpty(callback))
            {
                context.Response.ContentType = "application/json";
                await content.CopyToAsync(context.Response.Body);
            }
            else
            {
                context.Response.ContentType = "application/javascript";
                await context.Response.WriteAsync($"{callback}(");
                await content.CopyToAsync(context.Response.Body);
                await context.Response.WriteAsync(")");
            }
        }

        public async Task WriteResponseAsync(IOwinContext context, HttpStatusCode statusCode, Action<JsonWriter> writeContent)
        {
            using (var content = new MemoryStream())
            {
                WriteToStream(content, writeContent);
                content.Position = 0;
                
                // write the response
                context.Response.StatusCode = (int)statusCode;
                context.Response.Headers.Add("Pragma", new[] { "no-cache" });
                context.Response.Headers.Add("Cache-Control", new[] { "no-cache" });
                context.Response.Headers.Add("Expires", new[] { "0" });

                var callback = context.Request.Query["callback"];
                if (string.IsNullOrEmpty(callback))
                {
                    context.Response.ContentType = "application/json";
                    await content.CopyToAsync(context.Response.Body);
                }
                else
                {
                    context.Response.ContentType = "application/javascript";
                    await context.Response.WriteAsync($"{callback}(");
                    await content.CopyToAsync(context.Response.Body);
                    await context.Response.WriteAsync(")");
                }
            }
        }

        public async Task<Response> ExecuteRequest(Request request)
        {
            if (!_tcpClient.Connected)
            {
                throw new InvalidOperationException("Connect first.");
            }

            var converter = new MessageConverter();

            var requestBuffer = new MemoryStream();
            var streamWriter = new HmBinaryMessageWriter(requestBuffer);
            var requestReader = new MessageReader(request);
            converter.Convert(requestReader, streamWriter);


            var networkStream = _tcpClient.GetStream();
            requestBuffer.Position = 0;
            await requestBuffer.CopyToAsync(networkStream);

            await Task.Delay(100);

            //todo: implement buffered reader
            var streamReader = new HmBinaryMessageReader(networkStream);
            var responseBuilder = new MessageBuilder();

            converter.Convert(streamReader, responseBuilder);

            var response = (Response)responseBuilder.Result;

            return response;
        }

		public async Task Invoke(IDictionary<string, object> env)
		{
			IOwinContext context = new OwinContext(env);
			 
			// Switch the response body stream
			// to a memory stream.
			var originalStream = context.Response.Body;
			var responseBuffer = new MemoryStream();
			context.Response.Body = responseBuffer;

			await this.next(env);

			responseBuffer.Seek(0, SeekOrigin.Begin);
			string responseBody = await this.ReadAllAsync(
				responseBuffer);
			Console.WriteLine(responseBody);
			 
			// This header is getting added after the
			// second middleware has already written into
			// the response body stream, yet, the header goes out.
			context.Response.Headers.Add("X-Some-Header",
				new[] { "Hello" });
			 
			responseBuffer.Seek(0, SeekOrigin.Begin);
			await responseBuffer.CopyToAsync(originalStream);
		}

        public static async Task SaveAsync()
        {
            try
            {
                foreach (var weakFrameReference in mRegisteredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                var sessionData = new MemoryStream();
                var serializer = new DataContractSerializer(typeof(Dictionary<string, object>), mKnownTypes);

                serializer.WriteObject(sessionData, mSessionState);

                var file = await ApplicationData.Current.LocalFolder.CreateFileAsync(mSessionStateFilename, CreationCollisionOption.ReplaceExisting);
                using (var fileStream = await file.OpenStreamForWriteAsync())
                {
                    sessionData.Seek(0, SeekOrigin.Begin);
                    await sessionData.CopyToAsync(fileStream);
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }

        private async Task WriteResponseAsync(string[] requestTokens, IOutputStream outstream)
        {
            // NOTE: If you change the respBody format, change the Content-Type (below) accordingly
            //string respBody = weatherData.HTML;
            //string respBody = weatherData.XML;
            string respBody = weatherData.JSON;

            string htmlCode = "200 OK";

            using (Stream resp = outstream.AsStreamForWrite())
            {
                byte[] bodyArray = Encoding.UTF8.GetBytes(respBody);
                MemoryStream stream = new MemoryStream(bodyArray);

                // NOTE: If you change the respBody format (above), change the Content-Type accordingly
                string header = string.Format("HTTP/1.1 {0}\r\n" +
                                              //"Content-Type: text/html\r\n" + // HTML only
                                              //"Content-Type: text/xml\r\n" +  // XML only
                                              "Content-Type: text/json\r\n" + // JSON only
                                              "Content-Length: {1}\r\n" +
                                              "Connection: close\r\n\r\n",
                                              htmlCode, stream.Length);

                byte[] headerArray = Encoding.UTF8.GetBytes(header);
                await resp.WriteAsync(headerArray, 0, headerArray.Length);
                await stream.CopyToAsync(resp);
                await resp.FlushAsync();
            }
        }

        public async Task Invoke(HttpContext httpContext)
        {
            StringValues acceptEncoding = httpContext.Request.Headers["Accept-Encoding"];
            if (acceptEncoding.Count > 0)
            {
                if (acceptEncoding.ToString().IndexOf
                ("gzip", StringComparison.CurrentCultureIgnoreCase) >= 0)
                {
                    using (var memoryStream = new MemoryStream())
                    {
                        var stream = httpContext.Response.Body;
                        httpContext.Response.Body = memoryStream;
                        await _next(httpContext);
                        if (httpContext.Response.Headers.ContainsKey("X-Content-Encoding"))
                        {
                            httpContext.Response.Headers.Remove("X-Content-Encoding");
                            httpContext.Response.Headers.Add("Content-Encoding", new[] {"gzip"});
                            memoryStream.Seek(0, SeekOrigin.Begin);
                            return;
                        }

                        using (var compressedStream = new GZipStream(stream, CompressionLevel.Optimal))
                        {
                            httpContext.Response.Headers.Add("Content-Encoding", new[] { "gzip" });
                            memoryStream.Seek(0, SeekOrigin.Begin);
                            await memoryStream.CopyToAsync(compressedStream);
                        }
                    }
                }
            }
        }

        public static async Task SaveAsync()
        {
            foreach (var weakFrameReference in registeredFrames)
            {
                Frame frame;
        
                if (weakFrameReference.TryGetTarget(out frame))
                {
                    SaveFrameNavigationState(frame);
                }
            }

            MemoryStream sessionData = new MemoryStream();
            DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), knownTypes);
            serializer.WriteObject(sessionData, sessionState);

            StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
            
            using (Stream fileStream = await file.OpenStreamForWriteAsync())
            {
                sessionData.Seek(0, SeekOrigin.Begin);
                await sessionData.CopyToAsync(fileStream);
                await fileStream.FlushAsync();
            }
        }

        /// <summary>
        /// Post processes the image asynchronously.
        /// </summary>
        /// <param name="stream">The source image stream.</param>
        /// <param name="extension">The image extension.</param>
        /// <returns>
        /// The <see cref="Task"/>.
        /// </returns>
        public static async Task<MemoryStream> PostProcessImageAsync(MemoryStream stream, string extension)
        {
            // Create a source temporary file with the correct extension.
            long length = stream.Length;
            string tempFile = Path.GetTempFileName();
            string sourceFile = Path.ChangeExtension(tempFile, extension);
            File.Move(tempFile, sourceFile);

            // Save the input stream to a temp file for post processing.
            using (FileStream fileStream = File.Create(sourceFile))
            {
                await stream.CopyToAsync(fileStream);
            }

            PostProcessingResultEventArgs result = await RunProcess(sourceFile, length);

            if (result != null && result.Saving > 0)
            {
                using (FileStream fileStream = File.OpenRead(sourceFile))
                {
                    // Replace stream contents.
                    stream.SetLength(0);
                    await fileStream.CopyToAsync(stream);
                }
            }

            // Cleanup
            File.Delete(sourceFile);

            stream.Position = 0;

            return stream;
        }

        public async Task<string> GetFileUrl(Photo photo)
        {
            string relativeFileName = Path.Combine(
                _relativePathToPhotos,
                photo.DepositId.ToString(),
                photo.Id.ToString(),
                photo.ImageUploadFileName);

            string absoluteFileName = _absoluteRoot + relativeFileName;

            if (!File.Exists(absoluteFileName))
            {
                string dirName = Path.GetDirectoryName(absoluteFileName);
                if (!Directory.Exists(dirName))
                {
                    Directory.CreateDirectory(dirName);
                }

                using (var ms = new MemoryStream(photo.ImageUpload.Content))
                using (var fs = new FileStream(absoluteFileName, FileMode.Create))
                {
                    await ms.CopyToAsync(fs);
                }
            }

            return relativeFileName.Replace('\\', '/');
        }

        public async Task Invoke(HttpContext context)
        {
            var sw = new Stopwatch();
            sw.Start();

            using (var memoryStream = new MemoryStream())
            {
                var bodyStream = context.Response.Body;
                context.Response.Body = memoryStream;

                await _next(context);

                var isHtml = context.Response.ContentType?.ToLower().Contains("text/html");
                if (context.Response.StatusCode == 200 && isHtml.GetValueOrDefault())
                {
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    using (var streamReader = new StreamReader(memoryStream))
                    {
                        var responseBody = await streamReader.ReadToEndAsync();
                        //C# 6 DEMO
                        var newFooter = string.Format($"<footer><div id='process'>Page processed in {sw.ElapsedMilliseconds} milliseconds.</div>");
                        responseBody = responseBody.Replace("<footer>", newFooter);
                        context.Response.Headers.Add("X-ElapsedTime", new[] { sw.ElapsedMilliseconds.ToString() });
                        using (var amendedBody = new MemoryStream())
                        using (var streamWriter = new StreamWriter(amendedBody))
                        {
                            streamWriter.Write(responseBody);
                            amendedBody.Seek(0, SeekOrigin.Begin);
                            await amendedBody.CopyToAsync(bodyStream);
                        }
                    }
                }
            }
        }

        public override async Task Invoke(IOwinContext context)
        {
            using (var buffer = new MemoryStream())
            {
                var responseStream = context.Response.Body;

                context.Response.Body = buffer;

                await _next.Invoke(context);

                Console.WriteLine("[{0}] {1} {2}", Thread.CurrentThread.ManagedThreadId, context.Response.StatusCode, (HttpStatusCode)context.Response.StatusCode);

                foreach (var header in context.Response.Headers)
                {
                    Console.WriteLine("\t{0} {1}", header.Key, string.Join(", ", header.Value));
                }

                buffer.Seek(0, SeekOrigin.Begin);

                await buffer.CopyToAsync(responseStream);

                if (LogBody(context.Response.ContentType))
                {
                    buffer.Seek(0, SeekOrigin.Begin);

                    using (var reader = new StreamReader(buffer, true))
                    {
                        var body = await reader.ReadToEndAsync();

                        Console.WriteLine(body);
                        Console.WriteLine();
                    }
                }
            }
        }

        /// <summary>
        /// 儲存目前的 <see cref="SessionState"/>。任何 <see cref="Frame"/> 執行個體
        /// 若在 <see cref="RegisterFrame"/> 中註冊，也會保留其目前
        /// 導覽堆疊，從而使它們的使用中 <see cref="Page"/> 有機會
        /// 儲存狀態。
        /// </summary>
        /// <returns>反映何時儲存工作階段狀態的非同步工作。</returns>
        public static async Task SaveAsync()
        {
            try
            {
                // 儲存所有已註冊框架的導覽狀態
                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                // 同步序列化工作階段狀態，以免非同步存取共用
                // 狀態
                MemoryStream sessionData = new MemoryStream();
                DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                serializer.WriteObject(sessionData, _sessionState);

                // 取得 SessionState 檔的輸出資料流，並以非同步方式寫入狀態
                StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
                using (Stream fileStream = await file.OpenStreamForWriteAsync())
                {
                    sessionData.Seek(0, SeekOrigin.Begin);
                    await sessionData.CopyToAsync(fileStream);
                    await fileStream.FlushAsync();
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }

        public static AppDelegate Middleware(AppDelegate app)
        {
            return call =>
            {
                return app(call).Then<ResultParameters, ResultParameters>(
                    result =>
                    {
                        if (IsStatusWithNoNoEntityBody(result.Status)
                            || result.Headers.ContainsKey("Content-Length")
                            || result.Headers.ContainsKey("Transfer-Encoding"))
                        {
                            return TaskHelpers.FromResult(result);
                        }

                        if (result.Body == null)
                        {
                            result.Headers.SetHeader("Content-Length", "0");
                            return TaskHelpers.FromResult(result);
                        }

                        // Buffer the body
                        MemoryStream buffer = new MemoryStream();
                        return result.Body(buffer).Then<ResultParameters>(
                            () =>
                            {
                                buffer.Seek(0, SeekOrigin.Begin);
                                result.Headers.SetHeader("Content-Length", buffer.Length.ToString(CultureInfo.InvariantCulture));
                                result.Body = output => buffer.CopyToAsync(output);

                                return TaskHelpers.FromResult(result);
                            });

                    });
            };
        }