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