FileInfo::CopyTo Method (String^)

 
System_CAPS_noteNote

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Copies an existing file to a new file, disallowing the overwriting of an existing file.

Namespace:   System.IO
Assembly:  mscorlib (in mscorlib.dll)

public:
FileInfo^ CopyTo(
	String^ destFileName
)

Parameters

destFileName
Type: System::String^

The name of the new file to copy to.

Return Value

Type: System.IO::FileInfo^

A new file with a fully qualified path.

Exception Condition
ArgumentException

destFileName is empty, contains only white spaces, or contains invalid characters.

IOException

An error occurs, or the destination file already exists.

SecurityException

The caller does not have the required permission.

ArgumentNullException

destFileName is null.

UnauthorizedAccessException

A directory path is passed in, or the file is being moved to a different drive.

DirectoryNotFoundException

The directory specified in destFileName does not exist.

PathTooLongException

The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.

NotSupportedException

destFileName contains a colon (:) within the string but does not specify the volume.

Use the CopyTo method to allow overwriting of an existing file.

System_CAPS_cautionCaution

Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior

The following example demonstrates both overloads of the CopyTo method.

using namespace System;
using namespace System::IO;

int main()
{
   String^ path = "c:\\MyTest.txt";
   String^ path2 = "c:\\MyTest.txttemp";
   FileInfo^ fi1 = gcnew FileInfo( path );
   FileInfo^ fi2 = gcnew FileInfo( path2 );
   try
   {
      // Create the file and clean up handles.
      FileStream^ fs = fi1->Create();
      if ( fs )
         delete (IDisposable^)fs;

      //Ensure that the target does not exist.
      fi2->Delete();

      //Copy the file.
      fi1->CopyTo( path2 );
      Console::WriteLine( "{0} was copied to {1}.", path, path2 );

      //Try to copy it again, which should succeed.
      fi1->CopyTo( path2, true );
      Console::WriteLine( "The second Copy operation succeeded, which is expected." );
   }
   catch ( Exception^ ) 
   {
      Console::WriteLine( "Double copying was not allowed, which is not expected." );
   }
}
//This code produces output similar to the following; 
//results may vary based on the computer/file structure/etc.:
//
//The second Copy operation succeeded, which is expected.

The following example demonstrates copying one file to another file, throwing an exception if the destination file already exists.

using namespace System;
using namespace System::IO;
int main()
{
   try
   {

      // Create a reference to a file, which might or might not exist.
      // If it does not exist, it is not yet created.
      FileInfo^ fi = gcnew FileInfo( "temp.txt" );

      // Create a writer, ready to add entries to the file.
      StreamWriter^ sw = fi->AppendText();
      sw->WriteLine( "Add as many lines as you like..." );
      sw->WriteLine( "Add another line to the output..." );
      sw->Flush();
      sw->Close();

      // Get the information out of the file and display it.
      StreamReader^ sr = gcnew StreamReader( fi->OpenRead() );
      Console::WriteLine( "This is the information in the first file:" );
      while ( sr->Peek() != -1 )
            Console::WriteLine( sr->ReadLine() );

      // Copy this file to another file. The file will not be overwritten if it already exists.
      FileInfo^ newfi = fi->CopyTo( "newTemp.txt" );

      // Get the information out of the new file and display it.* sr = new StreamReader(newfi->OpenRead());
      Console::WriteLine( "{0}This is the information in the second file:", Environment::NewLine );
      while ( sr->Peek() != -1 )
            Console::WriteLine( sr->ReadLine() );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( e->Message );
   }

}
//This code produces output similar to the following; 
//results may vary based on the computer/file structure/etc.:
//
//This is the information in the first file:
//Add as many lines as you like...
//Add another line to the output...
//
//This is the information in the second file:

FileIOPermission

for reading and writing files. Associated enumerations: FileIOPermissionAccess::Read, FileIOPermissionAccess::Write

Universal Windows Platform
Available since 10
.NET Framework
Available since 1.1
Silverlight
Available since 2.0
Windows Phone Silverlight
Available since 7.0
Return to top
Show: