/// <summary>
/// Обеспечивает сохранение в файл тремя способами.
/// </summary>
/// <param name="path">Полный путь до файла для записи.</param>
/// <param name="append">true для добавления данных в файл, false для перезаписи.</param>
/// <param name="writeHeaders"></param>
/// <returns>Задача, представляющая асинхронную операцию записи в файл.</returns>
private async System.Threading.Tasks.Task Save(string path, bool append = false, bool writeHeaders = true)
{
if (fileOpened)
{
Cursor.Current = Cursors.WaitCursor;
using (var writer = new System.IO.StreamWriter(path, append, System.Text.Encoding.Unicode))
{
if (writeHeaders)
{
foreach (var header in Headers)
{
await writer.WriteAsync($"{header};");
}
await writer.WriteLineAsync();
}
foreach (var item in clinicSource)
{
await writer.WriteLineAsync(item.ToString());
}
}
Cursor.Current = Cursors.Default;
}
else
{
if (MessageBox.Show(Resources.StartForm_Save_File_Not_Opened__Openь_, Resources.StartForm_Save_Saving_Error, MessageBoxButtons.YesNo, MessageBoxIcon.Error) != DialogResult.Yes)
{
return;
}
OpenToolStripMenuItem_Click(this, EventArgs.Empty);
}
}
private async void App_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
{
using var fs = new System.IO.FileStream($"{DateTime.Now:yyyy-MM-dd_HH+mm+ss}.log", System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.Read);
using var sw = new System.IO.StreamWriter(fs);
await sw.WriteLineAsync(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:ms"));
await sw.WriteLineAsync(e.Exception.ToString());
MessageBox.Show($"异常信息: {e.Exception}", "内部错误");
}
static StackObject *WriteLineAsync_16(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 4);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Int32 @count = ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.Int32 @index = ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 3);
System.Char[] @buffer = (System.Char[]) typeof(System.Char[]).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 4);
System.IO.StreamWriter instance_of_this_method = (System.IO.StreamWriter) typeof(System.IO.StreamWriter).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.WriteLineAsync(@buffer, @index, @count);
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
private async void saveUsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (SaveFileDialog sfd = new SaveFileDialog()
{
Filter = "JEPG Document|*.Jpeg", ValidateNames = true
})
{
if (sfd.ShowDialog() == DialogResult.OK)
{
try
{
s = sfd.FileName;
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(sfd.FileName))
{
await sw.WriteLineAsync(s);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
surface.Save(s);
s += i;
i++;
}
private async Task TestAsyncOperationSwitchToPoolInner(StaticThreadPool testInst)
{
Assert.IsFalse(testInst.IsThreadPoolThread);
System.IO.StreamWriter writer = null;
string fileName = Guid.NewGuid().ToString().Replace('-', '_');
try
{
writer = new System.IO.StreamWriter(new System.IO.FileStream(fileName, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.ReadWrite, 128, true));
await testInst.SwitchToPool();
Assert.IsTrue(testInst.IsThreadPoolThread);
string longString = "test test test test test test test test test test test test";
for (int i = 0; i < 10; i++)
{
longString += longString;
}
await writer.WriteLineAsync(longString);
Assert.IsTrue(testInst.IsThreadPoolThread);
}
finally
{
if (writer != null)
{
writer.Close();
}
System.IO.File.Delete(fileName);
}
}
public static async Task <bool> WriteToFileAsync(string filePath, string contents, bool supressLogMessage = true)
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
using (System.IO.FileStream stream = new System.IO.FileStream(filePath, System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.Write, 4096, true))
{
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(stream))
{
await sw.WriteLineAsync(contents);
if (!supressLogMessage)
{
Log.Here().Activity("Saved file: {0}", filePath);
}
}
}
return(true);
}
catch (Exception e)
{
Log.Here().Error("Error saving file at {0} - {1}", filePath, e.ToString());
return(false);
}
}
public async static Task <string> Flush()
{
if (Trace.Length > 0)
{
if (EnableDebugingLog)
{
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(DebugLogPath, true))
{
await writer.WriteLineAsync(Trace.ToString());
}
}
else
{
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(ErrorLogPath, true))
{
await writer.WriteLineAsync(Trace.ToString());
}
}
}
string result = Trace.ToString();
Trace.Clear();
return(await Task.FromResult(result));
}
private void WriteToOutFile(string data)
{
if (null != _outFile)
{
_outFile.WriteLineAsync(data);
}
}
public static async Task <bool> WriteToFileAsync(List <Task <string> > CList)
{
//var task = Task.Run(async() =>
//{
System.IO.StreamWriter sw = new System.IO.StreamWriter("OutPut.txt", true, Encoding.UTF8);
try
{
foreach (var tk in CList)
{
Console.WriteLine($"Begin reading ThreadID:{System.Threading.Thread.CurrentThread.ManagedThreadId}");
string str = await tk;
await sw.WriteLineAsync(str);
}
}
catch (Exception ex)
{
log4net.LogManager.GetLogger(typeof(Program)).Error("Write To File Error.", ex);
return(false);
}
finally
{
sw.Flush();
sw.Close();
}
return(true);
//});
//return await task;
}
/// <summary>
/// Sends an EOL-terminated message to the server (\n is appended by this method)
/// </summary>
/// <param name="format">Format of message to send</param>
/// <param name="formatParameters">Format parameters</param>
/// <returns></returns>
public async Task <bool> SendRawMessage(String message)
{
try
{
await _streamSemaphore.WaitAsync();
await streamWriter.WriteLineAsync(message);
await streamWriter.FlushAsync();
}
catch (Exception e)
{
Exception = e;
if (OnException != null)
{
foreach (var d in OnException.GetInvocationList())
{
var task = Task.Run(() => d.DynamicInvoke(this, e));
}
}
return(false);
}
finally { _streamSemaphore.Release(); }
if (OnRawMessageSent != null)
{
foreach (var d in OnRawMessageSent.GetInvocationList())
{
var task = Task.Run(() => d.DynamicInvoke(this, message));
}
}
return(true);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
///Скрываем исключения от пользовател
app.UseExceptionHandler(appBuilder
=> appBuilder.Run(async context =>
{
var errorFeature = context.Features.Get <IExceptionHandlerFeature>();
var unhandledException = errorFeature?.Error;
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
this._exceptionLog.WriteLn("----->ERROR Не обработканная ошибка: {" + (int)HttpStatusCode.InternalServerError + "} " + unhandledException.Message, unhandledException);
using (var streamWriter = new System.IO.StreamWriter(context.Response.Body))
{
await streamWriter.WriteLineAsync(unhandledException?.Message ?? string.Empty);
}
}));
if (!env.IsDevelopment())
{
app.UseHsts();
}
//TODO нет пока HTTPS
//добавляет для проекта переадресацию на тот же ресурс только по протоколу https
//app.UseHttpsRedirection();
// чтобы приложение могло бы отдавать статические файлы клиенту
app.UseStaticFiles();
app.UseSpaStaticFiles();
app.UseAuthentication(); // система аутентификации
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
app.UseSignalR(routes =>
{
routes.MapHub <Hubs.DataImport.DataImportHub>("/dataimport/hub");
routes.MapHub <Hubs.Files.FilesHub>("/files/hub");
});
app.UseCors("SiteCorsPolicy"); // это тоже для нескольких портов(см. выше)
app.UseSpa(spa =>
{
// To learn more about options for serving an Angular SPA from ASP.NET Core,
// see https://go.microsoft.com/fwlink/?linkid=864501
spa.Options.SourcePath = "ClientApp";
if (env.IsDevelopment())
{
spa.UseAngularCliServer(npmScript: "start");
}
});
}
// Main entry point in the escalation where it will perform its custom operations
public override async Task RunAsync(EscalationProperties properties)
{
// Implement custom escalation details here. Send notifications, update services, etc
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\temp\HelloWorld.txt", true))
{
await file.WriteLineAsync(DateTime.Now.ToString());
}
}
public static void Log(Exception ex, string source)
{
System.IO.StreamWriter file = new System.IO.StreamWriter(HttpContext.Current.Server.MapPath("~/Log.txt"));
string logText = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss tt") + " | Message: " + ex.Message + " | Source: " + source;
file.WriteLineAsync(logText);
}
// 创建用户
public async Task CreateAsync(UserIdentity user)
{
user.Id = Guid.NewGuid().ToString();
using (var stream = new System.IO.StreamWriter(_filePath, true, Encoding.UTF8))
{
await stream.WriteLineAsync(user.ToString());
}
}
//Button Speichern
private async void Button_speichern_Click(object sender, RoutedEventArgs e)
{
speicherpfad = await savepath();
progressBar_Lade.Value = 0;
if (listBox_Daten.Items.Count == 0)
{
//Ausgabe, sollte Liste noch leer sein
label_TextAusgabe.Content = "keine Daten vorhanden";
return;
}
if (speicherpfad == string.Empty)
{
return;
}
writer = new System.IO.StreamWriter(speicherpfad);
List <string> liste = new List <string>();
//Daten in Listbox werden in Liste gespeichert (zum Sortieren)
foreach (string str in listBox_Daten.Items)
{
liste.Add(str);
}
//Liste wird sortiert
liste.Sort();
//Sortierung auf absteigend
liste.Reverse();
progressBar_Lade.Maximum = listBox_Daten.Items.Count;
label_TextAusgabe.Content = "wird gespeichert...";
try
{
//Daten werden gespeichert
foreach (string text in liste)
{
await writer.WriteLineAsync(text);
progressBar_Lade.Value++;
}
}
catch (Exception ex)
{
label_TextAusgabe.Content = ex.Message;
}
//nach dem Speichern wird die Liste geleert
finally
{
writer.Close();
label_TextAusgabe.Content = "Daten gespeichert in " + speicherpfad;
button_speichern.IsEnabled = false;
liste.Clear();
}
}
private void SaveTofile(string username)
{
var backingFile = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "userdata.txt");
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(backingFile, true))
{
writer.WriteLineAsync(username.ToString());
}
}
// 创建用户
public async Task CreateAsync(IdentityUser user)
{
user.Id = Guid.NewGuid().ToString();
using (var stream = new System.IO.StreamWriter(_filePath, true, Encoding.UTF8))
{
await stream.WriteLineAsync(user.ToString());
}
}
public async Task Handler(EventFromMicroserviceA _event)
{
string eventReceive = JsonConvert.SerializeObject(_event);
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"..\MicroserviceB\EventMessage.txt", true))
{
await file.WriteLineAsync(eventReceive);
}
}
public async Task WriteLineAsync(string filePath, List <string> list)
{
using (var writer = new System.IO.StreamWriter(filePath))
{
foreach (var line in list)
{
await writer.WriteLineAsync(line);
}
}
}
public static void SaveGrid(this Grid grid, string path)
{
using (var saver = new System.IO.StreamWriter(path + @"\SavedGame.txt", true))
{
saver.WriteLineAsync($"Time: {DateTime.Now}");
foreach (var cell in grid.Cells)
{
if (cell.Digit == null)
{
saver.WriteAsync('.');
}
else
{
var digit = (char)((int)cell.Digit + '1');
saver.WriteAsync(digit);
}
}
saver.WriteLineAsync();
}
}
public static async void createList(List <User> usr)
{
using (System.IO.StreamWriter sw = System.IO.File.CreateText(Environment.CurrentDirectory + $@"\Scraped_Users_{DateTime.Now.ToShortDateString().Replace('/', '-')}.txt"))
{
sw.AutoFlush = true;
for (int i = 0; i < usr.Count; i++)
{
await sw.WriteLineAsync(usr[i].Username);
}
}
}
private async Task SaveToJson(IList <Artikel> artikels)
{
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"C:\temp\IreckonuData.json", true))
{
foreach (var artikel in artikels)
{
await file.WriteLineAsync(Newtonsoft.Json.JsonConvert.SerializeObject(artikel));
}
}
}
private async void SaveResult_Click(object sender, EventArgs e)
{
using (System.IO.StreamWriter MHA_write = new System.IO.StreamWriter("MHA_training", true))
{
List <TextBox> textBoxes = new List <TextBox> {
Squats_textBox, PushUps_textBox, PullUps_textBox, HangingLeg_textBox, InnerBiceps_textBox, Press_textBox
};
string my_training = DateTime.Now.ToString();
textBoxes.ForEach(delegate(TextBox textBox) { my_training += "$" + textBox.Text; });
await MHA_write.WriteLineAsync(my_training);
}
}
public async Task <bool> ImageMonitor(MiraiHttpSession session, IGroupMessageEventArgs e)
{
var chain = e.Chain;
foreach (var msg in chain)
{
if (msg is ImageMessage image)
{
await using var file = new System.IO.StreamWriter("ImageMonitor.txt", true);
await file.WriteLineAsync($"{DateTime.Now.ToLongTimeString()} {e.Sender.Group.Id} {e.Sender.Id} {e.Sender.Name} {image.Url}");
}
}
return(false);
}
/// <summary>
/// Appends lines to a file, and then closes the file.
/// </summary>
/// <param name="file">The file to write to</param>
/// <param name="contents">The content to write to the file</param>
/// <returns>A task which completes when the write operation finishes</returns>
///
public static async Task AppendAllLinesAsync(this IFile file, IEnumerable <string> contents)
{
using (var stream = await file.OpenAsync(FileAccess.ReadAndWrite).ConfigureAwait(false))
{
stream.Seek(stream.Length, System.IO.SeekOrigin.Begin);
using (var sw = new System.IO.StreamWriter(stream))
{
foreach (var content in contents)
{
await sw.WriteLineAsync(content).ConfigureAwait(false);
}
}
}
}
public async Task ToLogFile(System.IO.Stream output)
{
await FileUploadsFinished;
var fileLogEntries = AllFileResults.Select(file => new { Time = file.ProcessedAt, LogLine = file.ToLogString() });
var folderLogEntries = AllFolderResults.Select(folder => new { Time = folder.ProcessedAt, LogLine = folder.ToLogString() });
var sorted = fileLogEntries.Concat(folderLogEntries).OrderBy(logEntry => logEntry.Time);
using (var wr = new System.IO.StreamWriter(output))
{
foreach (string line in sorted.Select(logEntry => logEntry.LogLine))
{
await wr.WriteLineAsync(line);
}
}
}
private async Task SaveLogMessageToFile(string message)
{
System.IO.Directory.CreateDirectory(PathConstans.TRACE_FILTER_LOG_PATH);
using (System.IO.StreamWriter file = System.IO.File.AppendText(string.Format("{0}\\{1}.txt", PathConstans.TRACE_FILTER_LOG_PATH, DateTime.Now.Date.ToShortDateString())))
{
try
{
await file.WriteLineAsync(message);
}
finally //Clean resource after write text
{
file.Close();
}
}
}
private static async System.Threading.Tasks.Task fileLogAsync(string message, string entryType = "DEBUG")
{
if (CurrentLogLevel == LogLevel.Debug)
{
using (IsolatedStorageFile isoFile = GetIsolatedStorageFile()) {
await logFileLock.WaitAsync();
try {
//IsolatedStorage will be something like: C:\WINDOWS\system32\config\systemprofile\AppData\Local\IsolatedStorage\arpzpldm.neh\4hq14imw.y2b\Publisher.5yo4swcgiijiq5te00ddqtmrsgfhvrp4\AssemFiles\
using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(ApplicationName + ".log", System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.Read, isoFile)) {
//stream.Seek(0, System.IO.SeekOrigin.End);
if (debugLogEventCount == 0)
{
try {
string path = stream.GetType().GetField("m_FullPath", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(stream).ToString();
if (logToEventLog && eventLogWriteEntryAction != null)
{
await System.Threading.Tasks.Task.Run(() => eventLogWriteEntryAction("Saving debug log to " + path, EventLogEntryType.Information));
}
else
{
await ConsoleLogAsync("Saving debug log to " + path, EventLogEntryType.Information);
}
}
catch { }
}
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(stream)) {
await writer.WriteLineAsync(DateTime.UtcNow.ToString("s", System.Globalization.CultureInfo.InvariantCulture) + "\t[" + entryType + "]\t" + message);
}
}
}
catch (System.IO.IOException e) {
if (debugLogEventCount == 0 && eventLogWriteEntryAction != null)
{
await System.Threading.Tasks.Task.Run(() => eventLogWriteEntryAction(e.Message, EventLogEntryType.Error));
}
}
catch (System.NullReferenceException) {
LogToFile = false;
}
finally {
logFileLock.Release();
System.Threading.Interlocked.Increment(ref debugLogEventCount);
}
}
}
}
public async Task PutAsync(string Id, IAppointment Document)
{
try
{
string fn = Filename(Id);
using (var writer = new System.IO.StreamWriter(fn))
{
string docSer = Newtonsoft.Json.JsonConvert.SerializeObject(Document);
await writer.WriteLineAsync(docSer);
}
}
catch (Exception ex)
{
mko.TraceHlp.ThrowEx("Schreiben des Terminsmit der ID " + Id + " fehlgeschlagen. Termin: " + Document, ex);
}
}
private async Task WriteLineAsync(string text, bool append = true)
{
try
{
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(logFilename, append, Encoding.UTF8))
{
if (!string.IsNullOrEmpty(text))
{
await writer.WriteLineAsync(text);
}
}
}
catch
{
throw;
}
}
/// <summary>
/// Opens a file, appends the specified string to the file, and then closes the file.
/// </summary>
/// <param name="file">The file to write to</param>
/// <param name="contents">The content to write to the file</param>
/// <returns>A task which completes when the write operation finishes</returns>
public static async Task AppendAllTextAsync(this IFile file, string contents)
{
try
{
using (var stream = await file.OpenAsync(FileAccess.ReadAndWrite).ConfigureAwait(false))
{
stream.Seek(stream.Length, System.IO.SeekOrigin.Begin);
using (var sw = new System.IO.StreamWriter(stream))
{
//await sw.WriteAsync(contents).ConfigureAwait(false);
await sw.WriteLineAsync(contents).ConfigureAwait(false);
}
}
}
catch (Exception)
{
}
}
public override async System.Threading.Tasks.Task WriteToStreamAsync(Type type, object value, System.IO.Stream writeStream, HttpContent content, System.Net.TransportContext transportContext)
{
var agents = value as IEnumerable<Agent>;
using (var writer = new System.IO.StreamWriter(writeStream))
{
// Write the CSV header
writer.WriteLine("First name,Last name,Link");
if (agents != null)
{
UrlHelper url = _request.GetUrlHelper();
// Write the CSV content
foreach (var agent in agents)
{
string agentUrl = url.Link("DefaultApi", new { id = agent.AgentID });
await writer.WriteLineAsync(string.Format("{0},{1},{2}", agent.FirstName, agent.LastName, agentUrl));
}
}
}
}