Sample of a Manager with Singleton for make a few specific IO operation

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Framework
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Manager i/o. </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    public class ManagerIO
    {
        #region singleton
        /// <summary>   The instance. </summary>
        private static ManagerIO instance = null;
        /// <summary>   The padlock. </summary>
        private static readonly object padlock = new object();
        
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Prevents a default instance of the <see cref="ManagerIO"/> class from being created.
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        
        ManagerIO()
        {
            //if (_Log.IsDebugEnabled)
            // _Log.DebugFormat("Nouvelle instance de {0}", Assembly.GetExecutingAssembly());
        }
        
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets the instance. </summary>
        ///
        /// <value> The instance. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        
        public static ManagerIO Instance
        {
            get
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new ManagerIO();
                    }
                
                    return instance;
                }
            }
        }

        #endregion Gestion du singleton
        
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Copies the directory (with protected files). </summary>
        ///
        /// <param name="SourcePath">       The source path. </param>
        /// <param name="DestinationPath">  The destination path. </param>
        /// <param name="Recursive">        if set to <c>true</c> [recursive]. </param>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        
        public Boolean CopyDirectory(string SourcePath, string DestinationPath, bool Recursive)
        {
            List<string> Paths = new List<string>();
            List<string> Files = new List<string>();
            Boolean bResult = false;

            if (String.IsNullOrEmpty(SourcePath))
                throw new ArgumentNullException("SourcePath");
            if (String.IsNullOrEmpty(DestinationPath))
                throw new ArgumentNullException("DestinationPath");

            try
            {
                foreach (string StringPath in this.DirectoryList(SourcePath, Recursive, null))
                {
                    Paths.Add(StringPath);
                }
                
                foreach (string StringPath in this.FileList(SourcePath, Recursive, null))
                {
                    Files.Add(StringPath);
                }
                
                foreach (string dirPath in Paths)
                {
                    System.IO.Directory.CreateDirectory(dirPath.Replace(SourcePath, DestinationPath));
                }
                
                foreach (string newPath in Files)
                {
                    System.IO.File.Copy(newPath, newPath.Replace(SourcePath, DestinationPath), Recursive);
                }
            
                bResult = true;
            }
            catch (Exception ex)
            {
                ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ex);
                bResult = false;
            }
        
            return bResult;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Renames the specified file. </summary>
        ///
        /// <exception cref="ArgumentNullException">    Thrown when one or more required arguments are
        ///                                             null. </exception>
        /// <exception cref="IOException">              Thrown when an IO failure occurred. </exception>
        ///
        /// <param name="oldPath">  Full path of file to rename. </param>
        /// <param name="newName">  New file name. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void RenameFile(string oldPath, string newName)
        {
            if (String.IsNullOrEmpty(oldPath))
                throw new ArgumentNullException("oldPath");
            if (String.IsNullOrEmpty(newName))
                throw new ArgumentNullException("newName");

            string oldName = Path.GetFileName(oldPath);

            // if the file name is changed
            if (!String.Equals(oldName, newName, StringComparison.CurrentCulture))
            {
                string folder = Path.GetDirectoryName(oldPath);
                string newPath = Path.Combine(folder, newName);
                bool changeCase = String.Equals(oldName, newName, StringComparison.CurrentCultureIgnoreCase);

                // if renamed file already exists and not just changing case
                if (File.Exists(newPath) && !changeCase)
                {
                    throw new IOException(String.Format("File already exists:n{0}", newPath));
                }
                else if (changeCase)
                {
                    // Move fails when changing case, so need to perform two moves
                    string tempPath = Path.Combine(folder, Guid.NewGuid().ToString());
                    Directory.Move(oldPath, tempPath);
                    Directory.Move(tempPath, newPath);
                }
                else
                {
                    Directory.Move(oldPath, newPath);
                }
            }
        } 
        
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Liste des fichier protégé ou non d'un répertoires. </summary>
        ///
        /// <param name="RootDirectory">        The root directory. </param>
        /// <param name="SearchAllDirectories"> if set to <c>true</c> [search all directories]. </param>
        /// <param name="Filter">               The filter. </param>
        ///
        /// <returns>   . </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
            
        public List<string> FileList(string RootDirectory,
            bool SearchAllDirectories, Predicate<string> Filter)
        {
            List<string> retList = new List<string>();

            if (String.IsNullOrEmpty(RootDirectory))
                throw new ArgumentNullException("RootDirectory");

            try
            {
                List<string> DirList = new List<string> { RootDirectory };
                
                if (SearchAllDirectories)
                {
                    DirList.AddRange(this.DirectoryList(RootDirectory, SearchAllDirectories, Filter));
                }
                
                foreach (string DirectoryStr in DirList)
                {
                    DirectoryInfo di = new DirectoryInfo(DirectoryStr);
                    try
                    {
                        foreach (FileInfo FileStr in di.GetFiles())
                        {
                            try
                            {
                                if ((Filter == null) || (Filter(FileStr.FullName)))
                                {
                                    retList.Add(FileStr.FullName);
                                }
                            }
                            catch (Exception ax)
                            {
                                ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ax);
                            }
                        }
                    }
                    catch (UnauthorizedAccessException)
                    {
                    }
                    catch (Exception ex)
                    {
                        ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ex);
                    }
                }
            }
            catch (Exception ex)
            {
                ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ex);
            }
            return retList;
        }
        
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Liste d'un répertoire protegé ou non. </summary>
        ///
        /// <param name="RootDirectory">        The root directory. </param>
        /// <param name="SearchAllDirectories"> if set to <c>true</c> [search all directories]. </param>
        /// <param name="Filter">               The filter. </param>
        ///
        /// <returns>   . </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
            
        public List<string> DirectoryList(string RootDirectory,
            bool SearchAllDirectories, Predicate<string> Filter)
        {
            List<string> retList = new List<string>();

            if (String.IsNullOrEmpty(RootDirectory))
                throw new ArgumentNullException("RootDirectory"); 

            try
            {
                DirectoryInfo di = new DirectoryInfo(RootDirectory);
                
                foreach (DirectoryInfo DirectoryStr in di.GetDirectories())
                {
                    try
                    {
                        if ((Filter == null) || (Filter(DirectoryStr.FullName)))
                        {
                            retList.Add(DirectoryStr.FullName);
                            
                            if (SearchAllDirectories)
                            {
                                retList.AddRange(this.DirectoryList(DirectoryStr.FullName, SearchAllDirectories,
                                    Filter));
                            }
                        }
                    }
                    catch (UnauthorizedAccessException)
                    {
                    }
                    catch (Exception exx)
                    {
                        ManagerLogger.Instance.LogException("RemoteSurvey.Tools", exx);
                    }
                }
            }
            catch (Exception ex)
            {
                ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ex);
            }
            return retList;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets file as stream. </summary>
        ///
        /// <exception cref="ArgumentNullException">    Thrown when one or more required arguments are
        ///                                             null. </exception>
        ///
        /// <param name="psFilePath">   Full pathname of the ps file. </param>
        ///
        /// <returns>   The file as stream. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public  byte[] GetFileAsStream(String psFilePath)
        {
            if (String.IsNullOrEmpty(psFilePath))
                throw new ArgumentNullException("psFilePath"); 
            
            byte[] fileContent = null;
            
            try
            {
                if (File.Exists(psFilePath))
                {
                    fileContent = File.ReadAllBytes(psFilePath);
                }
            }
            catch (Exception ex)
            {
                ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ex);
            }

            return fileContent;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Saves a stream as file. </summary>
        ///
        /// <param name="pByteArray">   Array of bytes. </param>
        /// <param name="psSaveFileAs"> The ps save file as. </param>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        
        public Boolean SaveStreamAsFile( byte[] pByteArray, String psSaveFileAs)
        {
            Boolean bResult = false;

            if (String.IsNullOrEmpty(psSaveFileAs))
                throw new ArgumentNullException("psSaveFileAs");

            try
            {
                // instance a memory stream and pass the
                // byte array to its constructor
                MemoryStream ms = new MemoryStream(pByteArray);

                // instance a filestream pointing to the
                // storage folder, use the original file name
                // to name the resulting file

                FileStream fs = new FileStream(psSaveFileAs, FileMode.Create); 

                // write the memory stream containing the original
                // file as a byte array to the filestream

                ms.WriteTo(fs); 

                // clean up
                ms.Close();
                fs.Close();
                fs.Dispose(); 
            
                bResult = true;
            }
            catch (Exception ex)
            {
                bResult = false;
                ManagerLogger.Instance.LogException("RemoteSurvey.Tools", ex);
            }
            return bResult;
        }
    }
}