/// <summary> /// Dispose(bool disposing) executes in two distinct scenarios. /// If disposing equals true, the method is called directly /// or indirectly by a user's code. Managed and unmanaged resources /// can be disposed. /// This method will close all log sinks. /// </summary> /// <param name="disposing"> /// If disposing equals false, the method is called by the /// runtime from inside the finalizer and you should not reference /// other objects. Only unmanaged resources can be disposed. /// </param> protected virtual void Dispose(bool disposing) { if (!disposed) { if (disposing) { if (logRunner.IsAlive) { // send end log message to end the thread. AvailableLogMessage endMessage = new AvailableLogMessage( new List <LogSink>(), new Dictionary <string, object>(), true); lock (logMessageQueue) { logMessageQueue.Enqueue(endMessage); hRead.Set(); } // wait for thread end logRunner.Join(); ProcessErrors(); } // close event handles hRead.Close(); hWrite.Close(); // clear queue lock (logMessageQueue) { logMessageQueue.Clear(); logMessageQueue = null; } // clear sinks if (null != logProfile) { foreach (LogSink sink in logProfile.AllSinks) { sink.Close(); } logProfile.ProfilesMap.Clear(); } // clear other resources activeKinds.Clear(); activeKinds = null; registeredProviders.Clear(); registeredProviders = null; outputStatistics.Clear(); outputStatistics = null; errors.Clear(); errors = null; } this.disposed = true; } }
/// <summary> /// Reads and processes log messages /// </summary> private void Run() { AvailableLogMessage message = null; while (true) { // wait until queue is not empty hRead.WaitOne(); lock (logMessageQueue) { message = logMessageQueue.Dequeue(); // disable reader when queue is empty if (logMessageQueue.Count == 0) { hRead.Reset(); } // inform writer that queue is able to write if (logMessageQueue.Count < MaxCapability) { hWrite.Set(); } } // skip empty message if (null == message) { continue; } // end thread if this is the final message if (message.EndOfLog) { message.Dispose(); message = null; return; } // process message WriteInfoToSinks(message.LogInfo, (List <LogSink>)message.LogSinks); message.Dispose(); message = null; } }
/// <summary> /// Dispose(bool disposing) executes in two distinct scenarios. /// If disposing equals true, the method is called directly /// or indirectly by a user's code. Managed and unmanaged resources /// can be disposed. /// This method will close all log sinks. /// </summary> /// <param name="disposing"> /// If disposing equals false, the method is called by the /// runtime from inside the finalizer and you should not reference /// other objects. Only unmanaged resources can be disposed. /// </param> protected virtual void Dispose(bool disposing) { if (!disposed) { if (disposing) { if (logRunner.IsAlive) { // send end log message to end the thread. AvailableLogMessage endMessage = new AvailableLogMessage( new List<LogSink>(), new Dictionary<string, object>(), true); lock (logMessageQueue) { logMessageQueue.Enqueue(endMessage); hRead.Set(); } // wait for thread end logRunner.Join(); ProcessErrors(); } // close event handles hRead.Close(); hWrite.Close(); // clear queue lock (logMessageQueue) { logMessageQueue.Clear(); logMessageQueue = null; } // clear sinks if (null != logProfile) { foreach (LogSink sink in logProfile.AllSinks) { sink.Close(); } logProfile.ProfilesMap.Clear(); } // clear other resources activeKinds.Clear(); activeKinds = null; registeredProviders.Clear(); registeredProviders = null; outputStatistics.Clear(); outputStatistics = null; errors.Clear(); errors = null; } this.disposed = true; } }