Copy file from source to destination

   
 

#region License and Copyright
/* -------------------------------------------------------------------------
 * Dotnet Commons IO
 *
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
 * for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public License 
 * along with this library; if not, write to the 
 * 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, 
 * Boston, 
 * MA 02111-1307 
 * USA 
 * 
 * -------------------------------------------------------------------------
 */
#endregion

using System;
using System.Collections;
using System.Globalization;
using System.IO;

namespace Dotnet.Commons.IO
{
    class MainClass{
        /// --------------------------------------------------------------------------
        /// <summary>
        ///  Copy file from source to destination. The directories up to 
        ///  <i>destination</i> will be created if they don&#039;t already exist. 
        /// </summary>        
        /// <param name="source"></param>
        /// <param name="destination"></param>
        /// --------------------------------------------------------------------------
        public static void CopyFile(string source, string destination)
        {
            FileInfo sourceFile = new FileInfo(source);            
            FileInfo destFile = new FileInfo(destination);

            CopyFile(sourceFile, destFile);
        }

    /// --------------------------------------------------------------------------
    /// <summary>
    ///  Copy file from source to destination. The directories up to 
    ///  <i>destination</i> will be created if they don&#039;t already exist. 
    ///  <i>destination</i> will be overwritten if it already exists.
    ///  The copy will have the same file date as the original.
    /// </summary>
    /// <param name="source">An existing non-directory <see cref="FileInfo"/> to copy</param>
    /// <param name="destination">A non-directory <see cref="FileInfo"/> to write bytes to</param>
    /// <exception cref="IOException"/>
    /// <exception cref="FileNotFoundException"/>
    /// <remarks>Ported from Jakarta Commons IO FileUtils</remarks>
    /// --------------------------------------------------------------------------
    public static void CopyFile(FileInfo source, 
                                    FileInfo destination)
    {
      CopyFile(source, destination, true, true);
    }

    /// --------------------------------------------------------------------------
    /// <summary>
    ///  Copy file from source to destination. The directories up to 
    ///  <i>destination</i> will be created if they don&#039;t already exist. 
    /// </summary>
    /// <param name="source">An existing non-directory <see cref="FileInfo"/> to copy</param>
    /// <param name="destination">A non-directory <see cref="FileInfo"/> to write bytes to</param>
    /// <param name="preserveFileDate">flag to indicate if the file date of 
        /// the copy should be the same as the original.</param>
    /// <param name="overwriteIfExists">Flag to indicate if the file 
        /// is to be overwritten if already exists</param>
    /// <exception cref="IOException"/>
    /// <exception cref="FileNotFoundException"/>
    /// <remarks>Ported from Jakarta Commons IO FileUtils</remarks>
    /// --------------------------------------------------------------------------
    public static void CopyFile(FileInfo source, 
                                    FileInfo destination, 
                                    bool preserveFileDate, 
                                    bool overwriteIfExists)
    {
      
      //check source exists
      if (!source.Exists) 
      {
        string message = "File &#039;" + source.FullName + "&#039; does not exist";
        throw new FileNotFoundException(message);
      }
      
      //does destinations directory exist ?
      if (destination.Directory != null &amp;&amp; !destination.Directory.Exists) 
      {
        destination.Directory.Create();
      }

      //make sure we can write to destination
      if (destination.Exists &amp;&amp; (destination.Attributes &amp; FileAttributes.ReadOnly)== FileAttributes.ReadOnly) 
      {
        String message = "Unable to open file &#039;" + destination.FullName + "&#039; for writing.";
        throw new IOException(message);
      }

      //makes sure it is not the same file        
      if (source.DirectoryName.Equals(destination.DirectoryName)) 
      {
        String message = "Unable to write file &#039;" + source + "&#039; on itself.";
        throw new IOException(message);
      }
      
      
      File.Copy(source.FullName, destination.FullName, overwriteIfExists);          
      destination.Refresh();
      
      if (source.Length != destination.Length) 
      {
        String message =
          "Failed to copy full contents from "
          + source.FullName
          + " to "
          + destination.FullName;
        throw new IOException(message);
      }
        
      if (preserveFileDate) 
      {
        //file copy should preserve file date
        destination.LastWriteTime = source.LastWriteTime;        
      }
    }

        /// <summary>
        /// Copy all the files in a directory into a destination folder. This operation performs
        /// a deep copy, meaning it copies all the files in the subdirectory inside the source directory.
        /// </summary>
        /// <param name="sourcePath">source directory to copy from</param>
        /// <param name="destinationPath">destination to copy to</param>
        /// <exception cref="ArgumentException">If the source directory does not exist</exception>
        /// <exception cref="IOException">if an I/O error occurs while copying the files</exception>
        public static void CopyFiles(string sourcePath,
                                     string destinationPath)
        {
            CopyFiles(new DirectoryInfo(sourcePath), new DirectoryInfo(destinationPath));
        }

        /// <summary>
        /// Copy all the files in a directory into a destination folder. This operation performs
        /// a deep copy, meaning it copies all the files in the subdirectory inside the source directory.
        /// </summary>
        /// <param name="source">source directory to copy from</param>
        /// <param name="destination">destination to copy to</param>
        /// <exception cref="ArgumentException">If the source directory does not exist</exception>
        /// <exception cref="IOException">if an I/O error occurs while copying the files</exception>
        public static void CopyFiles(DirectoryInfo source,
                                    DirectoryInfo destination)
        {

            if (!source.Exists)
                throw new ArgumentException(string.Format("Source directory &#039;{0}&#039; does not exist", source));

            if (!destination.Exists)
                destination.Create();

            FileInfo[] sourceFiles = source.GetFiles();
            foreach (FileInfo file in sourceFiles)
            {
                file.CopyTo(destination.FullName + Path.DirectorySeparatorChar + file.Name);
            }

            DirectoryInfo[] subdirs = source.GetDirectories();
            foreach (DirectoryInfo subdir in subdirs)
            {
                DirectoryInfo destSubDir = Directory.CreateDirectory(destination.FullName + Path.DirectorySeparatorChar + subdir.Name);
                CopyFiles(subdir, destSubDir);
            }
        }
   }
}

   
     


This entry was posted in File Stream. Bookmark the permalink.