trjhtr

Here is a sample code to explain the approach I am going for.

public class LogWriter

 #region Private Members

 // If writer is not static class, still need to keep single message list; same for other members
 private static ConcurrentQueue<string> _logMessages = new ConcurrentQueue<string>();
 private static object locker = new object();
 private static bool _stopAfterCurrentQueue = false;
 private static bool _discardQueueAndStop = false;

 private static CancellationTokenSource _tokenSource = new CancellationTokenSource();
 #endregion

 public void Write(string text)
 
 if (!_stopAfterCurrentQueue && !_discardQueueAndStop)
 
 Task.Run(() =>
 
 _logMessages.Enqueue(text);

 );

 Task.Run(() =>
 
 while (!_logMessages.IsEmpty)
 
 foreach (var item in _logMessages)
 

 _logMessages.TryDequeue(out string current);
 lock (locker)
 
 // Will be replaced by StreamWriter
 File.AppendAllText("Log_" + DateTime.Now.ToString("yyyyMMMdd") + ".txt", current + Environment.NewLine);
 
 
 
 , _tokenSource.Token);
 
 

 public void ProcessCurrentAndStop()
 
 // Only stops accepting new messages, will process the current queue
 _stopAfterCurrentQueue = true;
 

 public void DiscardQueueAndStop()
 
 // Cancels subsequent Enqueue
 _tokenSource.Cancel();

 // No more writing even if there is something in the queue
 _discardQueueAndStop = true;
 

 public void RestartLogging()
 
 _stopAfterCurrentQueue = false;
 _discardQueueAndStop = false;

 _tokenSource.Dispose();
 _tokenSource = new CancellationTokenSource();
 

The idea is to write to file in asynchronous way. I am trying to make it thread safe as well. There is not much to process here except to write message to a file.

I would like to understand what could be potential issues with this approach and also if it would be better to keep class static.

Let’s try to get rid of ConcurrentQueue. And Task.Run – those are expensive ones. It also makes sense to use async file access – which is a way more lightweight.

public class LogWriter

 public static LogWriter Instance = new LogWriter();

 LogWriter()
 
 Enabled = true;
 Cts = new CancellationTokenSource();
 Task = Task.CompletedTask;
 

 bool Enabled get; set; 
 CancellationTokenSource Cts get; set; 
 Task Task get; set; 
 string Path => $"Log_DateTime.Now:yyyyMMMdd.txt";

 public void Start() => Enabled = true;

 public void Stop(bool discard = false)
 
 Enabled = false;
 if (discard)
 
 Cts.Cancel();
 Cts = new CancellationTokenSource();
 Task = Task.ContinueWith(t => );
 
 

 public void Write(string line) =>
 Write(line, Path, Cts.Token);

 void Write(string line, string path, CancellationToken token)
 
 if (Enabled)
 lock(Task)
 Task = Task.ContinueWithAsync(
 t => AppendAllTextAsync(path, line + NewLine, token),
 token);
 

Where missing part would be:

static class AsyncContinuations

 public static async Task ContinueWithAsync(this Task task, Func<Task, Task> continuationFunction, CancellationToken cancellationToken)
 
 await task;
 cancellationToken.ThrowIfCancellationRequested();
 await continuationFunction(task);
 

I think I would build up the append and then just take the Lock once. Write all at once is going to be more efficient.

public static void WriteTask(string text)

 if (!_stopAfterCurrentQueue && !_discardQueueAndStop && !string.IsNullOrEmpty(text))
 
 _logMessages.Enqueue(text);

 List<string> lString = new List<string>();
 string current;
 while (_logMessages.TryDequeue(out current))
 
 lString.Add(current);
 

 lock (locker)
 
 File.AppendAllLines("Log_" + DateTime.Now.ToString("yyyyMMMdd") + ".txt", lString);
 
 

The BlockingCollection<T> is a much better tool for implementing the the Producer-Consumer pattern.

A really simple implementaion could look like this where you create a Task that is a LongRunning one that consumes the collection and a Write method that enqueues new items. The Completion is made public on purpose so that you can wait until everything is processed just before you exit your application .

public class Logger

 private static BlockingCollection<string> _logs = new BlockingCollection<string>();

 public static Task Completion get; = Task.Factory.StartNew(() =>
 
 foreach (var log in _logs.GetConsumingEnumerable())
 
 Console.WriteLine(log);
 
 , TaskCreationOptions.LongRunning);

 public static void Write(string text)
 
 _logs.Add(text);
 

Alternatively you can use the Dataflow (Task Parallel Library) and just build it of ready-made components. They offer a lot of options too so check the documentation.

public class Logger2

 private static BufferBlock<string> _logs;
 private static ActionBlock<string> _logger;

 static Logger2()
 
 _logs = new BufferBlock<string>();
 _logger = new ActionBlock<string>(l => Log(l));
 _logs.LinkTo(_logger);
 

 public static Task Completion => _logs.Completion;

 public static void Write(string text)
 
 _logs.Post(text);
 

 private static void Log(string log) => Console.WriteLine(log);