| 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);
}
}
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;
}
/// <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);
}
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);
}
}
/// <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);
}
}
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);
});
});
};
}
/// <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);
}
}
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);
}
}
}
}
}
}
/// <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);
}
}
/// <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);
}
}
/// <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);
}
}
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();
}
}
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);
}
}
}
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);
}
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);
}
}
