| public WriteLineAsync ( ) : System.Threading.Tasks.Task | ||
| return | System.Threading.Tasks.Task | |
// чтение данных из текстового файла
private void ReadDaysFromDatabase()
{
try
{
using (var reader = new StreamReader(Environment.CurrentDirectory + DataFile))
{
uint allBudget, costsCount;
UInt32.TryParse(reader.ReadLine(), out allBudget);
UInt32.TryParse(reader.ReadLine(), out costsCount);
_allBudget = allBudget;
for (var i = 0; i < costsCount; i++)
{
var costsString = reader.ReadLine();
var date = reader.ReadLine();
uint costs;
UInt32.TryParse(costsString, out costs);
_days.Add(new Day(DateTime.Parse(date), costs));
}
}
}
catch (Exception)
{
// файл с данными не существует - создадим его
using (var writer = new StreamWriter(Environment.CurrentDirectory + DataFile))
{
// бюждет - незвестен
// кол-во трат - неизвестно
writer.WriteLineAsync("0");
writer.WriteLineAsync("0");
}
}
}
public override async Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContent content, TransportContext transportContext)
{
using (stream)
{
Encoding encoding = SelectCharacterEncoding(content.Headers);
using (var writer = new StreamWriter(stream, encoding))
{
var individuals = value as IEnumerable<Individual>;
if (individuals != null)
{
foreach (var individu in individuals)
{
await writer.WriteLineAsync(String.Format("{0,-10};{1,-10};{2,-10}", individu.Id, individu.FirstName, individu.LastName));
}
await writer.FlushAsync();
}
var individual = value as Individual;
if (individual != null)
{
await writer.WriteLineAsync(String.Format("{0,-10};{1,-10};{2,-10}", individual.Id, individual.FirstName, individual.LastName));
await writer.FlushAsync();
}
}
}
}
private static async Task WorkAsync(Channel channel)
{
using (channel)
{
using (var reader = new StreamReader(channel))
{
using (var writer = new StreamWriter(channel))
{
string request = await reader.ReadLineAsync();
await writer.WriteLineAsync(request);
await writer.FlushAsync();
request = await reader.ReadLineAsync();
await writer.WriteLineAsync(request);
await writer.FlushAsync();
Console.WriteLine("Server waiting for close");
if (reader.EndOfStream)
{
Console.WriteLine("Server feel right!");
}
await channel.StopSendingAsync();
await channel.FlushAsync();
}
}
}
}
private async void ClientWork(object state)
{
int clientId = (int)state;
using (var channel = this.connection.ConnectChannel())
{
using (StreamWriter writer = new StreamWriter(channel))
{
using (StreamReader reader = new StreamReader(channel))
{
string request = string.Format("Hello from {0}", clientId);
string response;
await writer.WriteLineAsync(request);
await writer.FlushAsync();
response = await reader.ReadLineAsync();
await writer.WriteLineAsync(request);
await writer.FlushAsync();
response = await reader.ReadLineAsync();
await channel.StopSendingAsync();
await channel.FlushAsync();
if (reader.EndOfStream)
{
Console.WriteLine("Client feel right!");
}
}
}
}
if (Interlocked.Decrement(ref pendingCount) == 0)
{
lock (termLock)
{
Monitor.Pulse(termLock);
}
}
}
public static async Task ReadOutChannels(XmlTvReader reader, StreamWriter resultsFileStream)
{
var channels = reader.GetChannels().Distinct().ToList();
resultsFileStream.Write(EntityExtensions.GetHeader("Channels"));
foreach (var channel in channels)
{
System.Console.WriteLine("Retrieved Channel: {0} - {1}", channel.Id, channel.DisplayName);
resultsFileStream.Write(channel.GetChannelDetail());
}
var totalProgrammeCount = 0;
resultsFileStream.Write("\r\n");
foreach (var channel in channels)
{
System.Console.WriteLine("Processing Channel: {0}", channel.DisplayName);
resultsFileStream.Write(EntityExtensions.GetHeader("Programs for " + channel.DisplayName));
var channelProgrammeCount = await ReadOutChannelProgrammes(reader, channel, resultsFileStream);
totalProgrammeCount += channelProgrammeCount;
await resultsFileStream.WriteLineAsync(String.Format("Total Programmes for {1}: {0}", channelProgrammeCount, channel.DisplayName));
}
await resultsFileStream.WriteLineAsync(String.Format("Total Programmes: {0}", totalProgrammeCount));
}
public async Task Save(string path, BlackHoleGameTable gameTable)
{
try
{
using (StreamWriter writer = new StreamWriter(path))
{
// save the game status and details
writer.Write(gameTable.TableSize + " ");
await writer.WriteAsync(gameTable.GameStatus + " ");
await writer.WriteAsync(gameTable.CoordinatesOfChosenField.Item1 + " " + gameTable.CoordinatesOfChosenField.Item2 + " ");
await writer.WriteAsync(gameTable.IsGameActive + " ");
await writer.WriteAsync(gameTable.PlayerAScore + " ");
await writer.WriteAsync(gameTable.PlayerBScore + "");
// save the game table values
await writer.WriteLineAsync();
for (Int32 row = 0; row < gameTable.TableSize; ++row)
{
for (Int32 column = 0; column < gameTable.TableSize; ++column)
{
await writer.WriteAsync(gameTable[row, column] + " ");
}
await writer.WriteLineAsync();
}
}
}
catch
{
throw new BlackHoleGameDataException("Save file path is wrong.");
}
}
public async Task DoSomethingWithClientAsync()
{
try
{
using (var stream = _client.GetStream())
{
using (var sr = new StreamReader(stream))
using (var sw = new StreamWriter(stream))
{
await sw.WriteLineAsync("Hi. This is x2 TCP/IP easy-to-use server").ConfigureAwait(false);
await sw.FlushAsync().ConfigureAwait(false);
var data = default(string);
while (!((data = await sr.ReadLineAsync().ConfigureAwait(false)).Equals("exit", StringComparison.OrdinalIgnoreCase)))
{
await sw.WriteLineAsync(data).ConfigureAwait(false);
await sw.FlushAsync().ConfigureAwait(false);
}
}
}
}
finally
{
if (_ownsClient && _client != null)
{
(_client as IDisposable).Dispose();
_client = null;
}
}
}
public static async Task WriteTo(IHttpHeaders headers, Stream stream)
{
#if PCL && !ASYNC_PCL
var writer = new StreamWriter(new NonDisposableStream(stream), Encoding.UTF8, 128);
#else
var writer = new StreamWriter(stream, Encoding.UTF8, 128, true);
#endif
try
{
writer.NewLine = "\r\n";
if (headers != null)
{
foreach (var header in headers)
{
await
writer.WriteLineAsync($"{header.Key}: {string.Join(", ", header.Value)}");
}
}
await writer.WriteLineAsync();
}
finally
{
writer.Dispose();
}
}
private async Task ProcessQueue(string queue)
{
try
{
var events = MessageQueue.GetBatch<PerfEvent>(queue)
.ToList();
// Group by hour
var groups = events.GroupBy(e => new { e.TimestampUtc.Date, e.TimestampUtc.Hour });
await Task.WhenAll(groups.Select(async group =>
{
if (group.Any())
{
string dir = Path.Combine(LogDirectory, queue);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
// Determine the file name for the log
string fileName = Path.Combine(
dir,
String.Format("{0:yyyyMMdd}{1}.csv", group.Key.Date, group.Key.Hour));
// Append to the log
using (var strm = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.None))
using (var writer = new StreamWriter(strm))
{
foreach (var evt in group)
{
var fields = evt.Fields.OrderBy(p => p.Key);
if (strm.Length == 0)
{
await writer.WriteLineAsync(
"Source,Timestamp,Duration," + String.Join(",", fields.Select(f => f.Key)));
await writer.FlushAsync();
}
await writer.WriteLineAsync(
CsvEscape(evt.Source) + "," +
CsvEscape(evt.TimestampUtc.ToString("O")) + "," +
CsvEscape(evt.Duration.TotalMilliseconds.ToString("0.00")) + "," +
String.Join(",", fields.Select(f => CsvEscape(f.Value == null ? String.Empty : f.Value.ToString()))));
}
}
}
}));
}
catch (Exception)
{
throw;
}
}
public static async void LogUnhandledException(Exception e)
{
var logsFolder = await ApplicationData.Current.LocalFolder
.CreateFolderAsync("Logs", CreationCollisionOption.OpenIfExists);
var file = await logsFolder.CreateFileAsync(String.Format("{0}.log", DateTime.Now.Ticks));
var stream = await file.OpenStreamForWriteAsync();
using (var writer = new StreamWriter(stream))
{
await writer.WriteLineAsync(e.Message);
if (e.StackTrace != null)
await writer.WriteLineAsync(e.StackTrace);
}
}
protected async Task Listen(Socket socket) {
Stream ioStream = socket.GetStream();
StreamReader reader = new StreamReader(ioStream);
StreamWriter writer = new StreamWriter(ioStream);
await writer.WriteLineAsync(FtpResponse.PositiveCompletionReply.ServiceReady.ToString());
await writer.FlushAsync();
string command;
while (true) {
string result = await RunCommand(await reader.ReadLineAsync());
await writer.WriteLineAsync(result);
await writer.FlushAsync();
}
}
public async Task Invoke(IDictionary<string, object> environment)
{
var response = environment["owin.ResponseBody"] as Stream;
using (var writer = new StreamWriter(response))
{
await writer.WriteLineAsync(string.Format("Demo Component!", _options.Name));
foreach (var option in _options.MoreOptions)
{
_next.Invoke(environment);
Console.WriteLine("I hope this works");
await writer.WriteLineAsync(string.Format("Option: {0}", option));
}
}
}
public static void LogError(string error)
{
string appPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
if (appPath != null)
{
string configFile = Path.Combine(appPath, "errorlogs.txt");
var file = new StreamWriter(configFile, true);
file.WriteLineAsync("-----------------");
file.WriteLine(error);
file.WriteLineAsync("---------------------");
file.Close();
Console.WriteLine("Error=>{0}", error);
}
}
public async Task Invoke(IDictionary<string, object> environment)
{
var response = environment["owin.ResponseBody"] as Stream;
if (response != null)
using (var writer = new StreamWriter(response))
{
await writer.WriteLineAsync(string.Format("Hello {0}!", _options.Name));
foreach (var option in _options.MoreOptions)
{
//_next.Invoke(environment);
await writer.WriteLineAsync(string.Format("Option: {0}", option));
}
}
}
private async void SaveTokens_FileOk(object sender, CancelEventArgs e)
{
var cardsList = await Task.Run(() => { return this.tokenizationService.GetEntries().OrderBy(x => x.Token); });
var filename = (sender as SaveFileDialog).FileName;
using (StreamWriter sw = new StreamWriter(filename))
{
await sw.WriteLineAsync(string.Format("{0,-16} - {1,-16}", "Token", "Card number"));
foreach (var item in cardsList)
{
await sw.WriteLineAsync(string.Format("{0} - {1}", item.Token, item.CardNumber));
}
}
UnlockScreen();
}
/// <summary>
/// Saves the transmission to the specified <paramref name="stream"/>.
/// </summary>
internal static async Task SaveAsync(Transmission transmission, Stream stream)
{
var writer = new StreamWriter(stream);
try
{
await writer.WriteLineAsync(transmission.EndpointAddress.ToString()).ConfigureAwait(false);
await writer.WriteLineAsync(Transmission.ContentTypeHeader + ":" + transmission.ContentType).ConfigureAwait(false);
await writer.WriteLineAsync(Transmission.ContentEncodingHeader + ":" + transmission.ContentEncoding).ConfigureAwait(false);
await writer.WriteLineAsync(string.Empty).ConfigureAwait(false);
await writer.WriteAsync(Convert.ToBase64String(transmission.Content)).ConfigureAwait(false);
}
finally
{
writer.Flush();
}
}
public override void Handle()
{
using (var sw = new StreamWriter(@"D:\JobText.txt", true))
{
sw.WriteLineAsync(DateTime.Now.ToString());
}
}
/// <summary>
/// Writes the logevent to the log file async.
/// </summary>
/// <param name="args">The log event arguments.</param>
/// <exception cref="System.IO.IOException">Thrown if unable to write to file.</exception>
/// <returns>A Task object that can be used to listen for completion of the work.</returns>
public async Task OnLogEventAsync(LogArgs args)
{
using (StreamWriter sw = new StreamWriter(this.Filename, true, Encoding.UTF8))
{
await sw.WriteLineAsync(args.ToString());
}
}
private async Task Log(string value)
{
var logFile = ConfigurationManager.AppSettings["LogFile"];
if (string.IsNullOrWhiteSpace(logFile))
throw new Exception("Misconfigured Log File");
var replacement = ConfigurationManager.AppSettings["ReplaceWith"];
using (FileStream fs = new FileStream(logFile, FileMode.OpenOrCreate, FileSystemRights.AppendData, FileShare.Write, 4096, FileOptions.None))
using (StreamWriter sw = new StreamWriter(fs))
{
sw.AutoFlush = true;
if (!string.IsNullOrEmpty(replacement))
{
var sb = new StringBuilder(value);
sb.Replace(WindowsNL, replacement);
sb.Replace(RiscNL, replacement);
sb.Replace(UnixNL, replacement);
sb.Replace(MacNL, replacement);
value = sb.ToString();
}
await sw.WriteLineAsync(value);
}
}
async Task<string> SendRPCAsync(string methodName, params object[] args) {
var jsonArgs = new List<string>();
foreach(var arg in args) {
if(arg is string) {
jsonArgs.Add(String.Format("\"{0}\"", arg));
}
else {
jsonArgs.Add(arg.ToString());
}
}
var rpc = String.Format("{{\"id\": 1, \"method\": \"{0}\", \"params\": [{1}]}}", methodName, String.Join(", ", jsonArgs));
await ClientLock.WaitAsync();
try {
var writer = new StreamWriter(ClientStream);
await writer.WriteLineAsync(rpc);
await writer.FlushAsync();
var reader = new StreamReader(ClientStream);
return await reader.ReadLineAsync();
}
finally {
ClientLock.Release();
}
}
public static async Task ProcessStream(Stream networkStream)
{
try
{
StreamReader reader = new StreamReader(networkStream);
StreamWriter writer = new StreamWriter(networkStream);
writer.AutoFlush = true;
while (true)
{
string request = await reader.ReadLineAsync();
if (request != null)
{
Console.WriteLine("Received echo: " + request);
string echo_str = await CommandResolve.Resolve(request);
if (!String.IsNullOrEmpty(echo_str))
{
await writer.WriteLineAsync(echo_str);
}
else
break; // unvalid command or command complete
}
else
break; // Client closed connection
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task Write(string path)
{
using (var stream = new StreamWriter(path))
{
await stream.WriteLineAsync("#EXTM3U");
foreach (var track in tracklist.Tracks)
{
await stream.WriteLineAsync(string.Format("#EXTINF:{0},{1} - {2}", (int)track.TaglibFile.Properties.Duration.TotalSeconds
, string.IsNullOrEmpty(track.TaglibFile.Tag.JoinedAlbumArtists) ? track.TaglibFile.Tag.JoinedPerformers : track.TaglibFile.Tag.JoinedAlbumArtists
, track.TaglibFile.Tag.Title));
await stream.WriteLineAsync(track.Path);
}
}
}
private async Task SendServiceMessage(Message packet)
{
var command = packet.Json;
try
{
using (var tcpClient = new TcpClient())
{
await tcpClient.ConnectAsync(IPAddress.Loopback, 22005);
using (var stream = tcpClient.GetStream())
using (var sw = new StreamWriter(stream, Encoding.UTF8))
{
if (tcpClient.Connected)
{
await sw.WriteLineAsync(command);
await sw.FlushAsync();
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public async Task HandleClientAsync(TcpClient c)
{
string msg = null;
bool connected = true;
Console.WriteLine($"Connection accepted {DateTime.Now.ToShortTimeString()}");
using (var output = new StreamWriter(c.GetStream(), UTF32Encoding.ASCII) { AutoFlush = true })
{
using (var input = new StreamReader(c.GetStream(), UTF32Encoding.ASCII))
{
while (connected)
{
switch (msg = await input.ReadLineAsync())
{
case "done":
connected = false;
break;
default:
await output.WriteLineAsync(msg);
break;
}
}
}
}
c.Close();
Console.WriteLine("bye...");
}
public async void SendMessageAsync()
{
try
{
using (var pipe = new NamedPipeServerStream(verb, PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
using (var stream = new StreamWriter(pipe))
{
var connectionTask = Task.Factory.FromAsync(pipe.BeginWaitForConnection, pipe.EndWaitForConnection, null);
var timeoutTask = Task.Delay(2000);
var firstTask = await Task.WhenAny(connectionTask, timeoutTask);
if (firstTask == timeoutTask)
{
pipe.EndWaitForConnection(connectionTask);
return;
}
stream.AutoFlush = true;
await stream.WriteLineAsync(selectedFile);
}
}
catch (Exception exception)
{
//OnSendMessageException(pipeName, new MessengerExceptionEventArgs(exception));
}
}
public HttpResponseMessage Get()
{
var resp = new HttpResponseMessage
{
Content = new PushStreamContent(async (respStream, content, context) =>
{
try
{
var wordsToSend = Lipsum.Split(' ');
using (var writer = new StreamWriter(respStream))
{
foreach (var word in wordsToSend)
{
await writer.WriteLineAsync(word);
await writer.FlushAsync();
await Task.Delay(millisecondsDelay: 250);
}
}
}
catch (Exception ex)
{
return;
}
finally
{
respStream.Close();
}
}, "text/plain")
};
return resp;
}
private async void DumpExportFilesAsync(string orders)
{
SelectedPath = FileUtility.GetExportsDirectory().ToLower();
if(SelectedPath=="not defined")
{
MessageBox.Show("Working folder MUST be defined first", "Import tool warning", MessageBoxButton.OK);
IsSaved=false;
return;
}
try
{
string fileName = Path.Combine(SelectedPath, @"ExportOrders-" + DateTime.Now.ToString("ddmmyyy").Replace(':', '-') + ".csv");
using (var fs = new FileStream(fileName, FileMode.OpenOrCreate))
{
fs.Close();
using (var wr = new StreamWriter(fileName, false))
{
await wr.WriteLineAsync(orders);
}
}
IsSaved = true;
}catch(IOException ex)
{
MessageBox.Show("Error copying import oders\nDetails=>" + ex.Message);
IsSaved = false;
}
}
protected override async Task WriteTextToFileCore(IStorageFile file, string contents)
{
using (var sw = new StreamWriter(file.Path, true))
{
await sw.WriteLineAsync(contents);
}
}
public async Task Error(Exception ex)
{
using (var log = new StreamWriter(File.OpenWrite("err.log")))
{
await log.WriteLineAsync(ex.ToString());
}
}
public static async Task SendAndReceive()
{
using (var client = new TcpClient())
{
await client.ConnectAsync(host, port);
using (NetworkStream stream = client.GetStream())
using (var writer = new StreamWriter(stream, Encoding.ASCII, 1024, leaveOpen: true))
using (var reader = new StreamReader(stream, Encoding.ASCII, true, 1024, leaveOpen: true))
{
writer.AutoFlush = true;
string line = string.Empty;
do
{
WriteLine("enter a string, bye to exit");
line = ReadLine();
await writer.WriteLineAsync(line);
string result = await reader.ReadLineAsync();
WriteLine($"received {result} from server");
} while (line != "bye");
WriteLine("so long, and thanks for all the fish");
}
}
}
