public void DisposeAsync_CanInvokeMultipleTimes() { var ms = new MemoryStream(); var sw = new StreamWriter(ms); Assert.True(sw.DisposeAsync().IsCompletedSuccessfully); Assert.True(sw.DisposeAsync().IsCompletedSuccessfully); }
/// <summary> /// 获取浏览数 /// </summary> /// <returns></returns> private async Task <int> GetVisit() { var filepath = Path.Combine(Directory.GetCurrentDirectory(), _configuration.GetValue <string>("filePath")); var fileStream = new FileStream(filepath, FileMode.Open); int visit; try { var reader = new StreamReader(fileStream); var line = await reader.ReadLineAsync(); visit = int.Parse(line ?? string.Empty); fileStream.Flush(); reader.Close(); var writer = new StreamWriter(filepath, append: false); await writer.WriteLineAsync((visit + 1).ToString()); await writer.DisposeAsync(); } finally { fileStream.Close(); } return(visit); }
public async Task ReadmeEditor_should_not_allow_concurrent_edits() { var file = Path.GetTempFileName(); await using var writer = new StreamWriter(file); await writer.WriteAsync("hello ").ConfigureAwait(false); await writer.DisposeAsync().ConfigureAwait(false); var edits = Enumerable.Repeat("*", 10).Select(async s => { using var editor = new ReadmeEditor(file); var content = await editor.ExtractReadmeContent().ConfigureAwait(false); await editor.UpdateReadmeContent(content + s).ConfigureAwait(false); }).ToArray(); await Task.WhenAll(edits).ConfigureAwait(false); var delays = Enumerable.Repeat(TimeSpan.FromMilliseconds(100), 100); var retryPolicy = Policy.Handle <Exception>().WaitAndRetryAsync(delays); var trials = await retryPolicy.ExecuteAndCaptureAsync( async() => await File.ReadAllTextAsync(file).ConfigureAwait(false)) .ConfigureAwait(false); trials.Result.Should().Be("hello **********"); }
public async Task CacheData_Daily(string symbol, string fpCache, string fpLockout, bool fullData = true) { string requestData = await RequestData_Daily(symbol, fullData); if (!Directory.Exists(Path.GetDirectoryName(fpCache))) { Directory.CreateDirectory(Path.GetDirectoryName(fpCache)); } if (!Directory.Exists(Path.GetDirectoryName(fpLockout))) { Directory.CreateDirectory(Path.GetDirectoryName(fpLockout)); } StreamWriter sw; sw = new StreamWriter(fpCache); await sw.WriteAsync(requestData); await sw.FlushAsync(); sw.Close(); await sw.DisposeAsync(); sw = new StreamWriter(fpLockout); sw.Close(); await sw.DisposeAsync(); }
public async Task WriteAllDataAsync <T>(IEnumerable <T> roots, string fileName) { var sw = Stopwatch.StartNew(); try { await Task.Run(async() => { _logger.Information($"write entries of type {typeof(T)} to file {fileName}"); await using StreamWriter streamWriter = new StreamWriter(fileName, true, Encoding.UTF8, 32768); var enumerable = roots.ToList(); enumerable.ToList().ForEach(async root => { await using MemoryStream str = new MemoryStream(); await JsonSerializer.SerializeAsync(str, root, root.GetType()); str.Position = 0; await streamWriter.WriteLineAsync(await new StreamReader(str).ReadToEndAsync()); }); _logger.Information($"Successfully written {enumerable.Count} lines to file"); await streamWriter.FlushAsync(); await streamWriter.DisposeAsync(); }); } finally { sw.Stop(); _logger.Information("Processed {MethodName} in {ElapsedMs:000} ms", $"WriteAllDataAsync<{typeof(T)}>", sw.ElapsedMilliseconds); } }
public async ValueTask DisposeAsync() { await writer.DisposeAsync(); reader.Dispose(); await stream.DisposeAsync(); }
public async Task RespondWithFile(string caption, string fileName, string contents) { if (this.ctx is null) { return; } FileStream fs = new FileStream($"{fileName}-{this.ctx.User.Id}.txt", FileMode.OpenOrCreate); StreamWriter sr = new StreamWriter(fs); await sr.WriteAsync(contents); await sr.FlushAsync(); var path = fs.Name; await sr.DisposeAsync(); await fs.DisposeAsync(); fs = new FileStream(path, FileMode.Open); await this.ctx.Channel.SendMessageAsync(new DiscordMessageBuilder().WithFile(caption, fs)); await fs.DisposeAsync(); File.Delete(path); }
public override async Task ExecuteResultAsync(ActionContext context) { var response = context.HttpContext.Response; response.StatusCode = 200; response.ContentType = "application/json"; response.ContentLength = (FileInfo.Length + 2) / 3 * 4 + 2; using var f1 = FileInfo.CreateReadStream(); byte[] opt = opts.Rent(byteLen); char[] res = ress.Rent(charLen); var sw = new StreamWriter(response.Body); await sw.WriteAsync('"'); while (true) { int len = await f1.ReadAsync(opt, 0, byteLen); if (len == 0) { break; } int len2 = Convert.ToBase64CharArray(opt, 0, len, res, 0); await sw.WriteAsync(res, 0, len2); } await sw.WriteAsync('"'); await sw.DisposeAsync(); opts.Return(opt); ress.Return(res); }
/// <summary> /// 写入所有文本行 /// </summary> /// <param name="stream"></param> /// <param name="lines"></param> /// <param name="encoding"></param> /// <param name="closeAfter">读取完毕后关闭流</param> /// <returns></returns> public static async Task WriteAllLinesAsync(this FileStream stream, IEnumerable <string> lines, Encoding encoding, bool closeAfter = true) { var sw = new StreamWriter(stream, encoding); stream.SetLength(0); foreach (var line in lines) { await sw.WriteLineAsync(line).ConfigureAwait(false); } await sw.FlushAsync().ConfigureAwait(false); if (closeAfter) { sw.Close(); stream.Close(); #if NET5_0_OR_GREATER await sw.DisposeAsync().ConfigureAwait(false); await stream.DisposeAsync().ConfigureAwait(false); #else sw.Dispose(); stream.Dispose(); #endif } }
private async Task <int> GetVisit() { string filepath = Path.Combine(Directory.GetCurrentDirectory(), conf.GetValue <string>("filePath")); FileStream fileStream = new FileStream(filepath, FileMode.Open); StreamReader reader; StreamWriter writer; int visit = 0; try { reader = new StreamReader(fileStream); string line = await reader.ReadLineAsync(); visit = int.Parse(line); fileStream.Flush(); reader.Close(); writer = new StreamWriter(filepath, append: false); await writer.WriteLineAsync((visit + 1).ToString()); await writer.DisposeAsync(); } catch (IOException e) { throw e; } finally { fileStream.Close(); } return(visit); }
public async ValueTask DisposeAsync() { await _buffer.FlushAsync(); await _writer.DisposeAsync(); await _buffer.DisposeAsync(); }
public async static void WriteAsync(string path, string value) { using StreamWriter streamWriter = new StreamWriter(path, true); await streamWriter.WriteLineAsync(value); streamWriter.Close(); await streamWriter.DisposeAsync(); }
public void DisposeAsync_CanDisposeAsyncAfterDispose() { var ms = new MemoryStream(); var sw = new StreamWriter(ms); sw.Dispose(); Assert.True(sw.DisposeAsync().IsCompletedSuccessfully); }
public async Task ExecuteResultAsync(ActionContext context) { context.HttpContext.Response.ContentType = "text/plain"; var streamWriter = new StreamWriter(context.HttpContext.Response.Body); await streamWriter.WriteAsync(this._value); await streamWriter.DisposeAsync(); }
public async Task RequestBodyAlwaysEmptyAfterUpgrade() { const string send = "Custom protocol send"; const string recv = "Custom protocol recv"; var upgrade = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously); using (var server = new TestServer(async context => { try { var feature = context.Features.Get <IHttpUpgradeFeature>(); var stream = await feature.UpgradeAsync(); var buffer = new byte[128]; var read = await context.Request.Body.ReadAsync(buffer, 0, 128).DefaultTimeout(); Assert.Equal(0, read); using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) { var line = await reader.ReadLineAsync(); Assert.Equal(send, line); await writer.WriteLineAsync(recv); await writer.FlushAsync(); await writer.DisposeAsync(); } upgrade.TrySetResult(true); } catch (Exception ex) { upgrade.SetException(ex); throw; } }, new TestServiceContext(LoggerFactory))) { using (var connection = server.CreateConnection()) { await connection.SendEmptyGetWithUpgrade(); await connection.Receive("HTTP/1.1 101 Switching Protocols", "Connection: Upgrade", $"Date: {server.Context.DateHeaderValue}", "", ""); await connection.Send(send + "\r\n"); await connection.Receive(recv); await upgrade.Task.DefaultTimeout(); } await server.StopAsync(); } }
public static async Task WriteToFileAsync(this string path, string content, bool WithCheck = false) { StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8, 8192); if (WithCheck && sw.BaseStream.CanRead) { StreamReader sr = new StreamReader(path); if (await sr.ReadToEndAsync() == content) { await sw.DisposeAsync(); sr.Dispose(); return; } } await sw.WriteAsync(content); await sw.DisposeAsync(); }
public override async ValueTask DisposeAsync() { if (disposed) { return; } disposed = true; await base.DisposeAsync(); await logStream.DisposeAsync(); }
public override async ValueTask DisposeAsync() { await base.DisposeAsync(); #if !DEBUG if (_logStream is not null) { await _logStream.DisposeAsync(); } #endif }
public async ValueTask DisposeAsync() { using (await AsyncLock.GetLockByKey(_reportFilePath).GetReleaserAsync()) { await _streamWriter.DisposeAsync(); if (!ReportIsNotEmpty) { await _blobStorageProvider.RemoveAsync(new[] { _reportFilePath }); } } }
public async Task Mask( string inputFilePath, string outputFilePath, IEnumerable <int> columnIndexToMask, char delimiter = ',', bool isFirstRowHeader = true, Func <IEnumerable <string>, bool> skipRow = null) { TextFieldParser parser = null; StreamWriter outputFile = null; try { parser = ReadFileWithParser(inputFilePath, delimiter); outputFile = OpenFile(outputFilePath); while (!parser.EndOfData) { if (isFirstRowHeader && parser.LineNumber == 1) { var header = parser.ReadFields(); await WriteOutputFile(header, delimiter, outputFile); } var tokens = parser.ReadFields(); if (skipRow?.Invoke(tokens) == true) { continue; } foreach (var col in columnIndexToMask) { var token = tokens.ElementAt(col); var masked = algorithm.Mask(token); tokens.SetValue(masked, col); } await WriteOutputFile(tokens, delimiter, outputFile); } } finally { if (parser != null) { parser.Close(); } if (outputFile != null) { await outputFile.DisposeAsync(); } } }
public async Task WriteLog(string log) { // Revize string filename = DateTime.Now.ToShortDateString(); string path = Path.Combine(@"wwwroot/logs/" + filename + ".txt"); using (var stream = new StreamWriter(path, true)) { stream.WriteLine(DateTime.Now + " " + log); stream.Close(); await stream.DisposeAsync(); } }
public async void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { var logPath = configuration["logPath:logPathTxt"]; if (!System.IO.File.Exists(logPath)) { using var tw = new StreamWriter(logPath); } using StreamWriter streamWriter = new StreamWriter(logPath, true); await streamWriter.WriteLineAsync($"{DateTime.Now} --> Log Level : {logLevel} | Event ID : {eventId.Id} | Event Name : {eventId.Name} | Formatter : {formatter(state, exception)}"); streamWriter.Close(); await streamWriter.DisposeAsync(); }
public async Task DisposeAsync_LeaveOpenTrue_LeftOpen() { var ms = new MemoryStream(); var sw = new StreamWriter(ms, Encoding.ASCII, 0x1000, leaveOpen: true); try { sw.Write("hello"); } finally { await sw.DisposeAsync(); } Assert.Equal(5, ms.Position); // doesn't throw }
public static async Task WriteJson(this FileMetadata[] metadata, Stream stream) { if (metadata is null) { throw new ArgumentNullException(nameof(metadata)); } if (stream is null) { throw new ArgumentNullException(nameof(stream)); } using var sw = new StreamWriter(stream); await sw.WriteLineAsync(JsonConvert.SerializeObject(metadata, Formatting.Indented)); await sw.DisposeAsync(); }
public async Task ExecuteAsync(Stream stream) { // We technically don't need this intermediate buffer if this method accepts a memory stream. var buffer = new MemoryStream(); Output = new StreamWriter(buffer, UTF8NoBOM, 4096, leaveOpen: true); await ExecuteAsync(); await Output.FlushAsync(); await Output.DisposeAsync(); buffer.Seek(0, SeekOrigin.Begin); await buffer.CopyToAsync(stream); }
/// <summary> /// Asynchronously ends the server connection /// </summary> public async Task EndAsync() { Status = StatusFlag.NotActive; try { await netSWriter.DisposeAsync(); netSReader.Dispose(); await netStream.DisposeAsync(); tcpClient.Dispose(); tcpListener.Stop(); } catch (Exception e) { throw new _Exception.Session.EndAsync("Failed to end the session!", e); } }
public async Task ExecuteResultAsync(ActionContext context) { var wrappedStream = context.HttpContext.Response.Body; using (var stream = new MemoryStream()) using (var streamReader = new StreamReader(stream, Encoding.UTF8)) { context.HttpContext.Response.Body = stream; string html = null; try { await _wrappedActionResult.ExecuteResultAsync(context); stream.Seek(0, SeekOrigin.Begin); { html = (await streamReader.ReadToEndAsync()).Trim(); } } finally { context.HttpContext.Response.Body = wrappedStream; } // Check for not XML if (IsHtmlContent(context, html)) { var headScript = _visualEditorScriptGenerator.CreateHeadScript(); var bodyScript = await _visualEditorScriptGenerator.CreateBodyScriptAsync(context); html = _htmlDocumentScriptInjector.InjectScripts(html, headScript, bodyScript); } var outputStream = new StreamWriter(wrappedStream, Encoding.UTF8, 1024, true); try { await outputStream.WriteAsync(html); await outputStream.FlushAsync(); } finally { // The "using" pattern would cause a sync flush which throws an error in NET Core 3.1 await outputStream.DisposeAsync(); } } }
public async Task ExecuteAsync(HttpContext context) { Context = context; Request = Context.Request; Response = Context.Response; var buffer = new MemoryStream(); Output = new StreamWriter(buffer, UTF8NoBOM, 4096, leaveOpen: true); await ExecuteAsync(); await Output.FlushAsync(); await Output.DisposeAsync(); buffer.Seek(0, SeekOrigin.Begin); await buffer.CopyToAsync(Response.Body); }
public async Task DisposeAsync_FlushesStream() { var ms = new MemoryStream(); var sw = new StreamWriter(ms); try { sw.Write("hello"); Assert.Equal(0, ms.Position); } finally { await sw.DisposeAsync(); } Assert.Throws <ObjectDisposedException>(() => ms.Position); Assert.Equal(5, ms.ToArray().Length); }
public static async Task <byte[]> GetCsvByteArrayAsync <T>(this IEnumerable list) where T : ClassMap { MemoryStream ms = null; StreamWriter writer = null; CsvWriter csv = null; try { var config = new CsvConfiguration(CultureInfo.InvariantCulture) { SanitizeForInjection = true }; ms = new MemoryStream(); writer = new StreamWriter(ms, Encoding.UTF8); csv = new CsvWriter(writer, config); csv.Context.RegisterClassMap <T>(); await csv.WriteRecordsAsync(list); await csv.FlushAsync(); await writer.FlushAsync(); await ms.FlushAsync(); return(ms.ToArray()); } finally { if (csv != null) { await csv.DisposeAsync(); } if (writer != null) { await writer.DisposeAsync(); } if (ms != null) { await ms.DisposeAsync(); } } }