Author: dpsenner
Date: Sun Nov 1 16:30:06 2015
New Revision: 1711830
URL: http://svn.apache.org/viewvc?rev=1711830&view=rev
Log:
Refactoring
Reformatted the entire document to fix indentations and others.
Modified:
logging/log4net/trunk/src/Appender/FileAppender.cs
Modified: logging/log4net/trunk/src/Appender/FileAppender.cs
URL:
http://svn.apache.org/viewvc/logging/log4net/trunk/src/Appender/FileAppender.cs?rev=1711830&r1=1711829&r2=1711830&view=diff
==============================================================================
--- logging/log4net/trunk/src/Appender/FileAppender.cs (original)
+++ logging/log4net/trunk/src/Appender/FileAppender.cs Sun Nov 1 16:30:06 2015
@@ -57,19 +57,19 @@ namespace log4net.Appender
/// If the file cannot be opened for writing when a message is logged
then
/// the message will be discarded by this appender.
/// </para>
- /// <para>
- /// The <see cref="FileAppender"/> supports pluggable file locking models
via
- /// the <see cref="LockingModel"/> property.
- /// The default behavior, implemented by <see
cref="FileAppender.ExclusiveLock"/>
- /// is to obtain an exclusive write lock on the file until this appender
is closed.
- /// The alternative models only hold a
- /// write lock while the appender is writing a logging event (<see
cref="FileAppender.MinimalLock"/>)
- /// or synchronize by using a named system wide Mutex (<see
cref="FileAppender.InterProcessLock"/>).
- /// </para>
- /// <para>
- /// All locking strategies have issues and you should seriously consider
using a different strategy that
- /// avoids having multiple processes logging to the same file.
- /// </para>
+ /// <para>
+ /// The <see cref="FileAppender"/> supports pluggable file locking
models via
+ /// the <see cref="LockingModel"/> property.
+ /// The default behavior, implemented by <see
cref="FileAppender.ExclusiveLock"/>
+ /// is to obtain an exclusive write lock on the file until this
appender is closed.
+ /// The alternative models only hold a
+ /// write lock while the appender is writing a logging event (<see
cref="FileAppender.MinimalLock"/>)
+ /// or synchronize by using a named system wide Mutex (<see
cref="FileAppender.InterProcessLock"/>).
+ /// </para>
+ /// <para>
+ /// All locking strategies have issues and you should seriously
consider using a different strategy that
+ /// avoids having multiple processes logging to the same file.
+ /// </para>
/// </remarks>
/// <author>Nicko Cadell</author>
/// <author>Gert Driesen</author>
@@ -125,7 +125,7 @@ namespace log4net.Appender
/// <author>Douglas de la Torre</author>
/// <author>Niall Daley</author>
#endif
- public class FileAppender : TextWriterAppender
+ public class FileAppender : TextWriterAppender
{
#region LockingStream Inner Class
@@ -137,23 +137,25 @@ namespace log4net.Appender
{
public sealed class LockStateException : LogException
{
- public LockStateException(string message):
base(message)
+ public LockStateException(string message)
+ : base(message)
{
}
}
- private Stream m_realStream=null;
- private LockingModelBase m_lockingModel=null;
- private int m_readTotal=-1;
- private int m_lockLevel=0;
+ private Stream m_realStream = null;
+ private LockingModelBase m_lockingModel = null;
+ private int m_readTotal = -1;
+ private int m_lockLevel = 0;
- public LockingStream(LockingModelBase locking) : base()
+ public LockingStream(LockingModelBase locking)
+ : base()
{
- if (locking==null)
+ if (locking == null)
{
- throw new ArgumentException("Locking
model may not be null","locking");
+ throw new ArgumentException("Locking
model may not be null", "locking");
}
- m_lockingModel=locking;
+ m_lockingModel = locking;
}
#region Override Implementation of Stream
@@ -162,8 +164,8 @@ namespace log4net.Appender
public override IAsyncResult BeginRead(byte[] buffer,
int offset, int count, AsyncCallback callback, object state)
{
AssertLocked();
- IAsyncResult
ret=m_realStream.BeginRead(buffer,offset,count,callback,state);
- m_readTotal=EndRead(ret);
+ IAsyncResult ret =
m_realStream.BeginRead(buffer, offset, count, callback, state);
+ m_readTotal = EndRead(ret);
return ret;
}
@@ -173,104 +175,104 @@ namespace log4net.Appender
public override IAsyncResult BeginWrite(byte[] buffer,
int offset, int count, AsyncCallback callback, object state)
{
AssertLocked();
- IAsyncResult
ret=m_realStream.BeginWrite(buffer,offset,count,callback,state);
+ IAsyncResult ret =
m_realStream.BeginWrite(buffer, offset, count, callback, state);
EndWrite(ret);
return ret;
}
- public override void Close()
+ public override void Close()
{
m_lockingModel.CloseFile();
}
- public override int EndRead(IAsyncResult asyncResult)
+ public override int EndRead(IAsyncResult asyncResult)
{
AssertLocked();
return m_readTotal;
}
- public override void EndWrite(IAsyncResult asyncResult)
+ public override void EndWrite(IAsyncResult asyncResult)
{
//No-op, it has already been handled
}
- public override void Flush()
+ public override void Flush()
{
AssertLocked();
m_realStream.Flush();
}
- public override int Read(byte[] buffer, int offset, int
count)
+ public override int Read(byte[] buffer, int offset, int
count)
{
- return m_realStream.Read(buffer,offset,count);
+ return m_realStream.Read(buffer, offset, count);
}
- public override int ReadByte()
+ public override int ReadByte()
{
return m_realStream.ReadByte();
}
- public override long Seek(long offset, SeekOrigin
origin)
+ public override long Seek(long offset, SeekOrigin
origin)
{
AssertLocked();
- return m_realStream.Seek(offset,origin);
+ return m_realStream.Seek(offset, origin);
}
- public override void SetLength(long value)
+ public override void SetLength(long value)
{
AssertLocked();
m_realStream.SetLength(value);
}
- void IDisposable.Dispose()
+ void IDisposable.Dispose()
{
Close();
}
- public override void Write(byte[] buffer, int offset,
int count)
+ public override void Write(byte[] buffer, int offset,
int count)
{
AssertLocked();
- m_realStream.Write(buffer,offset,count);
+ m_realStream.Write(buffer, offset, count);
}
- public override void WriteByte(byte value)
+ public override void WriteByte(byte value)
{
AssertLocked();
m_realStream.WriteByte(value);
}
// Properties
- public override bool CanRead
- {
- get { return false; }
- }
- public override bool CanSeek
- {
- get
+ public override bool CanRead
+ {
+ get { return false; }
+ }
+ public override bool CanSeek
+ {
+ get
{
AssertLocked();
return m_realStream.CanSeek;
- }
+ }
}
- public override bool CanWrite
- {
- get
+ public override bool CanWrite
+ {
+ get
{
AssertLocked();
return m_realStream.CanWrite;
- }
+ }
}
- public override long Length
- {
- get
+ public override long Length
+ {
+ get
{
AssertLocked();
return m_realStream.Length;
- }
+ }
}
- public override long Position
- {
- get
+ public override long Position
+ {
+ get
{
AssertLocked();
return m_realStream.Position;
- }
- set
+ }
+ set
{
AssertLocked();
- m_realStream.Position=value;
- }
+ m_realStream.Position = value;
+ }
}
#endregion Override Implementation of Stream
@@ -287,18 +289,18 @@ namespace log4net.Appender
public bool AcquireLock()
{
- bool ret=false;
- lock(this)
+ bool ret = false;
+ lock (this)
{
- if (m_lockLevel==0)
+ if (m_lockLevel == 0)
{
// If lock is already acquired,
nop
-
m_realStream=m_lockingModel.AcquireLock();
+ m_realStream =
m_lockingModel.AcquireLock();
}
- if (m_realStream!=null)
+ if (m_realStream != null)
{
m_lockLevel++;
- ret=true;
+ ret = true;
}
}
return ret;
@@ -306,14 +308,14 @@ namespace log4net.Appender
public void ReleaseLock()
{
- lock(this)
+ lock (this)
{
m_lockLevel--;
- if (m_lockLevel==0)
+ if (m_lockLevel == 0)
{
// If already unlocked, nop
m_lockingModel.ReleaseLock();
- m_realStream=null;
+ m_realStream = null;
}
}
}
@@ -335,7 +337,7 @@ namespace log4net.Appender
/// </remarks>
public abstract class LockingModelBase
{
- private FileAppender m_appender=null;
+ private FileAppender m_appender = null;
/// <summary>
/// Open the output file
@@ -351,7 +353,7 @@ namespace log4net.Appender
/// <see cref="ReleaseLock"/> and <see
cref="CloseFile"/>.
/// </para>
/// </remarks>
- public abstract void OpenFile(string filename, bool
append,Encoding encoding);
+ public abstract void OpenFile(string filename, bool
append, Encoding encoding);
/// <summary>
/// Close the file
@@ -412,55 +414,55 @@ namespace log4net.Appender
set { m_appender = value; }
}
- /// <summary>
- /// Helper method that creates a FileStream under
CurrentAppender's SecurityContext.
- /// </summary>
- /// <remarks>
- /// <para>
- /// Typically called during OpenFile or AcquireLock.
- /// </para>
- /// <para>
- /// If the directory portion of the <paramref name="filename"/>
does not exist, it is created
- /// via Directory.CreateDirecctory.
- /// </para>
- /// </remarks>
- /// <param name="filename"></param>
- /// <param name="append"></param>
- /// <param name="fileShare"></param>
- /// <returns></returns>
- protected Stream CreateStream(string filename, bool append,
FileShare fileShare)
- {
- using (CurrentAppender.SecurityContext.Impersonate(this))
- {
- // Ensure that the directory structure exists
- string directoryFullName = Path.GetDirectoryName(filename);
-
- // Only create the directory if it does not exist
- // doing this check here resolves some permissions failures
- if (!Directory.Exists(directoryFullName))
- {
- Directory.CreateDirectory(directoryFullName);
- }
-
- FileMode fileOpenMode = append ? FileMode.Append :
FileMode.Create;
- return new FileStream(filename, fileOpenMode,
FileAccess.Write, fileShare);
- }
- }
-
- /// <summary>
- /// Helper method to close <paramref name="stream"/> under
CurrentAppender's SecurityContext.
- /// </summary>
- /// <remarks>
- /// Does not set <paramref name="stream"/> to null.
- /// </remarks>
- /// <param name="stream"></param>
- protected void CloseStream(Stream stream)
- {
- using (CurrentAppender.SecurityContext.Impersonate(this))
- {
- stream.Close();
- }
- }
+ /// <summary>
+ /// Helper method that creates a FileStream under
CurrentAppender's SecurityContext.
+ /// </summary>
+ /// <remarks>
+ /// <para>
+ /// Typically called during OpenFile or AcquireLock.
+ /// </para>
+ /// <para>
+ /// If the directory portion of the <paramref
name="filename"/> does not exist, it is created
+ /// via Directory.CreateDirecctory.
+ /// </para>
+ /// </remarks>
+ /// <param name="filename"></param>
+ /// <param name="append"></param>
+ /// <param name="fileShare"></param>
+ /// <returns></returns>
+ protected Stream CreateStream(string filename, bool
append, FileShare fileShare)
+ {
+ using
(CurrentAppender.SecurityContext.Impersonate(this))
+ {
+ // Ensure that the directory structure
exists
+ string directoryFullName =
Path.GetDirectoryName(filename);
+
+ // Only create the directory if it does
not exist
+ // doing this check here resolves some
permissions failures
+ if
(!Directory.Exists(directoryFullName))
+ {
+
Directory.CreateDirectory(directoryFullName);
+ }
+
+ FileMode fileOpenMode = append ?
FileMode.Append : FileMode.Create;
+ return new FileStream(filename,
fileOpenMode, FileAccess.Write, fileShare);
+ }
+ }
+
+ /// <summary>
+ /// Helper method to close <paramref name="stream"/>
under CurrentAppender's SecurityContext.
+ /// </summary>
+ /// <remarks>
+ /// Does not set <paramref name="stream"/> to null.
+ /// </remarks>
+ /// <param name="stream"></param>
+ protected void CloseStream(Stream stream)
+ {
+ using
(CurrentAppender.SecurityContext.Impersonate(this))
+ {
+ stream.Close();
+ }
+ }
}
/// <summary>
@@ -490,15 +492,15 @@ namespace log4net.Appender
/// <see cref="ReleaseLock"/> and <see
cref="CloseFile"/>.
/// </para>
/// </remarks>
- public override void OpenFile(string filename, bool
append,Encoding encoding)
+ public override void OpenFile(string filename, bool
append, Encoding encoding)
{
try
{
- m_stream = CreateStream(filename, append, FileShare.Read);
+ m_stream = CreateStream(filename,
append, FileShare.Read);
}
catch (Exception e1)
{
-
CurrentAppender.ErrorHandler.Error("Unable to acquire lock on file
"+filename+". "+e1.Message);
+
CurrentAppender.ErrorHandler.Error("Unable to acquire lock on file " + filename
+ ". " + e1.Message);
}
}
@@ -512,8 +514,8 @@ namespace log4net.Appender
/// </remarks>
public override void CloseFile()
{
- CloseStream(m_stream);
- m_stream = null;
+ CloseStream(m_stream);
+ m_stream = null;
}
/// <summary>
@@ -559,7 +561,7 @@ namespace log4net.Appender
{
private string m_filename;
private bool m_append;
- private Stream m_stream=null;
+ private Stream m_stream = null;
/// <summary>
/// Prepares to open the file when the first message is
logged.
@@ -577,8 +579,8 @@ namespace log4net.Appender
/// </remarks>
public override void OpenFile(string filename, bool
append, Encoding encoding)
{
- m_filename=filename;
- m_append=append;
+ m_filename = filename;
+ m_append = append;
}
/// <summary>
@@ -607,16 +609,16 @@ namespace log4net.Appender
/// </remarks>
public override Stream AcquireLock()
{
- if (m_stream==null)
+ if (m_stream == null)
{
try
{
- m_stream = CreateStream(m_filename, m_append,
FileShare.Read);
- m_append = true;
+ m_stream =
CreateStream(m_filename, m_append, FileShare.Read);
+ m_append = true;
}
catch (Exception e1)
{
-
CurrentAppender.ErrorHandler.Error("Unable to acquire lock on file
"+m_filename+". "+e1.Message);
+
CurrentAppender.ErrorHandler.Error("Unable to acquire lock on file " +
m_filename + ". " + e1.Message);
}
}
return m_stream;
@@ -633,122 +635,125 @@ namespace log4net.Appender
/// </remarks>
public override void ReleaseLock()
{
- CloseStream(m_stream);
- m_stream = null;
+ CloseStream(m_stream);
+ m_stream = null;
}
}
#if !NETCF
- /// <summary>
- /// Provides cross-process file locking.
- /// </summary>
- /// <author>Ron Grabowski</author>
- /// <author>Steve Wranovsky</author>
- public class InterProcessLock : LockingModelBase
- {
- private Mutex m_mutex = null;
- private Stream m_stream = null;
-
- /// <summary>
- /// Open the file specified and prepare for logging.
- /// </summary>
- /// <param name="filename">The filename to use</param>
- /// <param name="append">Whether to append to the file, or
overwrite</param>
- /// <param name="encoding">The encoding to use</param>
- /// <remarks>
- /// <para>
- /// Open the file specified and prepare for logging.
- /// No writes will be made until <see cref="AcquireLock"/> is
called.
- /// Must be called before any calls to <see cref="AcquireLock"/>,
- /// -<see cref="ReleaseLock"/> and <see cref="CloseFile"/>.
- /// </para>
- /// </remarks>
+ /// <summary>
+ /// Provides cross-process file locking.
+ /// </summary>
+ /// <author>Ron Grabowski</author>
+ /// <author>Steve Wranovsky</author>
+ public class InterProcessLock : LockingModelBase
+ {
+ private Mutex m_mutex = null;
+ private Stream m_stream = null;
+
+ /// <summary>
+ /// Open the file specified and prepare for logging.
+ /// </summary>
+ /// <param name="filename">The filename to use</param>
+ /// <param name="append">Whether to append to the file,
or overwrite</param>
+ /// <param name="encoding">The encoding to use</param>
+ /// <remarks>
+ /// <para>
+ /// Open the file specified and prepare for logging.
+ /// No writes will be made until <see
cref="AcquireLock"/> is called.
+ /// Must be called before any calls to <see
cref="AcquireLock"/>,
+ /// -<see cref="ReleaseLock"/> and <see
cref="CloseFile"/>.
+ /// </para>
+ /// </remarks>
#if NET_4_0 || MONO_4_0
- [System.Security.SecuritySafeCritical]
+ [System.Security.SecuritySafeCritical]
#endif
- public override void OpenFile(string filename, bool append,
Encoding encoding)
- {
- try
- {
- m_stream = CreateStream(filename, append,
FileShare.ReadWrite);
-
- string mutexFriendlyFilename = filename
- .Replace("\\", "_")
- .Replace(":", "_")
- .Replace("/", "_");
-
- m_mutex = new Mutex(false, mutexFriendlyFilename);
- }
- catch (Exception e1)
- {
- CurrentAppender.ErrorHandler.Error("Unable to acquire lock
on file " + filename + ". " + e1.Message);
- }
- }
-
- /// <summary>
- /// Close the file
- /// </summary>
- /// <remarks>
- /// <para>
- /// Close the file. No further writes will be made.
- /// </para>
- /// </remarks>
- public override void CloseFile()
- {
- try {
- CloseStream(m_stream);
- m_stream = null;
- }
- finally {
+ public override void OpenFile(string filename, bool
append, Encoding encoding)
+ {
+ try
+ {
+ m_stream = CreateStream(filename,
append, FileShare.ReadWrite);
+
+ string mutexFriendlyFilename = filename
+ .Replace("\\", "_")
+ .Replace(":", "_")
+ .Replace("/", "_");
+
+ m_mutex = new Mutex(false,
mutexFriendlyFilename);
+ }
+ catch (Exception e1)
+ {
+
CurrentAppender.ErrorHandler.Error("Unable to acquire lock on file " + filename
+ ". " + e1.Message);
+ }
+ }
+
+ /// <summary>
+ /// Close the file
+ /// </summary>
+ /// <remarks>
+ /// <para>
+ /// Close the file. No further writes will be made.
+ /// </para>
+ /// </remarks>
+ public override void CloseFile()
+ {
+ try
+ {
+ CloseStream(m_stream);
+ m_stream = null;
+ }
+ finally
+ {
ReleaseLock();
- m_mutex.Close();
+ m_mutex.Close();
m_mutex = null;
- }
- }
+ }
+ }
+
+ /// <summary>
+ /// Acquire the lock on the file
+ /// </summary>
+ /// <returns>A stream that is ready to be written
to.</returns>
+ /// <remarks>
+ /// <para>
+ /// Does nothing. The lock is already taken
+ /// </para>
+ /// </remarks>
+ public override Stream AcquireLock()
+ {
+ if (m_mutex != null)
+ {
+ // TODO: add timeout?
+ m_mutex.WaitOne();
- /// <summary>
- /// Acquire the lock on the file
- /// </summary>
- /// <returns>A stream that is ready to be written to.</returns>
- /// <remarks>
- /// <para>
- /// Does nothing. The lock is already taken
- /// </para>
- /// </remarks>
- public override Stream AcquireLock()
- {
- if (m_mutex != null)
- {
- // TODO: add timeout?
- m_mutex.WaitOne();
-
- // should always be true (and fast) for FileStream
- if (m_stream.CanSeek) {
- m_stream.Seek(0, SeekOrigin.End);
- }
+ // should always be true (and fast) for
FileStream
+ if (m_stream.CanSeek)
+ {
+ m_stream.Seek(0,
SeekOrigin.End);
+ }
}
else
{
CurrentAppender.ErrorHandler.Error("Programming error, no mutex available to
acquire lock! From here on things will be dangerous!");
}
- return m_stream;
- }
+ return m_stream;
+ }
- /// <summary>
- /// Releases the lock and allows others to acquire a lock.
- /// </summary>
- public override void ReleaseLock()
- {
- if (m_mutex != null)
- {
- m_mutex.ReleaseMutex();
+ /// <summary>
+ /// Releases the lock and allows others to acquire a
lock.
+ /// </summary>
+ public override void ReleaseLock()
+ {
+ if (m_mutex != null)
+ {
+ m_mutex.ReleaseMutex();
}
else
{
CurrentAppender.ErrorHandler.Error("Programming error, no mutex available to
release the lock!");
}
- }
- }
+ }
+ }
#endif
#endregion Locking Models
@@ -779,7 +784,7 @@ namespace log4net.Appender
/// </para>
/// </remarks>
[Obsolete("Instead use the default constructor and set the
Layout, File & AppendToFile properties")]
- public FileAppender(ILayout layout, string filename, bool
append)
+ public FileAppender(ILayout layout, string filename, bool
append)
{
Layout = layout;
File = filename;
@@ -799,7 +804,8 @@ namespace log4net.Appender
/// </para>
/// </remarks>
[Obsolete("Instead use the default constructor and set the
Layout & File properties")]
- public FileAppender(ILayout layout, string filename) :
this(layout, filename, true)
+ public FileAppender(ILayout layout, string filename)
+ : this(layout, filename, true)
{
}
@@ -877,7 +883,7 @@ namespace log4net.Appender
/// of the current thread.
/// </para>
/// </remarks>
- public SecurityContext SecurityContext
+ public SecurityContext SecurityContext
{
get { return m_securityContext; }
set { m_securityContext = value; }
@@ -905,7 +911,7 @@ namespace log4net.Appender
/// </para>
/// </remarks>
#else
- /// <summary>
+ /// <summary>
/// Gets or sets the <see cref="FileAppender.LockingModel"/>
used to handle locking of the file.
/// </summary>
/// <value>
@@ -916,10 +922,10 @@ namespace log4net.Appender
/// Gets or sets the <see cref="FileAppender.LockingModel"/>
used to handle locking of the file.
/// </para>
/// <para>
- /// There are three built in locking models, <see
cref="FileAppender.ExclusiveLock"/>, <see cref="FileAppender.MinimalLock"/> and
<see cref="FileAppender.InterProcessLock"/> .
+ /// There are three built in locking models, <see
cref="FileAppender.ExclusiveLock"/>, <see cref="FileAppender.MinimalLock"/> and
<see cref="FileAppender.InterProcessLock"/> .
/// The first locks the file from the start of logging to the
end, the
/// second locks only for the minimal amount of time when
logging each message
- /// and the last synchronizes processes using a named system wide
Mutex.
+ /// and the last synchronizes processes using a named system
wide Mutex.
/// </para>
/// <para>
/// The default locking model is the <see
cref="FileAppender.ExclusiveLock"/>.
@@ -955,8 +961,8 @@ namespace log4net.Appender
/// This will cause the file to be opened.
/// </para>
/// </remarks>
- override public void ActivateOptions()
- {
+ override public void ActivateOptions()
+ {
base.ActivateOptions();
if (m_securityContext == null)
@@ -969,19 +975,19 @@ namespace log4net.Appender
m_lockingModel = new
FileAppender.ExclusiveLock();
}
- m_lockingModel.CurrentAppender=this;
-
- if (m_fileName != null)
+ m_lockingModel.CurrentAppender = this;
+
+ if (m_fileName != null)
{
- using(SecurityContext.Impersonate(this))
+ using (SecurityContext.Impersonate(this))
{
m_fileName =
ConvertToFullPath(m_fileName.Trim());
}
SafeOpenFile(m_fileName, m_appendToFile);
- }
- else
+ }
+ else
{
- LogLog.Warn(declaringType, "FileAppender: File
option not set for appender ["+Name+"].");
+ LogLog.Warn(declaringType, "FileAppender: File
option not set for appender [" + Name + "].");
LogLog.Warn(declaringType, "FileAppender: Are
you using FileAppender instead of ConsoleAppender?");
}
}
@@ -998,25 +1004,25 @@ namespace log4net.Appender
/// Resets the filename and the file stream.
/// </para>
/// </remarks>
- override protected void Reset()
+ override protected void Reset()
{
base.Reset();
m_fileName = null;
}
- /// <summary>
- /// Called to initialize the file writer
- /// </summary>
- /// <remarks>
- /// <para>
- /// Will be called for each logged message until the file is
- /// successfully opened.
- /// </para>
- /// </remarks>
- override protected void PrepareWriter()
- {
+ /// <summary>
+ /// Called to initialize the file writer
+ /// </summary>
+ /// <remarks>
+ /// <para>
+ /// Will be called for each logged message until the file is
+ /// successfully opened.
+ /// </para>
+ /// </remarks>
+ override protected void PrepareWriter()
+ {
SafeOpenFile(m_fileName, m_appendToFile);
- }
+ }
/// <summary>
/// This method is called by the <see
cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
@@ -1032,7 +1038,7 @@ namespace log4net.Appender
/// The format of the output will depend on the appender's
layout.
/// </para>
/// </remarks>
- override protected void Append(LoggingEvent loggingEvent)
+ override protected void Append(LoggingEvent loggingEvent)
{
if (m_stream.AcquireLock())
{
@@ -1058,7 +1064,7 @@ namespace log4net.Appender
/// the stream.
/// </para>
/// </remarks>
- override protected void Append(LoggingEvent[] loggingEvents)
+ override protected void Append(LoggingEvent[] loggingEvents)
{
if (m_stream.AcquireLock())
{
@@ -1081,9 +1087,9 @@ namespace log4net.Appender
/// Writes a footer as produced by the embedded layout's <see
cref="ILayout.Footer"/> property.
/// </para>
/// </remarks>
- protected override void WriteFooter()
+ protected override void WriteFooter()
{
- if (m_stream!=null)
+ if (m_stream != null)
{
//WriteFooter can be called even before a file
is opened
m_stream.AcquireLock();
@@ -1106,9 +1112,9 @@ namespace log4net.Appender
/// Writes a header produced by the embedded layout's <see
cref="ILayout.Header"/> property.
/// </para>
/// </remarks>
- protected override void WriteHeader()
+ protected override void WriteHeader()
{
- if (m_stream!=null)
+ if (m_stream != null)
{
if (m_stream.AcquireLock())
{
@@ -1132,9 +1138,9 @@ namespace log4net.Appender
/// Closes the underlying <see cref="TextWriter"/>.
/// </para>
/// </remarks>
- protected override void CloseWriter()
+ protected override void CloseWriter()
{
- if (m_stream!=null)
+ if (m_stream != null)
{
m_stream.AcquireLock();
try
@@ -1161,7 +1167,7 @@ namespace log4net.Appender
/// closes the file.
/// </para>
/// </remarks>
- protected void CloseFile()
+ protected void CloseFile()
{
WriteFooterAndCloseWriter();
}
@@ -1183,13 +1189,13 @@ namespace log4net.Appender
/// </remarks>
virtual protected void SafeOpenFile(string fileName, bool
append)
{
- try
+ try
{
OpenFile(fileName, append);
}
- catch(Exception e)
+ catch (Exception e)
{
-
ErrorHandler.Error("OpenFile("+fileName+","+append+") call failed.", e,
ErrorCode.FileOpenFailure);
+ ErrorHandler.Error("OpenFile(" + fileName + ","
+ append + ") call failed.", e, ErrorCode.FileOpenFailure);
}
}
@@ -1214,29 +1220,29 @@ namespace log4net.Appender
{
// Internal check that the fileName passed in
is a rooted path
bool isPathRooted = false;
- using(SecurityContext.Impersonate(this))
+ using (SecurityContext.Impersonate(this))
{
isPathRooted =
Path.IsPathRooted(fileName);
}
if (!isPathRooted)
{
- LogLog.Error(declaringType, "INTERNAL
ERROR. OpenFile("+fileName+"): File name is not fully qualified.");
+ LogLog.Error(declaringType, "INTERNAL
ERROR. OpenFile(" + fileName + "): File name is not fully qualified.");
}
}
- lock(this)
+ lock (this)
{
Reset();
- LogLog.Debug(declaringType, "Opening file for
writing ["+fileName+"] append ["+append+"]");
+ LogLog.Debug(declaringType, "Opening file for
writing [" + fileName + "] append [" + append + "]");
// Save these for later, allowing retries if
file open fails
m_fileName = fileName;
m_appendToFile = append;
- LockingModel.CurrentAppender=this;
-
LockingModel.OpenFile(fileName,append,m_encoding);
- m_stream=new LockingStream(LockingModel);
+ LockingModel.CurrentAppender = this;
+ LockingModel.OpenFile(fileName, append,
m_encoding);
+ m_stream = new LockingStream(LockingModel);
if (m_stream != null)
{
@@ -1271,7 +1277,7 @@ namespace log4net.Appender
/// data using a
<c>System.Security.Cryptography.CryptoStream</c>.
/// </para>
/// </remarks>
- virtual protected void SetQWForFiles(Stream fileStream)
+ virtual protected void SetQWForFiles(Stream fileStream)
{
SetQWForFiles(new StreamWriter(fileStream, m_encoding));
}
@@ -1286,7 +1292,7 @@ namespace log4net.Appender
/// wrap the <see cref="TextWriter"/> in some way.
/// </para>
/// </remarks>
- virtual protected void SetQWForFiles(TextWriter writer)
+ virtual protected void SetQWForFiles(TextWriter writer)
{
QuietWriter = new QuietTextWriter(writer, ErrorHandler);
}
@@ -1350,17 +1356,17 @@ namespace log4net.Appender
#endregion Private Instance Fields
- #region Private Static Fields
+ #region Private Static Fields
- /// <summary>
- /// The fully qualified type of the FileAppender class.
- /// </summary>
- /// <remarks>
- /// Used by the internal logger to record the Type of the
- /// log message.
- /// </remarks>
- private readonly static Type declaringType = typeof(FileAppender);
+ /// <summary>
+ /// The fully qualified type of the FileAppender class.
+ /// </summary>
+ /// <remarks>
+ /// Used by the internal logger to record the Type of the
+ /// log message.
+ /// </remarks>
+ private readonly static Type declaringType =
typeof(FileAppender);
- #endregion Private Static Fields
+ #endregion Private Static Fields
}
}
