Benennen Sie eine Datei in C # um

632

Wie benenne ich eine Datei mit C # um?

Gold
quelle
Ich würde gerne hinzufügen, dass es hier ein Problem mit allen Lösungen gibt, insbesondere wenn Sie die Datei vergleichen und von einem Speicherort an einen anderen verschieben (Verzeichnis sowie Dateiname), sofern Sie sich darüber im Klaren sein sollten, dass ein Volume ein sein könnte Knotenpunkt ... Wenn also der neue Name q: \ SomeJunctionDirectory \ hello.txt und der alte Name c: \ TargetOfJunctionPoint \ hello.txt lautet ... sind die Dateien identisch, die Namen jedoch nicht.
Adrian Hum

Antworten:

966

Schauen Sie sich System.IO.File.Move an und verschieben Sie die Datei unter einem neuen Namen.

System.IO.File.Move("oldfilename", "newfilename");
Chris Taylor
quelle
12
Diese Lösung funktioniert nicht, wenn sich Dateinamen nur in Groß- und Kleinschreibung unterscheiden. Zum Beispiel file.txt und File.txt
SepehrM
2
@SepehrM, ich habe es nur noch einmal überprüft und es funktioniert gut auf meinem Windows 8.1-Computer.
Chris Taylor
1
@SepehrM, ich habe es nicht getestet, aber die Beispiele, auf die Sie verweisen, verwenden FileInfo.Move und nicht File.Move. Vielleicht hat das etwas damit zu tun?
Chris Taylor
2
@SepehrM Windows-Dateisystemnamen unterscheiden nicht zwischen Groß- und Kleinschreibung. File.txt und file.txt werden als der gleiche Dateiname behandelt. Daher ist mir nicht klar, wann Sie sagen, dass die Lösung nicht funktioniert. Was machst du genau das funktioniert nicht?
Michael
4
@Michael, das Dateisystem unterscheidet nicht zwischen Groß- und Kleinschreibung, speichert jedoch den Dateinamen im ursprünglichen Fall, wie vom Benutzer eingegeben. In SepehrMs Fall versuchte er, den Fall einer Datei zu ändern, was aus irgendeinem Grund nicht funktionierte. Das Matching ohne Berücksichtigung der Groß- und Kleinschreibung funktionierte. HTH
Chris Taylor
130
System.IO.File.Move(oldNameFullPath, newNameFullPath);
Aleksandar Vucetic
quelle
47

In der File.Move-Methode wird die Datei dadurch nicht überschrieben, wenn sie bereits vorhanden ist. Und es wird eine Ausnahme auslösen.

Wir müssen also prüfen, ob die Datei existiert oder nicht.

/* 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

Oder umgeben Sie es mit einem Try-Catch, um eine Ausnahme zu vermeiden.

Mohamed Alikhan
quelle
20
Seien Sie bei diesem Ansatz sehr vorsichtig. Wenn Ihr Zielverzeichnis und Ihr Quellverzeichnis identisch sind und der "neue Name" tatsächlich eine zwischen Groß- und Kleinschreibung unterscheidende Version von "oldFileName" ist, werden Sie löschen, bevor Sie die Möglichkeit haben, Ihre Datei zu verschieben.
Adrian Hum
1
Sie können die Zeichenfolgen auch nicht einfach auf Gleichheit überprüfen, da es verschiedene Möglichkeiten gibt, einen einzelnen Dateipfad darzustellen.
Drew Noakes
File.Move verfügt jetzt über eine Überladungsmethode, mit der Sie die Datei überschreiben können - File.Move (oldPath, newPath, true)
Ella
39

Sie können es verwenden File.Move, um es zu tun.

Franci Penov
quelle
34

Einfach hinzufügen:

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

Und dann...

FileInfo file = new FileInfo("c:\test.txt");
file.Rename("test2.txt");
Nogro
quelle
... "\\" + newName + fileInfo.Extension
mac10688
31
eww ... Verwenden Sie Path.Combine (), anstatt die Datei zusammenzustellen.
Adrian Hum
20
  1. Erste Lösung

    Vermeiden Sie hier veröffentlichte System.IO.File.MoveLösungen (markierte Antwort enthalten). Es fällt über Netzwerke aus. Das Kopieren / Löschen von Mustern funktioniert jedoch lokal und über Netzwerke. Befolgen Sie eine der Verschiebungslösungen, ersetzen Sie sie jedoch stattdessen durch Kopieren. Verwenden Sie dann File.Delete, um die Originaldatei zu löschen.

    Sie können eine Umbenennungsmethode erstellen, um sie zu vereinfachen.

  2. Benutzerfreundlichkeit

    Verwenden Sie die VB-Assembly in C #. Verweis auf Microsoft.VisualBasic hinzufügen

    Um die Datei dann umzubenennen:

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

    Beide sind Saiten. Beachten Sie, dass myfile den vollständigen Pfad hat. newName nicht. Zum Beispiel:

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

    Der C:\whatever\Ordner enthält jetzt b.txt.

Strahl
quelle
8
Damit Sie wissen, ruft Microsoft.VisualBasic.FileIO.FileSystem.RenameFile File.Move auf. Andere bedanken sich für die Normalisierung der Originaldatei und einige zusätzliche Fehlerprüfungen für die Argumente, z. Datei existiert, Dateiname nicht null usw. Dann wird File.Move aufgerufen.
Chris Taylor
Wenn Copy () nicht alle Dateistreams kopiert, von denen ich annehme, dass dies nicht der Fall ist, würde ich die Verwendung von delete / copy vermeiden. Ich gehe davon aus, dass Move (), zumindest wenn Sie im selben Dateisystem bleiben, einfach umbenannt wird und somit alle Dateistreams beibehalten werden.
Nickdu
"Es schlägt über das Netzwerk fehl", dann werden Sie kopieren und löschen, was tatsächlich heruntergeladen und hochgeladen wird, nur um die Code-Zeit zu vereinfachen ... Welche Art von Netzwerk? Windows freigegebenen Ordner ( smb) ftp, sshoder was auch immer alle haben Befehle / Primitive für Datei Bewegt- / Umbenennen , es sei denn nicht zulässig (zB read-only).
Meow Cat 2012
16

Sie können es als neue Datei kopieren und dann die alte mit der System.IO.FileKlasse löschen :

if (File.Exists(oldName))
{
    File.Copy(oldName, newName, true);
    File.Delete(oldName);
}
Zaki Choudhury
quelle
4
Hinweis für alle, die dies lesen: Dies ist ein Anti-Pattern. Die Datei wird möglicherweise von einem anderen Prozess oder dem Betriebssystem zwischen der Überprüfung, ob sie vorhanden ist, und Ihrem Aufruf zum Kopieren gelöscht oder umbenannt. Sie müssen stattdessen einen Try-Catch verwenden.
user9993
Wenn das Volume gleich ist, ist dies auch eine enorme Verschwendung von E / A, da ein Verschieben tatsächlich eine Umbenennung auf Verzeichnisinformationsebene bewirken würde.
Adrian Hum
Ich verarbeite Tausende von Dateien und habe den Eindruck, dass Kopieren / Löschen schneller ist als Verschieben.
Roberto
Wie würde jemand auf eine solche Idee kommen? Schneller oder nicht, zumindest ermorden Sie die Festplatte. Wenn Sie in der Frage "umbenennen" sagen, bedeutet dies, dass Sie lokal umbenennen müssen, was natürlich keine partitionübergreifende Verschiebung beinhaltet.
Meow Cat 2012
Mit File.Move bin ich auf UnauthorizedAccessException gestoßen, aber diese Sequenz von Kopieren und Löschen hat funktioniert. Vielen Dank!
Oliver König
6

HINWEIS: In diesem Beispielcode öffnen wir ein Verzeichnis und suchen nach PDF-Dateien mit offener und geschlossener Klammer im Namen der Datei. Sie können jedes Zeichen im gewünschten Namen überprüfen und ersetzen oder einfach einen ganz neuen Namen mit den Ersetzungsfunktionen angeben.

Es gibt andere Möglichkeiten, mit diesem Code zu arbeiten, um aufwändigere Umbenennungen durchzuführen. Meine Hauptabsicht war jedoch, zu zeigen, wie File.Move zum Umbenennen von Stapeln verwendet wird. Dies funktionierte gegen 335 PDF-Dateien in 180 Verzeichnissen, als ich es auf meinem Laptop ausführte. Dies ist spontaner Code, und es gibt ausgefeiltere Möglichkeiten, dies zu tun.

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();
        }
    }
}
MicRoc
quelle
3
Das ist ... völlig nebensächlich, auf eine Frage, die genau auf den Punkt vor 3 Jahren beantwortet wurde.
Nyerguds
2
Es ist ein gültiges Beispiel. Overkill vielleicht, aber nicht nebensächlich. +1
Adam
1
@Adam: Es ist eine sehr spezifische Implementierung genau der Antwort, die bereits drei Jahre zuvor gegeben wurde, auf eine Frage, bei der es überhaupt nicht um eine spezifische Implementierung ging. Sehen Sie nicht, wie konstruktiv das ist.
Nyerguds
@Nyerguds dann haben wir verschiedene Definitionen von "neben dem Punkt", was nicht überraschend ist, da es ein subjektiver Begriff ist.
Adam
@Nyerguds wenn es für dich irrelevant ist, dann ist das in Ordnung. Einige Leute mögen Ausführlichkeit, weil es ihnen hilft, "reale" Implementierungen von "Beispiel- / Beispiel" -Code zu finden. Es benennt Datei (en) um. Wie es nebensächlich ist, ist ziemlich genau wie Adam sagte, es ist subjektiv. Aus irgendeinem Grund empfinden Sie es als absolut objektiv. Na ja, jedem sein eigenes. Vielen Dank für die Eingabe.
MicRoc
6

Hoffnungsvoll! es wird für Sie hilfreich sein. :) :)

  public static class FileInfoExtensions
    {
        /// <summary>
        /// behavior when new filename is exist.
        /// </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);
        }
    }

Wie benutze ich diesen 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);
        }
    }

quelle
6

Verwenden:

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);
Avinash Singh
quelle
5
Wenn Sie dies tun, würde ich vorschlagen, zu überprüfen, ob der 'oldFilePath' vorhanden ist, bevor Sie etwas tun ... oder Sie löschen den 'newFilePath' ohne Grund.
John Kroetch
Kompiliert das überhaupt ( Using System.IO;)?
Peter Mortensen
3

In meinem Fall möchte ich, dass der Name der umbenannten Datei eindeutig ist, daher füge ich dem Namen einen Datums- / Zeitstempel hinzu. Auf diese Weise ist der Dateiname des 'alten' Protokolls immer eindeutig:

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"))));
    }
}
real_yggdrasil
quelle
2

Verschieben macht dasselbe = Altes kopieren und löschen.

File.Move(@"C:\ScanPDF\Test.pdf", @"C:\BackupPDF\" + string.Format("backup-{0:yyyy-MM-dd_HH:mm:ss}.pdf",DateTime.Now));
Nalan Madheswaran
quelle
1
Stimmt, wenn Sie sich nur um das Endergebnis kümmern. Intern nicht so sehr.
Michael
Nein, Verschieben kopiert und löscht mit Sicherheit nicht.
Jim Balter
1

Ich konnte keinen Ansatz finden, der zu mir passt, also schlage ich meine Version vor. Natürlich brauchen Eingabe, Fehlerbehandlung.

public void Rename(string filePath, string newFileName)
{
    var newFilePath = Path.Combine(Path.GetDirectoryName(filePath), newFileName + Path.GetExtension(filePath));
    System.IO.File.Move(filePath, newFilePath);
}
Valentasmus
quelle
1
  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);               
        }
    }
AminGolmahalle
quelle
0

Ich bin auf einen Fall gestoßen, in dem ich die Datei im Ereignishandler umbenennen musste, der für jede Dateiänderung, einschließlich Umbenennen, ausgelöst wurde, und um das Umbenennen der Datei für immer zu überspringen, musste ich sie umbenennen, mit:

  1. Kopie erstellen
  2. Original entfernen
File.Copy(fileFullPath, destFileName); // both has the format of "D:\..\..\myFile.ext"
Thread.Sleep(100); // wait OS to unfocus the file 
File.Delete(fileFullPath);

Nur für den Fall, dass jemand ein solches Szenario hat;)

Arsen Khachaturyan
quelle
0
int rename(const char * oldname, const char * newname);

Die Funktion rename () ist in der Header-Datei stdio.h definiert. Es benennt eine Datei oder ein Verzeichnis von altem Namen in neuen Namen um. Der Umbenennungsvorgang entspricht dem Verschieben. Daher können Sie diese Funktion auch zum Verschieben einer Datei verwenden.

Meruemu
quelle
Herzlich willkommen. Bei dieser Frage geht es darum, eine Datei in der Sprache C # umzubenennen. Ich bin mir nicht sicher, wie es hier hilft, auf etwas aus der Standardbibliothek von C (nicht C #) hinzuweisen.
Jeff Dammeyer
-10

Wenn C # keine Funktion hat, verwende ich C ++ oder 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);
    }
}
Alexander Chernosvitov
quelle
20
C # hat absolut die Möglichkeit, Dateien umzubenennen.
Andrew Barber
76
Ich bin sprachlos
Chris McGrath
Danke, genau das wollte ich. Es kann den Selbstnamen einer ausführbaren Datei ändern.
Jake