本文整理汇总了C#中System.IO.MemoryStream.CopyToAsync方法的典型用法代码示例。如果您正苦于以下问题:C# MemoryStream.CopyToAsync方法的具体用法?C# MemoryStream.CopyToAsync怎么用?C# MemoryStream.CopyToAsync使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.IO.MemoryStream
的用法示例。
在下文中一共展示了MemoryStream.CopyToAsync方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: SaveAsync
/// <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);
}
}
示例2: WriteResponseAsync
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(")");
}
}
示例3: WriteResponseAsync
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(")");
}
}
}
示例4: ExecuteRequest
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;
}
示例5: Invoke
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);
}
示例6: SaveAsync
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);
}
}
示例7: WriteResponseAsync
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();
}
}
示例8: Invoke
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);
}
}
}
}
}
示例9: SaveAsync
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();
}
}
示例10: PostProcessImageAsync
/// <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;
}
示例11: GetFileUrl
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('\\', '/');
}
示例12: Invoke
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);
}
}
}
}
}
示例13: Invoke
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();
}
}
}
}
示例14: SaveAsync
/// <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);
}
}
示例15: Middleware
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);
});
});
};
}