/// <summary>
 /// Initializes a new instance of the <see cref="BaseFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="createParameters">The create parameters.</param>
 public BaseFileAppender(string fileName, ICreateFileParameters createParameters)
 {
     this.CreateFileParameters = createParameters;
     this.FileName = fileName;
     this.OpenTime = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback
     this.LastWriteTime = DateTime.MinValue;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="parameters">The parameters.</param>
        public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
        {
            try
            {
                this.mutex = CreateSharableMutex("FileLock");
                this.fileStream = CreateFileStream(true);
                this.fileCharacteristicsHelper = FileCharacteristicsHelper.CreateHelper(parameters.ForceManaged);
            }
            catch
            {
                if (this.mutex != null)
                {
                    this.mutex.Close();
                    this.mutex = null;
                }

                if (this.fileStream != null)
                {
                    this.fileStream.Close();
                    this.fileStream = null;
                }

                throw;
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="BaseFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="createParameters">The create parameters.</param>
 public BaseFileAppender(string fileName, ICreateFileParameters createParameters)
 {
     this.CreateFileParameters = createParameters;
     this.FileName = fileName;
     this.OpenTime = CurrentTimeGetter.Now;
     this.LastWriteTime = DateTime.MinValue;
 }

        /// <summary>
        ///     Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="parameters">The parameters.</param>
        public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters)
            : base(fileName, parameters)
        {
            try
            {
                mutex = new Mutex(false, GetMutexName(fileName));
                file = CreateFileStream(true);
            }
            catch
            {
                if (mutex != null)
                {
                    mutex.Close();
                    mutex = null;
                }

                if (file != null)
                {
                    file.Close();
                    file = null;
                }

                throw;
            }
        }

        public UnixMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
        {
            int fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6)));
            if (fd == -1)
            {
                if (Stdlib.GetLastError() == Errno.ENOENT && parameters.CreateDirs)
                {
                    string dirName = Path.GetDirectoryName(fileName);
                    if (!Directory.Exists(dirName) && parameters.CreateDirs)
                        Directory.CreateDirectory(dirName);
                    
                    fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6)));
                }
            }
            if (fd == -1)
                UnixMarshal.ThrowExceptionForLastError();

            try
            {
                this.file = new UnixStream(fd, true);
            }
            catch
            {
                Syscall.close(fd);
                throw;
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="BaseFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="createParameters">The create parameters.</param>
 public BaseFileAppender(string fileName, ICreateFileParameters createParameters)
 {
     this.CreateFileParameters = createParameters;
     this.FileName = fileName;
     this.OpenTime = TimeSource.Current.Time.ToLocalTime();
     this.LastWriteTime = DateTime.MinValue;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="createParameters">The create parameters.</param>
        public BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) 
            : base(fileName, createParameters)
        {
#if SupportsMutex
            ArchiveMutex = CreateArchiveMutex();
#endif
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileAppenderCache"/> class.
        /// </summary>
        /// <remarks>
        /// The size of the list should be positive. No validations are performed during initialisation as it is an
        /// intenal class.
        /// </remarks>
        /// <param name="size">Total number of appenders allowed in list.</param>
        /// <param name="appenderFactory">Factory used to create each appender.</param>
        /// <param name="createFileParams">Parameters used for creating a file.</param>
        public FileAppenderCache(int size, IFileAppenderFactory appenderFactory, ICreateFileParameters createFileParams)
        {
            Size = size;
            Factory = appenderFactory;
            CreateFileParameters = createFileParams;

            appenders = new BaseFileAppender[Size];
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="createParameters">The create parameters.</param>
        public BaseFileAppender(string fileName, ICreateFileParameters createParameters)
        {
            this.CreateFileParameters = createParameters;
            this.FileName = fileName;
            this.OpenTime = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback
            this.LastWriteTime = DateTime.MinValue;
            this.CaptureLastWriteTime = createParameters.CaptureLastWriteTime;
#if !SILVERLIGHT
            this.ArchiveMutex = CreateArchiveMutex();
#endif
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileAppenderCache"/> class.
        /// </summary>
        /// <remarks>
        /// The size of the list should be positive. No validations are performed during initialisation as it is an
        /// intenal class.
        /// </remarks>
        /// <param name="size">Total number of appenders allowed in list.</param>
        /// <param name="appenderFactory">Factory used to create each appender.</param>
        /// <param name="createFileParams">Parameters used for creating a file.</param>
        public FileAppenderCache(int size, IFileAppenderFactory appenderFactory, ICreateFileParameters createFileParams)
        {
            Size = size;
            Factory = appenderFactory;
            CreateFileParameters = createFileParams;

            appenders = new BaseFileAppender[Size];

#if !SILVERLIGHT && !__IOS__ && !__ANDROID__
            externalFileArchivingWatcher.OnChange += ExternalFileArchivingWatcher_OnChange;
#endif
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="parameters">The parameters.</param>
 public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
 {
     var fi = new FileInfo(fileName);
     if (fi.Exists)
     {
         this.FileTouched(fi.LastWriteTime);
     }
     else
     {
         this.FileTouched();
     }
     this.file = CreateFileStream(false);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="createParameters">The create parameters.</param>
        public BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) 
            : base(fileName, createParameters)
        {
#if SupportsMutex
            try
            {
                ArchiveMutex = CreateArchiveMutex();
            }
            catch (SecurityException ex)
            {
                InternalLogger.Warn(ex, "Failed to create archive mutex");
            }
#endif
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="WindowsMultiProcessFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="parameters">The parameters.</param>
 public WindowsMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
 {
     try
     {
         CreateAppendOnlyFile(fileName);
         fileCharacteristicsHelper = FileCharacteristicsHelper.CreateHelper(parameters.ForceManaged);
     }
     catch
     {
         if (fileStream != null)
             fileStream.Dispose();
         fileStream = null;
         throw;
     }
 }

        public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
        {
            FileInfo fi = new FileInfo(fileName);
            if (fi.Exists)
            {
                FileTouched(fi.LastWriteTime);
                _fileLength = fi.Length;
            }
            else
            {
                FileTouched();
                _fileLength = 0;
            }

            _file = CreateFileStream(false);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="parameters">The parameters.</param>
 public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
 {
     if (CaptureLastWriteTime)
     {
         var fileInfo = new FileInfo(fileName);
         if (fileInfo.Exists)
         {
             FileTouched(fileInfo.GetLastWriteTimeUtc());
         }
         else
         {
             FileTouched();
         }
     }
     this.file = CreateFileStream(false);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="parameters">The parameters.</param>
        public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters)
            : base(fileName, parameters)
        {
            var fi = new FileInfo(fileName);
            if (fi.Exists)
            {
                this.FileTouched(fi.LastWriteTime);
                this.currentFileLength = fi.Length;
            }
            else
            {
                this.FileTouched();
                this.currentFileLength = 0;
            }

            this.file = this.CreateFileStream(false);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="parameters">The parameters.</param>
        public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
        {
            var fileInfo = new FileInfo(fileName);
            if (fileInfo.Exists)
            {
#if !SILVERLIGHT
                FileTouched(fileInfo.LastWriteTimeUtc);
#else
                FileTouched(fileInfo.LastWriteTime);
#endif
            }
            else
            {
                FileTouched();
            }
            this.file = CreateFileStream(false);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="parameters">The parameters.</param>
        public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters)
            : base(fileName, parameters)
        {
            var fileInfo = new FileInfo(fileName);
            if (fileInfo.Exists)
            {
#if !SILVERLIGHT
                FileTouched(fileInfo.LastWriteTimeUtc);
#else
                FileTouched(fileInfo.LastWriteTime);
#endif
                this.currentFileLength = fileInfo.Length;
            }
            else
            {
                FileTouched();
                this.currentFileLength = 0;
            }

            this.file = this.CreateFileStream(false);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="parameters">The parameters.</param>
        public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
        {
            try
            {
                this.mutex = CreateSharableMutex(GetMutexName(fileName));
                this.file = CreateFileStream(true);
            }
            catch
            {
                if (this.mutex != null)
                {
                    this.mutex.Close();
                    this.mutex = null;
                }

                if (this.file != null)
                {
                    this.file.Close();
                    this.file = null;
                }

                throw;
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="RetryingMultiProcessFileAppender" /> class.
 /// </summary>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="parameters">The parameters.</param>
 public RetryingMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
 {
 }