ConsoleWorker.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Queue;
 
namespace Waher.Runtime.Console.Worker
{
    public static class ConsoleWorker
    {
        private static AsyncQueue<WorkItem> queue = new AsyncQueue<WorkItem>();
        private static bool terminating = false;
        private static bool terminated = false;
 
        static ConsoleWorker()
        {
            Log.Terminating += Log_Terminating;
            Task.Run(() => PerformWork());
        }
 
        private static void Log_Terminating(object Sender, System.EventArgs e)
        {
            Terminate();
            Log.Terminating -= Log_Terminating;
        }
 
        internal static void Terminate()
        {
            terminating = true;
            queue?.Dispose();
            queue = null;
        }
 
        public static Task<bool> Queue(WorkItem Work)
        {
            if (!terminating)
                return queue?.Add(Work) ?? Task.FromResult(false);
            else
                return Task.FromResult(false);
        }
 
        public static bool Terminating => terminating;
 
        public static bool Terminated => terminated;
 
        private static async void PerformWork()
        {
            try
            {
                WorkItem Item;
 
                while (!((Item = await (queue?.Wait() ?? Task.FromResult<WorkItem>(null))) is null))
                {
                    try
                    {
                        await Item.Execute();
                        Item.Processed(true);
                    }
                    catch (Exception ex)
                    {
                        Item.Processed(false);
                        ex = Log.UnnestException(ex);
 
                        Event Event = new Event(Log.GetEventType(ex), ex, string.Empty, string.Empty, string.Empty, EventLevel.Minor,
                            string.Empty, string.Empty);
 
                        foreach (IEventSink Sink in Log.Sinks)
                        {
                            if (Sink.GetType().FullName.Contains(".Console"))
                                Event.Avoid(Sink);
                        }
 
                        Log.Event(Event);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
            finally
            {
                terminated = true;
            }
        }
    }
}