/// <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;
}
}
