Benennen Sie eine Datei in C # um

Wie benenne ich eine Datei mit C # um?

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

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

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

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.

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

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");

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.

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);
}

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();
        }
    }
}

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);
        }
    }

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);

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

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));

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);
}

  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);               
        }
    }

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;)

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.

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);
    }
}