C# DirectoryInfo.MoveTo方法代码示例

        void OPMShellTreeView_AfterLabelEdit(object sender, NodeLabelEditEventArgs e)
        {
            if (!string.IsNullOrEmpty(e.Label))
            {
                string newName = e.Label;
                DirectoryInfo di = new DirectoryInfo(e.Node.FullPath);
                if (di != null && di.Exists && di.Parent != null && di.Parent.Exists)
                {
                    string newPath = Path.Combine(di.Parent.FullName, newName);

                    try
                    {
                        di.MoveTo(newPath);
                        e.Node.Name = di.Name;
                        e.Node.Tag = di;
                        e.CancelEdit = false;

                        SelectedNode = null;
                        SelectedNode = e.Node;

                        return;
                    }
                    catch { }
                }
            }

            e.CancelEdit = true;
        }

 public override void DeleteFolder(DirectoryInfo info, bool recursive)
 {
     if (!recursive && info.GetFileSystemInfos().Length != 0)
     throw new InvalidOperationException(S._("The folder {0} cannot be deleted as it is " +
      "not empty."));
        foreach (DirectoryInfo dir in info.GetDirectories())
     DeleteFolder(dir);
        foreach (FileInfo file in info.GetFiles())
     DeleteFile(file);
        for (int i = 0; i < FileNameErasePasses; ++i)
        {
     string newPath = GenerateRandomFileName(info.Parent, info.Name.Length);
     try
     {
      info.MoveTo(newPath);
     }
     catch (IOException)
     {
      Thread.Sleep(100);
      --i;
     }
        }
        info.CreationTime = info.LastWriteTime = info.LastAccessTime = MinTimestamp;
        info.Delete(true);
 }

 private void btn_MoveDir_Click(object sender, EventArgs e)
 {
     string strPath1 = this.txt_Path1.Text;
     string strPath2 = this.txt_Path2.Text;
     DirectoryInfo dirInfo = new DirectoryInfo(strPath1);
     dirInfo.MoveTo(strPath2);
 }

        public void dirRename(DirectoryInfo incDir)
        {
            string newDir = incDir.Name,
                oldDir = incDir.FullName;

            parseAll(ref newDir);

            newDir = Path.Combine(incDir.Parent.FullName, newDir);

            if (newDir == oldDir)
                return;

            if (!Directory.Exists(newDir))
                try
                {
                    incDir.MoveTo(newDir);

                    if (flgVerbose)
                        Console.WriteLine(String.Format("{0} -->> {1}", oldDir, newDir));
                }
                catch { Console.WriteLine(String.Format("Error: unable to rename, check permissions: {0}", incDir.FullName)); }
            else
                Console.WriteLine(String.Format("Error: directory already exists: {0}",
                    Path.Combine(incDir.Parent.FullName, newDir)));
        }

        public static bool RenameUserProfile(string userProfileName, DirectoryInfo userDataDir, string newUserProfileName)
        {
            var isRenamed = false;

            if (userProfileName != null && userDataDir != null && newUserProfileName != null)
            {
                var src = new DirectoryInfo(userDataDir.FullName + "\\" + userProfileName);
                var dst = new DirectoryInfo(userDataDir.FullName + "\\" + newUserProfileName);

                try
                {
                    if (src.Parent != null)
                    {
                        if (src.Exists && !dst.Exists)
                        {
                            src.MoveTo(Path.Combine(src.Parent.FullName, newUserProfileName));
                        }

                        isRenamed = true;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }

            return isRenamed;
        }

        public void MoveFolderInsideTheWatchedFolder() {
            string oldName = Path.GetRandomFileName();
            string newName = Path.GetRandomFileName();
            using (FileSystemWatcher fsWatcher = new FileSystemWatcher(this.path)) {
                fsWatcher.IncludeSubdirectories = true;
                fsWatcher.Filter = "*";
                fsWatcher.InternalBufferSize = 4 * 1024 * 16;
                fsWatcher.NotifyFilter = NotifyFilters.Size | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite | NotifyFilters.Security;
                fsWatcher.Created += (object sender, FileSystemEventArgs e) => this.list.Add(e);
                fsWatcher.Changed += (object sender, FileSystemEventArgs e) => this.list.Add(e);
                fsWatcher.Deleted += (object sender, FileSystemEventArgs e) => this.list.Add(e);
                fsWatcher.Renamed += (object sender, RenamedEventArgs e) => this.list.Add(e);
                DirectoryInfo dirA = new DirectoryInfo(Path.Combine(this.path, Path.GetRandomFileName()));
                dirA.Create();
                DirectoryInfo dirB = new DirectoryInfo(Path.Combine(this.path, Path.GetRandomFileName()));
                dirB.Create();
                DirectoryInfo movingDir = new DirectoryInfo(Path.Combine(dirA.FullName, oldName));
                movingDir.Create();
                fsWatcher.EnableRaisingEvents = true;
                movingDir.MoveTo(Path.Combine(dirB.FullName, newName));
                while (this.list.Count < 2) {
                    Thread.Sleep(100);
                }

                Assert.That(this.list.Count, Is.GreaterThanOrEqualTo(2));
                Assert.That(this.list[0].ChangeType, Is.EqualTo(WatcherChangeTypes.Deleted));
                Assert.That(this.list[0].FullPath, Is.EqualTo(Path.Combine(dirA.FullName, oldName)));
                Assert.That(this.list[1].ChangeType, Is.EqualTo(WatcherChangeTypes.Created));
                Assert.That(this.list[1].FullPath, Is.EqualTo(Path.Combine(dirB.FullName, newName)));
            }
        }

        public void CopyDirectories()
        {
            string destinationPath = Settings.Default.DestinationPath;
            string[] directories = Directory.GetDirectories(_desktopDirectory);

            foreach (string directory in directories)
            {
                string dirName = Path.GetFileName(directory);

                if (dirName != null)
                {
                    if (!IsBlacklistedDir(dirName))
                    {
                        string destinationDirectory = Path.Combine(destinationPath, dirName);

                        if (Directory.Exists(destinationDirectory))
                        {
                            int doubleCounter = Settings.Default.DoubleFileExtension;

                            string name = dirName;
                            name = name + "{" + doubleCounter + "}";

                            destinationDirectory = Path.Combine(destinationPath, name);

                            doubleCounter++;
                            Settings.Default.DoubleFileExtension = doubleCounter;
                        }

                        var info = new DirectoryInfo(directory);
                        info.MoveTo(destinationDirectory);
                    }
                }
            }
        }

 public static DirectoryInfoModifyingBegun BeginModifying(this DirectoryInfo orgInfo)
 {
     var id = Guid.NewGuid().ToString("N");
     var bakInfo = new DirectoryInfo(orgInfo.FullName);
     var bakPath = orgInfo.FullName + "." + id + ".bak";
     if (bakInfo.Exists)
         bakInfo.MoveTo(bakPath);
     return new DirectoryInfoModifyingBegun(orgInfo, bakPath);
 }

 /// <summary>
 /// Moves a folder to another destination.
 /// </summary>
 /// <param name="folderToMove">The folder to be moved.</param>
 /// <param name="destinationFolder">The destination folder to where the folder should be moved.</param>
 /// <param name="createDestinationFolder">Defines if the destination folder must be created if it doesn't exist.</param>
 /// <returns>A boolean indicating that the move was successful.</returns>
 public static bool MoveFolder(string folderToMove, string destinationFolder, bool createDestinationFolder)
 {
     if (Directory.Exists(folderToMove))
     {
         var dInfo = new DirectoryInfo(folderToMove);
         dInfo.MoveTo(PathHelper.ValidateEndOfPath(destinationFolder));
     }
     return true;
 }

    //[Repeat(3)]
    public void moveDatabaseLocations()
    {
      SessionBase.BaseDatabasePath = "d:/Databases"; // use same as VelocityDbServer.exe.config 
      DirectoryInfo info = new DirectoryInfo(Path.Combine(SessionBase.BaseDatabasePath,  systemDir));
     if (info.Exists)
        info.Delete(true);
      DirectoryInfo newInfo = new DirectoryInfo(Path.Combine(SessionBase.BaseDatabasePath,  systemDir + "MovedTo"));
      string newPath = newInfo.FullName;
      if (newInfo.Exists)
        newInfo.Delete(true);
      createDatabaseLocations(new SessionNoServer(systemDir));
      info.MoveTo(newPath);
      moveDatabaseLocations(new SessionNoServer(newPath, 2000, false, false), systemHost, newPath);
      verifyDatabaseLocations(new SessionNoServer(newPath));
      info.Delete(true);

      info = new DirectoryInfo(Path.Combine(SessionBase.BaseDatabasePath, systemDir));
      if (info.Exists)
        info.Delete(true);
      createDatabaseLocations(new ServerClientSession(systemDir));
      newPath = Path.Combine(SessionBase.BaseDatabasePath, systemDir + "MovedTo");
      info.MoveTo(newPath);
      moveDatabaseLocations(new ServerClientSession(newPath, systemHost, 2000, false, false), systemHost, newPath);
      verifyDatabaseLocations(new ServerClientSession(newPath, systemHost));
      info.Delete(true);

      info = new DirectoryInfo(Path.Combine(SessionBase.BaseDatabasePath, systemDir));
      if (info.Exists)
        info.Delete(true);
      string d = SessionBase.BaseDatabasePath;
      try
      {
        SessionBase.BaseDatabasePath = "\\\\" + systemHost2 + "\\Shared";
        newPath = Path.Combine(SessionBase.BaseDatabasePath, systemDir);
        info = new DirectoryInfo(newPath);
        createDatabaseLocations(new ServerClientSession(newPath, systemHost2));
        SessionBase.BaseDatabasePath = d;
        newPath = Path.Combine(SessionBase.BaseDatabasePath, systemDir + "MovedTo");
        string[] files = Directory.GetFiles(info.FullName);
        Directory.CreateDirectory(newPath);
        foreach (string file in files)
        {
          string name = Path.GetFileName(file);
          string dest = Path.Combine(newPath, name);
          File.Copy(file, dest);
        }
        info.Delete(true);
        info = new DirectoryInfo(newPath);
        moveDatabaseLocations(new ServerClientSession(newPath, systemHost, 2000, false, false), systemHost, newPath);
        verifyDatabaseLocations(new ServerClientSession(newPath));
        info.Delete(true);
      }
      finally
      {
        SessionBase.BaseDatabasePath = d;
      }
    }

        private void button1_Click(object sender, EventArgs e)
        {
            if (radioButton1.Checked)
                status = arr[0];
            else if (radioButton2.Checked)
                status = arr[1];
            else if (radioButton3.Checked)
                status = arr[2];
            else if (radioButton4.Checked)
                status = arr[3];
            else if (radioButton5.Checked)
                status = arr[4];
            else if (radioButton6.Checked)
                status = arr[5];

            if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
            {

                DirectoryInfo d = new DirectoryInfo(folderBrowserDialog1.SelectedPath);
                string selectedpath = d.Parent.FullName + d.Name;
                if (folderBrowserDialog1.SelectedPath.LastIndexOf(".{") == -1)
                {
                    if (checkBox1.Checked)
                        setpassword(folderBrowserDialog1.SelectedPath);
                    if (!d.Root.Equals(d.Parent.FullName))
                    d.MoveTo(d.Parent.FullName + "\\" + d.Name + status);
                    else d.MoveTo(d.Parent.FullName + d.Name + status);
                    textBox1.Text = folderBrowserDialog1.SelectedPath;
                    pictureBox1.Image = Image.FromFile(Application.StartupPath + "\\lock.jpg");
                }
                else
                {
                    status = getstatus(status);
                    bool s=checkpassword();
                    if (s)
                    {
                        File.Delete(folderBrowserDialog1.SelectedPath + "\\p.xml");
                        d.MoveTo(folderBrowserDialog1.SelectedPath.Substring(0, folderBrowserDialog1.SelectedPath.LastIndexOf(".")));
                        textBox1.Text = folderBrowserDialog1.SelectedPath.Substring(0, folderBrowserDialog1.SelectedPath.LastIndexOf("."));
                        pictureBox1.Image = Image.FromFile(Application.StartupPath + "\\unlock.jpg");
                    }
                }
            }
        }

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			string srcDirectory = context.ReadConfigAsString( testConfig, "SourceDirectory");
			string dstDirectory = context.ReadConfigAsString( testConfig, "DestinationDirectory");

			context.LogInfo("About to renme the directory \"{0}\" to \"{1}\"", srcDirectory, dstDirectory);

			var di = new DirectoryInfo(srcDirectory);
			di.MoveTo(dstDirectory);
		}

 public static void Main()
 {
     // ...
     DirectoryInfo directory = new DirectoryInfo(".\\Source");
     directory.MoveTo(".\\Root");
     DirectoryInfoExtension.CopyTo(
         directory, ".\\Target",
         SearchOption.AllDirectories, "*");
     // ...
 }

 private void button3_Click(object sender, EventArgs e)
 {
     try
     {
         DirectoryInfo DInfo = new DirectoryInfo(textBox1.Text);//创建DirectoryInfo对象
         //设置移动路径
         string strPath = textBox2.Text + textBox1.Text.Substring(textBox1.Text.LastIndexOf("\\") + 1, textBox1.Text.Length - textBox1.Text.LastIndexOf("\\") - 1);
         DInfo.MoveTo(strPath);//移动文件夹
     }
     catch { MessageBox.Show("移动的文件必须在同一盘符下！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information); }
 }

        public void MoveToDestination(string target)
        {
            if (string.IsNullOrEmpty(target)) return;
            if (!Directory.Exists(target)) return;
            if (target == FullPath) return;

            DirectoryInfo folder = new DirectoryInfo(FullPath);
            var destination = Path.Combine(target, folder.Name);
            Console.WriteLine(string.Format("move {0} to {1}", FullPath, destination));
            folder.MoveTo(destination);
        }