Rename a file in C#

Question

How do I rename a file using C#?

Omphalos

I'd hate to add that there is a problem here all the solutions here especially if you do compares and are moving the file from one location to another (directory as well as filename) insofar as you should be aware that a volume could be a junction point... so if newname is q:\SomeJunctionDirectory\hello.txt and the old name is c:\TargetOfJunctionPoint\hello.txt... the files are the same but the names aren't. – Judicious

Answer 1

Take a look at System.IO.File.Move, "move" the file to a new name.

System.IO.File.Move("oldfilename", "newfilename");

Klaipeda

This solution does not work when file names differ only in letter case. For example file.txt and File.txt – Spitsbergen

@SepehrM, I just double checked and it works fine on my Windows 8.1 machine. – Klaipeda

I'm not sure why this happens but take a look at these posts: #8153231 and codeproject.com/Tips/365773/… – Spitsbergen

@SepehrM, I did not test it, but the samples you point to use FileInfo.Move and not File.Move so maybe that has something to do with it? – Klaipeda

Thanks for getting back. Unfortunately I tested with File.Move and still have the same issue! – Spitsbergen

What OS are you testing on? – Klaipeda

Windows 8.1 Enterprise. We first encountered this error on one of our test machines whose OS is the same. This issue does NOT always occur. Sometimes we see a different behavior and I have no idea as to what causes this issue. – Spitsbergen

It is curious that you say it does not always happen, so sometimes the filename does change case. Just to ask the obvious, have you checked that the operation is not possibly failing? Maybe you have a try/catch which is catching an exception and now showing it? Just some guesses, so I don't know if they will help. – Klaipeda

Yes, all exceptions are logged automatically. For now I'm basically renaming the file to a random name and then renaming it back to the desired one. I'll get back to you if I ever find the cause of this problem. – Spitsbergen

I also found this to work with a little extra code after uploading to IIS. No delete required. System.IO.File.Move(Path.Combine(HttpContext.Server.MapPath("~/FileUploads/Photography/"), item.Filename), Path.Combine(HttpContext.Server.MapPath("~/FileUploads/Photography/"), "test.nef")); – Klausenburg

I wish MS provided a better method. One has to deal with file extensions too – Diadromous

@Spitsbergen Windows file system names are case insensitive. File.txt and file.txt are treated as the same file name. So it's not clear to me when you say the solution doesn't work. What are you doing exactly that isn't working? – Lesko

@Michael, the file system is case insensitive, but it does store the filename in the original case as entered by the user. In SepehrM's case, he was trying to change the case of a file, which for some reason was not working. The case insensitive matching was working. HTH – Klaipeda

Here, we should take into account that both oldfilename and newfilename are referring to the full path of the file (example: "D:\\MyProjects\\XProj\\myFile.txt"). And second when renaming we should exclude file name and extension from full path, i.e. $"{Path.GetDirectoryName(fullPath)}\\NewFileName{extension}") – Turnabout

@ArsenKhachaturyan, you only need the full path if the file is not in the current working directory. If the file to be renamed is in the current working directory you only need to specify the filename. – Klaipeda

@ChrisTaylor agree with you, it's kind of thing to remember to do. So generally good practice could be to use the full path, to not encounter bad surprises. – Turnabout

Just FYI for everyone, you will only have problems with case sensitive files not changing if they fall into the old 8.3 limit. – Columnist

To workaround the case insensitive filename, one could rename to a random filename using Path.GetRandomFileName() and then rename back to the different cased filename. If you are not comfortable doing this for everything, you could do a case-insensitive check for both names, and apply this trick only when they match. – Gynaecocracy

Answer 2

System.IO.File.Move(oldNameFullPath, newNameFullPath);

Rachmaninoff

Answer 3

In the File.Move method, this won't overwrite the file if it is already exists. And it will throw an exception.

So we need to check whether the file exists or not.

/* Delete the file if exists, else no exception thrown. */

File.Delete(newFileName); // Delete the existing file if exists
File.Move(oldFileName,newFileName); // Rename the oldFileName into newFileName

Or surround it with a try catch to avoid an exception.

Pleurodynia

be really careful with this approach... if your destination directory and your source directory are the same, and the "newname" actually a case-sensitive version of "oldFileName", you will delete before you get a chance to move your file. – Judicious

You also cannot just check the strings for equality as there are several ways of representing a single file path. – Hemolysis

File.Move has an overload method now that allows you to overwrite the file - File.Move(oldPath, newPath, true) – Jurisdiction

@Jurisdiction I don't see that third parameter in File.Move. – Leopoldeen

@Leopoldeen It's in .Net core 3.0 and later - learn.microsoft.com/en-us/dotnet/api/… – Jurisdiction

@Jurisdiction Indeed. It's still not in .Net Framework 4.6.1, unfort. – Leopoldeen

Answer 4

Just add:

namespace System.IO
{
    public static class ExtendedMethod
    {
        public static void Rename(this FileInfo fileInfo, string newName)
        {
            fileInfo.MoveTo(fileInfo.Directory.FullName + "\\" + newName);
        }
    }
}

And then...

FileInfo file = new FileInfo("c:\test.txt");
file.Rename("test2.txt");

Phototonus

... "\\" + newName + fileInfo.Extension – Kimbrough

eww... Use Path.Combine() instead of assembling the file. – Judicious

Answer 5

You can use File.Move to do it.

Tolbooth

Answer 6

1. First solution

   Avoid System.IO.File.Move solutions posted here (marked answer included). It fails over networks. However, copy/delete pattern works locally and over networks. Follow one of the move solutions, but replace it with Copy instead. Then use File.Delete to delete the original file.

   You can create a Rename method to simplify it.

2. Ease of use

   Use the VB assembly in C#. Add reference to Microsoft.VisualBasic

   Then to rename the file:

   Microsoft.VisualBasic.FileIO.FileSystem.RenameFile(myfile, newName);

   Both are strings. Note that myfile has the full path. newName does not. For example:

   a = "C:\whatever\a.txt";
   b = "b.txt";
   Microsoft.VisualBasic.FileIO.FileSystem.RenameFile(a, b);
   

   The C:\whatever\ folder will now contain b.txt.

Culinarian

just so you know, Microsoft.VisualBasic.FileIO.FileSystem.RenameFile calls File.Move. Other thank normalizing the original file and doing some additional error checks on the arguments ie. file exists, file name not null etc. it then calls File.Move. – Klaipeda

Unless Copy() copies all file streams, which I assume it doesn't, I would stay away from using delete/copy. I assume Move(), at least when staying on the same file system, is simply a rename and thus all file streams will be maintained. – Joly

"it fails over the network" then you're going to copy & delete which is actually download & upload, just for code-time convenience... What kind of network? Windows shared folder (smb), ftp , ssh or whatever all have commands/primitives for file moving/renaming unless not permitted (e.g. read-only). – Hamm

Answer 7

You can copy it as a new file and then delete the old one using the System.IO.File class:

if (File.Exists(oldName))
{
    File.Copy(oldName, newName, true);
    File.Delete(oldName);
}

Mealymouthed

Note to anyone reading this: This is an anti-pattern, the file might be deleted or renamed by another process or the OS between the check for if it exists and your call to Copy. You need to instead use a try catch. – Raouf

If the volume is the same, this is also a huge waste of I/O since a move would actually do a rename at directory information level. – Judicious

I am processing thousands of files and got the impression Copy/Delete is faster than Move. – Fratricide

How would anyone come up with such an idea. Faster or not at least you're murdering the disk. By saying "rename" in the question it should means rename locally which of course involves no cross-partition moving. – Hamm

with File.Move I ran into UnauthorizedAccessException, but this sequence of Copy and Delete worked. Thanks! – Og

Answer 8

public void RenameFile(string filePath, string newName)
{
    FileInfo fileInfo = new FileInfo(filePath);
    fileInfo.MoveTo(fileInfo.Directory.FullName + "\\" + newName);
}

Sateen

Can you explain how this is different or relevant compared to the other answers? – Dishman

@Dishman I just made it a clean and reusable method. So you can use it with minimum dependency. – Sateen

Answer 9

NOTE: In this example code we open a directory and search for PDF files with open and closed parenthesis in the name of the file. You can check and replace any character in the name you like or just specify a whole new name using replace functions.

There are other ways to work from this code to do more elaborate renames but my main intention was to show how to use File.Move to do a batch rename. This worked against 335 PDF files in 180 directories when I ran it on my laptop. This is spur of the moment code and there are more elaborate ways to do it.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BatchRenamer
{
    class Program
    {
        static void Main(string[] args)
        {
            var dirnames = Directory.GetDirectories(@"C:\the full directory path of files to rename goes here");

            int i = 0;

            try
            {
                foreach (var dir in dirnames)
                {
                    var fnames = Directory.GetFiles(dir, "*.pdf").Select(Path.GetFileName);

                    DirectoryInfo d = new DirectoryInfo(dir);
                    FileInfo[] finfo = d.GetFiles("*.pdf");

                    foreach (var f in fnames)
                    {
                        i++;
                        Console.WriteLine("The number of the file being renamed is: {0}", i);

                        if (!File.Exists(Path.Combine(dir, f.ToString().Replace("(", "").Replace(")", ""))))
                        {
                            File.Move(Path.Combine(dir, f), Path.Combine(dir, f.ToString().Replace("(", "").Replace(")", "")));
                        }
                        else
                        {
                            Console.WriteLine("The file you are attempting to rename already exists! The file path is {0}.", dir);
                            foreach (FileInfo fi in finfo)
                            {
                                Console.WriteLine("The file modify date is: {0} ", File.GetLastWriteTime(dir));
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }
}

Gluttonize

That's... completely beside the point, on a question answered exactly to the point 3 years ago. – Intromission

It's a valid example. Overkill maybe but not beside the point. +1 – Singlephase

@Adam: it's a very specific implementation of exactly the answer that was already given three years before, on a question that wasn't about any specific implementation in the first place. Don't see how that's in any way constructive. – Intromission

@Intromission then we have different definitions of 'beside the point', which is not surprising since it's a subjective term. – Singlephase

@Intromission if it's irrelevant for you then that is fine. Some people like verbosity because it helps them to find "real world" implementations of "sample/example" code. It renames file(s). How it is beside the point is pretty much as Adam said, it's subjective. For some reason you feel it to be absolutely objective. Oh well, to each his own. Thanks for the input, either way. – Gluttonize

Answer 10

None of the answers mention writing a unit testable solution. You could use System.IO.Abstractions as it provides a testable wrapper around FileSystem operations, using which you can create a mocked file system objects and write unit tests.

using System.IO.Abstractions;

IFileInfo fileInfo = _fileSystem.FileInfo.FromFileName("filePathAndName");
fileInfo.MoveTo(Path.Combine(fileInfo.DirectoryName, newName));

It was tested, and it is working code to rename a file.

Norahnorbert

Answer 11

Use:

using System.IO;

string oldFilePath = @"C:\OldFile.txt"; // Full path of old file
string newFilePath = @"C:\NewFile.txt"; // Full path of new file

if (File.Exists(newFilePath))
{
    File.Delete(newFilePath);
}
File.Move(oldFilePath, newFilePath);

Swinge

If you're going to do this, I'd suggest checking that the 'oldFilePath' exists before doing anything... or else you'll delete the 'newFilePath' for no reason. – Botanical

Answer 12

Use:

public static class FileInfoExtensions
{
    /// <summary>
    /// Behavior when a new filename exists.
    /// </summary>
    public enum FileExistBehavior
    {
        /// <summary>
        /// None: throw IOException "The destination file already exists."
        /// </summary>
        None = 0,
        /// <summary>
        /// Replace: replace the file in the destination.
        /// </summary>
        Replace = 1,
        /// <summary>
        /// Skip: skip this file.
        /// </summary>
        Skip = 2,
        /// <summary>
        /// Rename: rename the file (like a window behavior)
        /// </summary>
        Rename = 3
    }


    /// <summary>
    /// Rename the file.
    /// </summary>
    /// <param name="fileInfo">the target file.</param>
    /// <param name="newFileName">new filename with extension.</param>
    /// <param name="fileExistBehavior">behavior when new filename is exist.</param>
    public static void Rename(this System.IO.FileInfo fileInfo, string newFileName, FileExistBehavior fileExistBehavior = FileExistBehavior.None)
    {
        string newFileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(newFileName);
        string newFileNameExtension = System.IO.Path.GetExtension(newFileName);
        string newFilePath = System.IO.Path.Combine(fileInfo.Directory.FullName, newFileName);

        if (System.IO.File.Exists(newFilePath))
        {
            switch (fileExistBehavior)
            {
                case FileExistBehavior.None:
                    throw new System.IO.IOException("The destination file already exists.");

                case FileExistBehavior.Replace:
                    System.IO.File.Delete(newFilePath);
                    break;

                case FileExistBehavior.Rename:
                    int dupplicate_count = 0;
                    string newFileNameWithDupplicateIndex;
                    string newFilePathWithDupplicateIndex;
                    do
                    {
                        dupplicate_count++;
                        newFileNameWithDupplicateIndex = newFileNameWithoutExtension + " (" + dupplicate_count + ")" + newFileNameExtension;
                        newFilePathWithDupplicateIndex = System.IO.Path.Combine(fileInfo.Directory.FullName, newFileNameWithDupplicateIndex);
                    }
                    while (System.IO.File.Exists(newFilePathWithDupplicateIndex));

                    newFilePath = newFilePathWithDupplicateIndex;
                    break;

                case FileExistBehavior.Skip:
                    return;
            }
        }
        System.IO.File.Move(fileInfo.FullName, newFilePath);
    }
}

How to use this code

class Program
{
    static void Main(string[] args)
    {
        string targetFile = System.IO.Path.Combine(@"D://test", "New Text Document.txt");
        string newFileName = "Foo.txt";

        // Full pattern
        System.IO.FileInfo fileInfo = new System.IO.FileInfo(targetFile);
        fileInfo.Rename(newFileName);

        // Or short form
        new System.IO.FileInfo(targetFile).Rename(newFileName);
    }
}

Mannikin

Answer 13

I couldn't find an approach which suits me, so I propose my version. Of course, it needs input and error handling.

public void Rename(string filePath, string newFileName)
{
    var newFilePath = Path.Combine(Path.GetDirectoryName(filePath), newFileName + Path.GetExtension(filePath));
    System.IO.File.Move(filePath, newFilePath);
}

Geyserite

Answer 14

In my case, I want the name of the renamed file to be unique, so I add a date-time stamp to the name. This way, the filename of the 'old' log is always unique:

if (File.Exists(clogfile))
{
    Int64 fileSizeInBytes = new FileInfo(clogfile).Length;
    if (fileSizeInBytes > 5000000)
    {
        string path = Path.GetFullPath(clogfile);
        string filename = Path.GetFileNameWithoutExtension(clogfile);
        System.IO.File.Move(clogfile, Path.Combine(path, string.Format("{0}{1}.log", filename, DateTime.Now.ToString("yyyyMMdd_HHmmss"))));
    }
}

Pepsin

Answer 15

Move is doing the same = copy and delete old one.

File.Move(@"C:\ScanPDF\Test.pdf", @"C:\BackupPDF\" + string.Format("backup-{0:yyyy-MM-dd_HH:mm:ss}.pdf", DateTime.Now));

Pygmy

True, if all you care about is the end result. Internally, not so much. – Lesko

No, Move most certainly does not Copy and Delete. – Eyrie

Answer 16

// Source file to be renamed  
string sourceFile = @"C:\Temp\MaheshChand.jpg";  
// Create a FileInfo  
System.IO.FileInfo fi = new System.IO.FileInfo(sourceFile);  
// Check if file is there  
if (fi.Exists)  
{  
// Move file with a new name. Hence renamed.  
fi.MoveTo(@"C:\Temp\Mahesh.jpg");  
Console.WriteLine("File Renamed.");  
}  

Fagen

Answer 17

public static class ImageRename
{
    public static void ApplyChanges(string fileUrl,
                                    string temporaryImageName,
                                    string permanentImageName)
    {
        var currentFileName = Path.Combine(fileUrl,
                                           temporaryImageName);

        if (!File.Exists(currentFileName))
            throw new FileNotFoundException();

        var extention = Path.GetExtension(temporaryImageName);
        var newFileName = Path.Combine(fileUrl,
                                       $"{permanentImageName}
                                         {extention}");

        if (File.Exists(newFileName))
            File.Delete(newFileName);

        File.Move(currentFileName, newFileName);
    }
}

Acrolith

Answer 18

I've encountered a case when I had to rename the file inside the event handler, which was triggering for any file change, including rename, and to skip forever renaming of the file I had to rename it, with:

1. Making its copy
2. Removing the original

File.Copy(fileFullPath, destFileName); // Both have the format of "D:\..\..\myFile.ext"
Thread.Sleep(100); // Wait for the OS to unfocus the file
File.Delete(fileFullPath);

Turnabout

if you used an using block you could remove thread.sleep and let the program unfocus it automatically, right? – Infectious

@Zoba, if you meant applying using block over File.Copy or File.Delete static methods, then you should know that's not possible because both of them return void. To use using statement, the return type of the method (including constructor) should be the object which type implements the IDisposable interface. – Turnabout

Answer 19

private static void Rename_File(string FileFullPath, string NewName) // nes name without directory actualy you can simply rename with fileinfo.MoveTo(Fullpathwithnameandextension);
        {
            FileInfo fileInfo = new FileInfo(FileFullPath);
            string DirectoryRoot = Directory.GetParent(FileFullPath).FullName;

            string filecreator = FileFullPath.Substring(DirectoryRoot.Length,FileFullPath.Length-DirectoryRoot.Length);
             
            filecreator = DirectoryRoot + NewName;
            try
            {
                fileInfo.MoveTo(filecreator);
            }
            catch(Exception ex)
            {
                Console.WriteLine(filecreator);
                Console.WriteLine(ex.Message);
                Console.ReadKey();
            }

    enter code here
            // string FileDirectory = Directory.GetDirectoryRoot()

        }

Nonchalance

Answer 20

When C# doesn't have some feature, I use C++ or C:

public partial class Program
{
    [DllImport("msvcrt", CallingConvention = CallingConvention.Cdecl, SetLastError = true)]
    public static extern int rename(
            [MarshalAs(UnmanagedType.LPStr)]
            string oldpath,
            [MarshalAs(UnmanagedType.LPStr)]
            string newpath);

    static void FileRename()
    {
        while (true)
        {
            Console.Clear();
            Console.Write("Enter a folder name: ");
            string dir = Console.ReadLine().Trim('\\') + "\\";
            if (string.IsNullOrWhiteSpace(dir))
                break;
            if (!Directory.Exists(dir))
            {
                Console.WriteLine("{0} does not exist", dir);
                continue;
            }
            string[] files = Directory.GetFiles(dir, "*.mp3");

            for (int i = 0; i < files.Length; i++)
            {
                string oldName = Path.GetFileName(files[i]);
                int pos = oldName.IndexOfAny(new char[] { '0', '1', '2' });
                if (pos == 0)
                    continue;

                string newName = oldName.Substring(pos);
                int res = rename(files[i], dir + newName);
            }
        }
        Console.WriteLine("\n\t\tPress any key to go to main menu\n");
        Console.ReadKey(true);
    }
}

Penile

C# absolutely has the ability to rename files. – Neufer

Thanks, This is exactly what i wanted. It can change self name on a executable file. – Shred