Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

file scoped namespaces and CA warnings fixed in examples #202

Merged
merged 1 commit into from
Oct 24, 2024
Merged

file scoped namespaces and CA warnings fixed in examples #202

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
194 changes: 110 additions & 84 deletions examples/Appenders/SampleAppendersApp/Appender/AsyncAppender.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,130 +23,156 @@
using log4net.Core;
using log4net.Util;

namespace SampleAppendersApp.Appender
namespace SampleAppendersApp.Appender;

/// <summary>
/// Appender that forwards LoggingEvents asynchronously
/// </summary>
/// <remarks>
/// This appender forwards LoggingEvents to a list of attached appenders.
/// The events are forwarded asynchronously using the ThreadPool.
/// This allows the calling thread to be released quickly, however it does
/// not guarantee the ordering of events delivered to the attached appenders.
/// </remarks>
public sealed class AsyncAppender : IAppender, IBulkAppender, IOptionHandler, IAppenderAttachable
{
/// <summary>
/// Appender that forwards LoggingEvents asynchronously
/// </summary>
/// <remarks>
/// This appender forwards LoggingEvents to a list of attached appenders.
/// The events are forwarded asynchronously using the ThreadPool.
/// This allows the calling thread to be released quickly, however it does
/// not guarantee the ordering of events delivered to the attached appenders.
/// </remarks>
public sealed class AsyncAppender : IAppender, IBulkAppender, IOptionHandler, IAppenderAttachable
{
private readonly object syncRoot = new();
private readonly object _syncRoot = new();

/// <inheritdoc/>
public string Name { get; set; } = string.Empty;
/// <inheritdoc/>
public string Name { get; set; } = string.Empty;

/// <inheritdoc/>
public void ActivateOptions()
{ }
/// <inheritdoc/>
public void ActivateOptions()
{ }

/// <inheritdoc/>
public FixFlags Fix { get; set; } = FixFlags.All;
/// <inheritdoc/>
public FixFlags Fix { get; set; } = FixFlags.All;

/// <inheritdoc/>
public void Close()
/// <inheritdoc/>
public void Close()
{
// Remove all the attached appenders
lock (_syncRoot)
{
// Remove all the attached appenders
lock (syncRoot)
appenderAttachedImpl?.RemoveAllAppenders();
_appenderAttachedImpl?.RemoveAllAppenders();
}
}

/// <inheritdoc/>
public void DoAppend(LoggingEvent loggingEvent)
{
ArgumentNullException.ThrowIfNull(loggingEvent);
loggingEvent.Fix = Fix;
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncAppend), loggingEvent);
}

/// <inheritdoc/>
public void DoAppend(LoggingEvent loggingEvent)
/// <inheritdoc/>
public void DoAppend(LoggingEvent[] loggingEvents)
{
ArgumentNullException.ThrowIfNull(loggingEvents);
foreach (LoggingEvent loggingEvent in loggingEvents)
{
ArgumentNullException.ThrowIfNull(loggingEvent);
loggingEvent.Fix = Fix;
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncAppend), loggingEvent);
}

/// <inheritdoc/>
public void DoAppend(LoggingEvent[] loggingEvents)
{
ArgumentNullException.ThrowIfNull(loggingEvents);
foreach (LoggingEvent loggingEvent in loggingEvents)
loggingEvent.Fix = Fix;
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncAppend), loggingEvents);
}
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncAppend), loggingEvents);
}

private void AsyncAppend(object? state)
private void AsyncAppend(object? state)
{
if (_appenderAttachedImpl != null)
{
if (appenderAttachedImpl != null)
if (state is LoggingEvent loggingEvent)
{
_appenderAttachedImpl.AppendLoopOnAppenders(loggingEvent);
}
else if (state is LoggingEvent[] loggingEvents)
{
if (state is LoggingEvent loggingEvent)
appenderAttachedImpl.AppendLoopOnAppenders(loggingEvent);
else if (state is LoggingEvent[] loggingEvents)
appenderAttachedImpl.AppendLoopOnAppenders(loggingEvents);
_appenderAttachedImpl.AppendLoopOnAppenders(loggingEvents);
}
}
}

#region IAppenderAttachable Members
#region IAppenderAttachable Members

/// <inheritdoc/>
public void AddAppender(IAppender appender)
/// <inheritdoc/>
public void AddAppender(IAppender appender)
{
ArgumentNullException.ThrowIfNull(appender);
lock (_syncRoot)
{
ArgumentNullException.ThrowIfNull(appender);
lock (syncRoot)
(appenderAttachedImpl ??= new()).AddAppender(appender);
(_appenderAttachedImpl ??= new()).AddAppender(appender);
}
}

/// <inheritdoc/>
public AppenderCollection Appenders
/// <inheritdoc/>
public AppenderCollection Appenders
{
get
{
get
lock (_syncRoot)
{
lock (syncRoot)
return appenderAttachedImpl?.Appenders ?? AppenderCollection.EmptyCollection;
return _appenderAttachedImpl?.Appenders ?? AppenderCollection.EmptyCollection;
}
}
}

/// <inheritdoc/>
public IAppender? GetAppender(string name)
/// <inheritdoc/>
public IAppender? GetAppender(string? name)
{
lock (_syncRoot)
{
lock (syncRoot)
if (_appenderAttachedImpl is null || name is null)
{
if (appenderAttachedImpl is null || name is null)
return null;

return appenderAttachedImpl.GetAppender(name);
return null;
}

return _appenderAttachedImpl.GetAppender(name);
}
}

/// <inheritdoc/>
public void RemoveAllAppenders()
/// <inheritdoc/>
public void RemoveAllAppenders()
{
lock (_syncRoot)
{
lock (syncRoot)
if (appenderAttachedImpl is not null)
{
appenderAttachedImpl.RemoveAllAppenders();
appenderAttachedImpl = null;
}
if (_appenderAttachedImpl is not null)
{
_appenderAttachedImpl.RemoveAllAppenders();
_appenderAttachedImpl = null;
}
}
}

/// <inheritdoc/>
public IAppender? RemoveAppender(IAppender appender)
/// <inheritdoc/>
public IAppender? RemoveAppender(IAppender appender)
{
lock (_syncRoot)
{
lock (syncRoot)
if (appender is not null && appenderAttachedImpl is not null)
return appenderAttachedImpl.RemoveAppender(appender);
return null;
if (appender is not null && _appenderAttachedImpl is not null)
{
return _appenderAttachedImpl.RemoveAppender(appender);
}
}

/// <inheritdoc/>
public IAppender? RemoveAppender(string name)
return null;
}

/// <inheritdoc/>
public IAppender? RemoveAppender(string name)
{
lock (_syncRoot)
{
lock (syncRoot)
if (name is not null && appenderAttachedImpl is not null)
return appenderAttachedImpl.RemoveAppender(name);
return null;
if (name is not null && _appenderAttachedImpl is not null)
{
return _appenderAttachedImpl.RemoveAppender(name);
}
}

#endregion

private AppenderAttachedImpl? appenderAttachedImpl;
return null;
}

#endregion

private AppenderAttachedImpl? _appenderAttachedImpl;
}
69 changes: 34 additions & 35 deletions examples/Appenders/SampleAppendersApp/Appender/FireEventAppender.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,50 +21,49 @@

using log4net.Core;

namespace SampleAppendersApp.Appender
namespace SampleAppendersApp.Appender;

/// <inheritdoc/>
public sealed class MessageLoggedEventArgs(LoggingEvent loggingEvent) : EventArgs
{
/// <inheritdoc/>
public sealed class MessageLoggedEventArgs(LoggingEvent loggingEvent) : EventArgs
{
/// <inheritdoc/>
public LoggingEvent LoggingEvent { get; } = loggingEvent;
}
public LoggingEvent LoggingEvent { get; } = loggingEvent;
}

/// <summary>
/// Appender that raises an event for each LoggingEvent received
/// </summary>
/// <remarks>
/// Raises a MessageLoggedEvent for each LoggingEvent object received
/// by this appender.
/// </remarks>
public class FireEventAppender : log4net.Appender.AppenderSkeleton
{
/// <summary>
/// Appender that raises an event for each LoggingEvent received
/// Event handler
/// </summary>
/// <remarks>
/// Raises a MessageLoggedEvent for each LoggingEvent object received
/// by this appender.
/// </remarks>
public class FireEventAppender : log4net.Appender.AppenderSkeleton
{
/// <summary>
/// Event handler
/// </summary>
public event EventHandler<MessageLoggedEventArgs>? MessageLoggedEvent;
public event EventHandler<MessageLoggedEventArgs>? MessageLoggedEvent;

/// <summary>
/// Easy singleton, gets the last instance created
/// </summary>
public static FireEventAppender? Instance { get; private set; }
/// <summary>
/// Easy singleton, gets the last instance created
/// </summary>
public static FireEventAppender? Instance { get; private set; }

/// <inheritdoc/>
public FireEventAppender() => Instance = this; // Store the instance created
/// <inheritdoc/>
public FireEventAppender() => Instance = this; // Store the instance created

/// <inheritdoc/>
public virtual FixFlags Fix { get; set; } = FixFlags.All;
/// <inheritdoc/>
public virtual FixFlags Fix { get; set; } = FixFlags.All;

/// <inheritdoc/>
protected override void Append(LoggingEvent loggingEvent)
{
ArgumentNullException.ThrowIfNull(loggingEvent);
// Because we the LoggingEvent may be used beyond the lifetime
// of the Append() method we must fix any volatile data in the event
loggingEvent.Fix = Fix;
/// <inheritdoc/>
protected override void Append(LoggingEvent loggingEvent)
{
ArgumentNullException.ThrowIfNull(loggingEvent);
// Because we the LoggingEvent may be used beyond the lifetime
// of the Append() method we must fix any volatile data in the event
loggingEvent.Fix = Fix;

// Raise the event
MessageLoggedEvent?.Invoke(this, new MessageLoggedEventArgs(loggingEvent));
}
// Raise the event
MessageLoggedEvent?.Invoke(this, new MessageLoggedEventArgs(loggingEvent));
}
}
Loading