CopyToAsync() public method

public CopyToAsync ( Stream destination, int bufferSize, CancellationToken cancellationToken ) : Task
destination Stream
bufferSize int
cancellationToken CancellationToken
return Task
        /// <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);
            }
        }
Example #2
0
        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(")");
                }
            }
        }
Example #4
0
        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;
        }
        /// <summary>
        /// Salvar o <see cref="SessionState"/> atual.  Quaisquer instâncias de <see cref="Frame"/>
        ///registradas com <see cref="RegisterFrame"/> também preservarão sua sua pilha de navegação atual
        /// que, por sua vez, dá à sua <see cref="Page"/> ativa uma oportunidade
        /// para salvar seu estado.
        /// </summary>
        /// <returns>Uma tarefa assíncrona que reflete quando o estado da sessão foi salvo.</returns>
        public static async Task SaveAsync()
        {
            try
            {
                // Salve o estado de navegação para todos os quadros registrados
                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                // Serialize o estado da sessão de forma síncrona para evitar acesso assíncrono a
                // estado
                MemoryStream sessionData = new MemoryStream();
                DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                serializer.WriteObject(sessionData, _sessionState);

                // Obter um fluxo de saída para o arquivo SessionState e gravar o estado de forma assíncrona
                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);
            }
        }
        /// <summary>
        /// 현재 <see cref="SessionState"/>를 저장합니다.  <see cref="RegisterFrame"/>에 등록된
        /// 모든 <see cref="Frame"/> 인스턴스는 현재 탐색 스택도 유지합니다.
        /// 따라서 활성 <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);
                    }
                }

                // 공유 상태에 대해 비동기적으로 액세스하지 못하도록 세션 상태를 동기적으로
                //serialize합니다.
                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);
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }
		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);
		}
Example #8
0
        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);
            }
        }
Example #9
0
        /// <summary>
        /// Salvare l'oggetto <see cref="SessionState"/> corrente.  Tutte le istanze di <see cref="Frame"/>
        /// registrate con <see cref="RegisterFrame"/> conserveranno lo
        /// stack di navigazione corrente, che a sua volta fornisce all'oggetto <see cref="Page"/> attivo la possibilità
        /// di salvare lo stato.
        /// </summary>
        /// <returns>Attività asincrona che riflette il momento in cui è stato salvato lo stato sessione.</returns>
        public static async Task SaveAsync()
        {
            try
            {
                // Salvare lo stato di navigazione per tutti i frame registrati
                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                // Serializzare lo stato sessione in modo sincrono per evitare l'accesso asincrono allo stato
                // condiviso
                MemoryStream sessionData = new MemoryStream();
                DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                serializer.WriteObject(sessionData, _sessionState);

                // Richiamare un flusso di output per il file SessionState e scrivere lo stato in modo asincrono
                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);
            }
        }
Example #10
0
        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();
            }
        }
Example #11
0
        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();
                    }
                }
            }
        }
Example #17
0
        /// <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);
            }
        }
Example #18
0
        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);
                            });

                    });
            };
        }
Example #19
0
    /// <summary>
    /// Den aktuellen <see cref="SessionState"/> speichern.  Alle <see cref="Frame"/>-Instanzen,
    /// die bei <see cref="RegisterFrame"/> registriert wurden, behalten ebenfalls ihren aktuellen
    /// Navigationsstapel bei, wodurch deren aktive <see cref="Page"/> eine Gelegenheit
    /// zum Speichern des zugehörigen Zustands erhält.
    /// </summary>
    /// <returns>Eine asynchrone Aufgabe, die das Speichern des Sitzungszustands wiedergibt.</returns>
    public static async Task SaveAsync()
    {
      try
      {
        // Navigationszustand für alle registrierten Rahmen speichern
        foreach (var weakFrameReference in _registeredFrames)
        {
          Frame frame;
          if (weakFrameReference.TryGetTarget(out frame))
          {
            SaveFrameNavigationState(frame);
          }
        }

        // Sitzungszustand synchron serialisieren, um einen asynchronen Zugriff auf den freigegebenen
        // Zustand
        MemoryStream sessionData = new MemoryStream();
        DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
        serializer.WriteObject(sessionData, _sessionState);

        // Einen Ausgabedatenstrom für die SessionState-Datei abrufen und den Zustand asynchron schreiben
        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);
      }
    }
Example #20
0
        public async Task Invoke(Env environment)
        {
            if (IsCallToHealthCheck(environment))
            {
                var responseHeaders = (IDictionary<string, string[]>) environment["owin.ResponseHeaders"];
                responseHeaders["Content-Type"] = new[] {Constants.Response.ContentType.Json + "; charset=utf-8"};

                var responseStream = (Stream) environment["owin.ResponseBody"];

                var healthCheckService = new HealthCheckService(configuration, new VersionProvider(configuration),
                    systemCheckerResolverFactory());
                var result = healthCheckService.CheckHealth(IsIntrusive(environment));

                using (var writeStream = new MemoryStream())
                {
                    var contentLength = new HealthResultJsonSerializer().SerializeToStream(writeStream, result);
                    responseHeaders["Content-Length"] = new[] { contentLength.ToString("D") };
                    writeStream.Position = 0;

                    await writeStream.CopyToAsync(responseStream);
                }
            }
            else
                await next.Invoke(environment);
        }
        /// <summary>
        /// Guardar el <see cref="SessionState"/> actual.  Toda instancia de <see cref="Frame"/>
        /// registrada en <see cref="RegisterFrame"/> también conservará la
        /// pila de navegación actual que, a su vez, ofrece a la <see cref="Page"/> activa la oportunidad
        /// de guardar su estado.
        /// </summary>
        /// <returns>Tarea asincrónica que refleja cuándo se ha guardado el estado de la sesión.</returns>
        public static async Task SaveAsync()
        {
            try
            {
                // Guardar el estado de navegación para todos los marcos registrados
                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                // Serializar el estado de la sesión de forma sincrónica para impedir el acceso asincrónico al estado
                // compartido
                MemoryStream sessionData = new MemoryStream();
                DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                serializer.WriteObject(sessionData, _sessionState);

                // Obtener un flujo de salida para el archivo SessionState y escribir el estado de forma asincrónica
                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);
            }
        }
        /// <summary>
        /// Enregistre le <see cref="SessionState"/> actuel. Toutes les instances de <see cref="Frame"/>
        /// inscrites avec <see cref="RegisterFrame"/> conservent également leur
        /// pile de navigation actuelle, ce qui permet à leur <see cref="Page"/> active
        /// d'enregistrer son état.
        /// </summary>
        /// <returns>Tâche asynchrone qui reflète quand l'état de session a été enregistré.</returns>
        public static async Task SaveAsync()
        {
            try
            {
                // Enregistre l'état de navigation pour tous les frames inscrits
                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        SaveFrameNavigationState(frame);
                    }
                }

                // Sérialise l'état de session de manière synchrone pour éviter un accès asynchrone à un
                // état
                MemoryStream sessionData = new MemoryStream();
                DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                serializer.WriteObject(sessionData, _sessionState);

                // Obtient un flux de sortie pour le fichier SessionState file et écrit l'état de manière asynchrone
                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 async Task Invoke(HttpContext context)
        {
            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))
                        {
                            string body = await streamReader.ReadToEndAsync();
                            body = MinifyHtml(body);
                            using (var minBodyStream = new MemoryStream())
                            using (var streamWriter = new StreamWriter(minBodyStream))
                            {
                                streamWriter.Write(body);
                                streamWriter.Flush();
                                minBodyStream.Seek(0, SeekOrigin.Begin);
                                await minBodyStream.CopyToAsync(bodyStream);
                            }
                        }
                    }
                }
            }
        }
Example #24
0
        /// <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);
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }
Example #25
0
        /// <summary>
        /// 現在の <see cref="SessionState"/> を保存します。
        /// <see cref="RegisterFrame"/> で登録された <see cref="Frame"/> インスタンスは、現在のナビゲーション スタックも保存します。
        /// これは、アクティブな <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);
            }
        }
Example #26
0
        /// <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);
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }
Example #27
0
 public IActionResult Png(string id)
 {
     return new Tools.Web.CustomActionResult((ActionContext context) =>
     {
         const string blobContainer = "badges";
         string blobFileName = $"{id}.png";
         var blobCopyTask = mBlobStorageService.CopyBlobContentToStream(blobContainer, blobFileName, context.HttpContext.Response.Body);
         if (blobCopyTask != null)
         {
             HttpContext.Response.ContentType = "image/png";
             return blobCopyTask;
         }
         else
         {
             // This could be solved a bit more complex, but more efficiently,
             // if the ResponseStream of the cloud-converter download would
             // directly write into a pre-created CloudBlob stream.
             using (var mem = new MemoryStream())
             {
                 string host = ApplyHostNameWorkaround(context.HttpContext.Request.Host.Value);
                 var convertTask = mCloudConverter.Convert(
                     $"http://{host}/badge/{id}.svg",
                     id,
                     mem);
                 convertTask.Wait(10 * 1000); // wait a maximum of 10 seconds
                 mem.Position = 0;
                 mBlobStorageService.UploadBlobFromStream(blobContainer, blobFileName, mem);
                 mem.Position = 0;
                 HttpContext.Response.ContentType = "image/png";
                 return mem.CopyToAsync(context.HttpContext.Response.Body);
             }
         }
     });
 }
        /// <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()
        {
            // Save the navigation state for all registered frames
            foreach (var weakFrameReference in RegisteredFrames)
            {
                Frame frame;
                if (weakFrameReference.TryGetTarget(out frame))
                {
                    SaveFrameNavigationState(frame);
                }
            }

            var sessionData = new MemoryStream();
            var 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
            var file = await ApplicationData.Current.LocalFolder.CreateFileAsync(SessionStateFilename, CreationCollisionOption.ReplaceExisting);
            using (var fileStream = await file.OpenStreamForWriteAsync())
            {
                sessionData.Seek(0, SeekOrigin.Begin);
                await sessionData.CopyToAsync(fileStream);
                await fileStream.FlushAsync();
            }
        }
Example #29
0
        public static async Task WriteBytesAsync(string path, byte[] data)
        {
            using (var fs = GetOutputStream(path)) {
                using (var memory = new MemoryStream(data)) {
					await memory.CopyToAsync(fs).ConfigureAwait(false);
                }
            }
        }
Example #30
0
 protected async override Task SerializeToStreamAsync(Stream stream,
     TransportContext context)
 {
     MemoryStream ms = new MemoryStream();
     IFormatter formatter = new BinaryFormatter();
     formatter.Serialize(ms, Content);
     await ms.CopyToAsync(stream);
 }
Example #31
0
    public async Task InvokeAsync(HttpContext context)
    {
        var originalBodyStream = context.Response.Body;

        using (var responseBody = new System.IO.MemoryStream())
        {
            context.Response.Body = responseBody;
            long length = 0;
            context.Response.OnStarting(() =>
            {
                context.Response.Headers.ContentLength = length;
                return(Task.CompletedTask);
            });
            await _next(context);

            //if you want to read the body, uncomment these lines.
            //context.Response.Body.Seek(0, SeekOrigin.Begin);
            //var body = await new StreamReader(context.Response.Body).ReadToEndAsync();
            length = context.Response.Body.Length;
            context.Response.Body.Seek(0, System.IO.SeekOrigin.Begin);
            await responseBody.CopyToAsync(originalBodyStream);
        }
    }