public void TestGetAccessControlSections() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { var security = Directory.GetAccessControl(tempLongPathFilename, AccessControlSections.Access); Assert.IsNotNull(security); Assert.AreEqual(typeof(FileSystemRights), security.AccessRightType); Assert.AreEqual(typeof(FileSystemAccessRule), security.AccessRuleType); Assert.AreEqual(typeof(FileSystemAuditRule), security.AuditRuleType); Assert.IsTrue(security.AreAccessRulesCanonical); Assert.IsTrue(security.AreAuditRulesCanonical); Assert.IsFalse(security.AreAccessRulesProtected); Assert.IsFalse(security.AreAuditRulesProtected); var securityGetAccessRules = security.GetAuditRules(true, true, typeof(System.Security.Principal.NTAccount)).Cast <FileSystemAccessRule>(); Assert.AreEqual(0, securityGetAccessRules.Count()); AuthorizationRuleCollection perm = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); var ntAccount = new System.Security.Principal.NTAccount(System.Security.Principal.WindowsIdentity.GetCurrent().Name); FileSystemAccessRule rule = perm.Cast <FileSystemAccessRule>().SingleOrDefault(e => ntAccount == e.IdentityReference); Assert.IsNotNull(rule); Assert.IsTrue((rule.FileSystemRights & FileSystemRights.FullControl) != 0); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestInUseMove() { const bool recursive = true; #if SHORT_SOURCE var tempPathFilename1 = System.IO.Path.Combine(System.IO.Directory.GetCurrentDirectory(), System.IO.Path.GetRandomFileName()); System.IO.Directory.CreateDirectory(tempPathFilename1); Assert.IsTrue(System.IO.Directory.Exists(Path.GetFullPath(tempPathFilename1))); var tempPathFilename2 = System.IO.Path.Combine(System.IO.Directory.GetCurrentDirectory(), System.IO.Path.GetRandomFileName()); System.IO.Directory.CreateDirectory(tempPathFilename2); Assert.IsTrue(System.IO.Directory.Exists(System.IO.Path.GetFullPath(tempPathFilename2))); try { using ( var writer = System.IO.File.CreateText(System.IO.Path.Combine(tempPathFilename2, "TestInUseMove"))) { string destinationPath = System.IO.Path.GetFullPath(System.IO.Path.Combine(tempPathFilename1, System.IO.Path.GetFileName(tempPathFilename2))); System.IO.Directory.Move(tempPathFilename2, destinationPath); Assert.IsTrue(System.IO.Directory.Exists(System.IO.Path.GetFullPath(tempPathFilename1))); Assert.IsFalse(System.IO.Directory.Exists(System.IO.Path.GetFullPath(tempPathFilename2))); Assert.IsTrue(System.IO.Directory.Exists(destinationPath)); } } catch (Exception e) { throw; } finally { Directory.Delete(tempPathFilename1, recursive); Directory.Delete(tempPathFilename2, recursive); } #endif var tempLongPathFilename1 = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename1); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1))); var tempLongPathFilename2 = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename2); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename2))); try { using ( var writer = File.CreateText(Path.Combine(tempLongPathFilename2, "TestInUseMove"))) { string destinationPath = Path.GetFullPath(Path.Combine(tempLongPathFilename1, Path.GetFileName(tempLongPathFilename2))); Directory.Move(tempLongPathFilename2, destinationPath); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1))); Assert.IsFalse(Directory.Exists(Path.GetFullPath(tempLongPathFilename2))); Assert.IsTrue(Directory.Exists(destinationPath)); } } finally { Directory.Delete(tempLongPathFilename1, recursive); Directory.Delete(tempLongPathFilename2, recursive); } }
public void TestDirectoryCreateNearMaxPathLimit() { var uncPathNearMaxPathLimit = Path.Combine(uncDirectory, new string('x', Pri.LongPath.NativeMethods.MAX_PATH - uncDirectory.Length - 2)); Directory.CreateDirectory(uncPathNearMaxPathLimit); Assert.That(Directory.Exists(uncPathNearMaxPathLimit)); Directory.Delete(uncPathNearMaxPathLimit); }
public void TestDeleteDirectory() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename))); Directory.Delete(tempLongPathFilename); Assert.IsFalse(Directory.Exists(Path.GetFullPath(tempLongPathFilename))); }
public static bool CheckAccessToPath(string iPath) { string UniqueDirName = iPath + "kumo@Path@Check@Dir"; try { Directory.CreateDirectory(UniqueDirName); Directory.Delete(UniqueDirName); return(true); } catch (Exception e) { return(false); } }
/// <summary> /// Deletes a junction point at the specified source directory along with the directory itself. /// Does nothing if the junction point does not exist. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The junction point path</param> public static void Delete(string junctionPoint) { if (!Directory.Exists(junctionPoint)) { if (File.Exists(junctionPoint)) { throw new IOException("Path is not a junction point."); } return; } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { var reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = 0, PathBuffer = new byte[0x3ff0] }; int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_DELETE_REPARSE_POINT, inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to delete junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } try { Directory.Delete(junctionPoint); } catch (IOException ex) { throw new IOException("Unable to delete junction point.", ex); } } }
public IResult <Result.InternalTypes.Void> DeleteDirectory(string path, bool recursive) { try { Directory.Delete(path, recursive); return(new SuccessResult()); } catch (Exception e) { return(new FailureResult(e)); } }
static void CleanupTempFolders() { if (Directory.Exists(Paths.TransferPath)) { MarkFolderWritable(Paths.TransferPath); Directory.Delete(Paths.TransferPath, true); } if (Directory.Exists(Paths.RamDriveTransferPath)) { MarkFolderWritable(Paths.RamDriveTransferPath); Directory.Delete(Paths.RamDriveTransferPath, true); } }
public void TestCreateWithFileSecurity() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); try { Directory.CreateDirectory(tempLongPathFilename, new DirectorySecurity()); Assert.IsTrue(Directory.Exists(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestReplaceIgnoreMergeWithReadonlyBackupPath() { var tempLongPathFilename = new StringBuilder(longPathDirectory).Append(@"\").Append("filename.ext").ToString(); var tempBackupPathName = new StringBuilder(longPathDirectory).Append(@"\readonly").ToString(); var di = new DirectoryInfo(tempBackupPathName); di.Create(); var attr = di.Attributes; di.Attributes = attr | FileAttributes.ReadOnly; var tempBackupLongPathFilename = new StringBuilder(tempBackupPathName).Append(@"\").Append("backup").ToString(); using (var fileStream = File.Create(tempLongPathFilename)) { fileStream.WriteByte(42); } var tempLongPathFilename2 = new StringBuilder(longPathDirectory).Append(@"\").Append("filename2.ext").ToString(); using (var fileStream = File.Create(tempLongPathFilename2)) { fileStream.WriteByte(52); } try { const bool ignoreMetadataErrors = true; File.Replace(tempLongPathFilename, tempLongPathFilename2, tempBackupLongPathFilename, ignoreMetadataErrors); using (var fileStream = File.OpenRead(tempLongPathFilename2)) { Assert.AreEqual(42, fileStream.ReadByte()); } Assert.IsFalse(File.Exists(tempLongPathFilename)); Assert.IsTrue(File.Exists(tempBackupLongPathFilename)); } finally { di.Attributes = attr; if (File.Exists(tempLongPathFilename)) { File.Delete(tempLongPathFilename); } File.Delete(tempLongPathFilename2); File.Delete(tempBackupLongPathFilename); if (Directory.Exists(tempBackupPathName)) { Directory.Delete(tempBackupPathName); } } }
public void TestCreateDirectoryThatEndsWithSlash() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName() + @"\"); var di = Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsNotNull(di); Assert.IsTrue(Directory.Exists(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestGetCreationTime() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { var dateTime = Directory.GetCreationTime(tempLongPathFilename); var fi = new DirectoryInfo(tempLongPathFilename); Assert.AreEqual(fi.CreationTime, dateTime); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestEnumerateDirectoriesWithSearch() { var randomFileName = Path.GetRandomFileName(); var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName); Directory.CreateDirectory(tempLongPathFilename); try { var dirs = Directory.EnumerateDirectories(uncDirectory, "*").ToArray(); Assert.AreEqual(1, dirs.Length); Assert.IsTrue(dirs.Contains(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestSetLastAccessTime() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { DateTime dateTime = DateTime.Now.AddDays(1); Directory.SetLastAccessTime(tempLongPathFilename, dateTime); var fi = new DirectoryInfo(tempLongPathFilename); Assert.AreEqual(fi.LastAccessTime, dateTime); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestSetCreationTimeUtc() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { DateTime dateTime = DateTime.UtcNow.AddDays(1); Directory.SetCreationTimeUtc(tempLongPathFilename, dateTime); var di = new DirectoryInfo(tempLongPathFilename); Assert.AreEqual(di.CreationTimeUtc, dateTime); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestRecursiveEnumerateDirectoriesWithSingleSubsetSearch() { var randomFileName = "TestRecursiveEnumerateDirectoriesWithSubsetSearch"; var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName); Directory.CreateDirectory(tempLongPathFilename); try { var dirs = Directory.EnumerateDirectories(uncDirectory, "T*", SearchOption.AllDirectories).ToArray(); Assert.AreEqual(1, dirs.Length); Assert.IsTrue(dirs.Contains(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestGetDirectoriesWithSearchWithNoResults() { var randomFileName = Path.GetRandomFileName(); var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName); Directory.CreateDirectory(tempLongPathFilename); try { var dirs = Directory.GetDirectories(uncDirectory, "gibberish").ToArray(); Assert.AreEqual(0, dirs.Length); Assert.IsFalse(dirs.Contains(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestGetRecursiveDirectoriesWithSubsetSearch() { var tempLongPathFilename = Path.Combine(uncDirectory, "TestGetRecursiveDirectoriesWithSubsetSearch"); Directory.CreateDirectory(tempLongPathFilename); var tempLongPathFilename2 = Path.Combine(tempLongPathFilename, "ATestGetRecursiveDirectoriesWithSubsetSearch"); Directory.CreateDirectory(tempLongPathFilename2); try { Assert.AreEqual(1, Directory.GetDirectories(uncDirectory, "A*", System.IO.SearchOption.AllDirectories).Count()); } finally { Directory.Delete(tempLongPathFilename2); Directory.Delete(tempLongPathFilename); } }
public void TestGetDirectoriesWithAnySearch() { var tempLongPathFilename = Path.Combine(uncDirectory, "TestGetDirectoriesWithAnySearch"); Directory.CreateDirectory(tempLongPathFilename); var tempLongPathFilename2 = Path.Combine(uncDirectory, "ATestGetDirectoriesWithAnySearch"); Directory.CreateDirectory(tempLongPathFilename2); try { Assert.AreEqual(2, Directory.GetDirectories(uncDirectory, "*").Count()); } finally { Directory.Delete(tempLongPathFilename); Directory.Delete(tempLongPathFilename2); } }
// clean all files and directories in iPath, then delete iPath dir... public static void DeleteDirectory(string iPath, string[] ignoreFiles = null) { if (iPath == null) { return; } if (Application.platform == RuntimePlatform.WindowsEditor) { iPath = iPath.Replace('/', '\\'); } if (!Directory.Exists(iPath)) { return; } // delete subDir string[] dirPaths = Directory.GetDirectories(iPath); for (int i = 0; i < dirPaths.Length; i++) { DeleteDirectory(dirPaths[i], ignoreFiles); } // delete files string[] filePaths = Directory.GetFiles(iPath); for (int i = 0; i < filePaths.Length; ++i) { string extension = Path.GetExtension(filePaths[i]); if (ignoreFiles != null && Array.IndexOf(ignoreFiles, extension) >= 0) { continue; } if (filePaths[i] != null) { File.Delete(filePaths[i]); } } // delete iPath dir... if (Directory.GetDirectories(iPath).Length == 0 && Directory.GetFiles(iPath).Length == 0) { Directory.Delete(iPath); } }
public void TestDirectoryEnumerateDirectoriesNearMaxPathLimit() { var uncPathNearMaxPathLimit = Path.Combine(uncDirectory, new string('x', Pri.LongPath.NativeMethods.MAX_PATH - uncDirectory.Length - 2)); Directory.CreateDirectory(uncPathNearMaxPathLimit.Replace(uncDirectory, directory)); var uncPathAboveMaxPathLimit = Path.Combine(uncPathNearMaxPathLimit, "wibble"); Directory.CreateDirectory(uncPathAboveMaxPathLimit); Assert.That(Directory.Exists(uncPathNearMaxPathLimit)); Assert.That(Directory.Exists(uncPathAboveMaxPathLimit)); // there should be one subdirectory inside almostLongPath var subDirs = Directory.EnumerateDirectories(uncPathNearMaxPathLimit).ToArray(); Directory.Delete(uncPathAboveMaxPathLimit); Directory.Delete(uncPathNearMaxPathLimit); Assert.That(subDirs.Length, Is.EqualTo(1)); }
public void TestGetFileSystemEntriesRecursiveWithSearchWithNoResults() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsTrue(Directory.Exists(tempLongPathFilename)); var randomFileName = Util.CreateNewEmptyFile(tempLongPathFilename); var files = Directory.GetFileSystemEntries(uncDirectory, "gibberish", SearchOption.AllDirectories).ToArray(); Assert.AreEqual(0, files.Length); Assert.IsFalse(files.Contains(uncFilePath)); Assert.IsFalse(files.Contains(randomFileName)); } finally { const bool recursive = true; Directory.Delete(tempLongPathFilename, recursive); } }
public void TestEnumerateRecursiveFileSystemEntriesWithSearch() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsTrue(Directory.Exists(tempLongPathFilename)); var randomFileName = Util.CreateNewEmptyFile(tempLongPathFilename); var entries = Directory.EnumerateFileSystemEntries(uncDirectory, "*", SearchOption.AllDirectories).ToArray(); Assert.AreEqual(3, entries.Length); Assert.IsTrue(entries.Contains(uncFilePath)); Assert.IsTrue(entries.Contains(randomFileName)); } finally { const bool recursive = true; Directory.Delete(tempLongPathFilename, recursive); } }
public void TearDown() { try { if (File.Exists(filePath)) { File.Delete(filePath); } } catch (Exception e) { Trace.WriteLine("Exception {0} deleting \"filePath\"", e.ToString()); throw; } finally { if (Directory.Exists(directory)) { Directory.Delete(directory, true); } } }
public void TearDown() { try { if (File.Exists(longPathFilename)) { File.Delete(longPathFilename); } } catch (Exception e) { Trace.WriteLine("Exception {0} deleting \"longPathFilename\"", e.ToString()); throw; } finally { if (Directory.Exists(longPathRoot)) { Directory.Delete(longPathRoot, true); } } }
public void TestMove() { var tempLongPathFilename1 = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename1); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1))); var tempLongPathFilename2 = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename2); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename2))); string destinationPath = Path.GetFullPath(Path.Combine(tempLongPathFilename1, Path.GetFileName(tempLongPathFilename2))); Directory.Move(tempLongPathFilename2, destinationPath); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1))); Assert.IsFalse(Directory.Exists(Path.GetFullPath(tempLongPathFilename2))); Assert.IsTrue(Directory.Exists(destinationPath)); const bool recursive = true; Directory.Delete(tempLongPathFilename1, recursive); Directory.Delete(tempLongPathFilename2, recursive); }
public void TestGetRecursiveFilesWithSubsetSearch() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsTrue(Directory.Exists(tempLongPathFilename)); var randomFileName = Util.CreateNewEmptyFile(tempLongPathFilename); var searchPattern = Path.GetFileName(randomFileName).Substring(0, 3) + "*" + Path.GetExtension(randomFileName); var files = Directory.GetFiles(uncDirectory, searchPattern, SearchOption.AllDirectories).ToArray(); Assert.AreEqual(1, files.Length); Assert.IsFalse(files.Contains(uncFilePath)); Assert.IsTrue(files.Contains(randomFileName)); } finally { const bool recursive = true; Directory.Delete(tempLongPathFilename, recursive); } }
static void ProcessArchive(string rootPath, string folder, string file, IEnumerable <string> files, string destFolder) { if (Regex.IsMatch(file, @"(?i)\.(rar|r00|zip)$")) { var zipSize = GetAssociatedArchives(file, files).Sum(archiveFile => new FileInfo(archiveFile).Length); var tempPath = GetTempPath(zipSize * 2); var zipContentsPath = tempPath + folder.Substring(rootPath.Length) + Path.GetFileName(file); Console.WriteLine("Extracting {0} => {1}", Path.GetFileName(file), zipContentsPath); if (StartProcess(@"C:\Program Files\WinRAR\WinRar.exe", $"x -o+ -ibck -inul -y \"{file}\" \"{zipContentsPath}\"\\") < 2 && Directory.Exists(zipContentsPath)) { MarkFolderWritable(zipContentsPath); ProcessFolder(tempPath, zipContentsPath, destFolder, true, false); } else { Console.WriteLine("Error while extracting {0}", file); throw new UnzipError(); } Directory.Delete(zipContentsPath, true); } /* * else if (Path.GetExtension(file) == ".iso") * { * Console.WriteLine("Mounting {0} => G:", file); * StartProcess(@"C:\Program Files\PowerISO\piso.exe", string.Format("mount \"{0}\" G:", file)); * var isoSize = new FileInfo(file).Length; * var tempPath = GetTempPath(isoSize); * var isoContentsPath = tempPath + folder.Substring(rootPath.Length); * CopyFiles("G:", isoContentsPath, false); * MarkFolderWritable(isoContentsPath); * ProcessFolder(tempPath, isoContentsPath, destFolder, true, true, string.Format(@"\{0}", Path.GetFileName(file))); * Unmount(); * Directory.Delete(isoContentsPath, true); * } * */ }
public void Delete(string path, bool recursive) { Directory.Delete(path, recursive); }
public void DecryptCourse(List <ListViewItem> list) { if (string.IsNullOrWhiteSpace(txtCoursePath.Text)) { MessageBox.Show("Please select course path", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } else if (string.IsNullOrWhiteSpace(txtDBPath.Text)) { MessageBox.Show("Please select database path", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } else if (string.IsNullOrWhiteSpace(txtOutputPath.Text)) { MessageBox.Show("Please select output path", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } foreach (ListViewItem item in list) { CourseItem courseItem = listCourse.Where(r => r.Course.Name == item.Name).Select(r => r).FirstOrDefault(); if (chkDecrypt.Checked) { bgwDecrypt.ReportProgress(1, new Log { Text = $"Start to decrypt course \"{courseItem.Course.Title}\"", TextColor = Color.Magenta, NewLine = true, IsError = true }); //Create new course path with the output path var newCoursePath = Path.Combine(txtOutputPath.Text, this.CleanName(courseItem.Course.Title)); DirectoryInfo courseInfo = Directory.Exists(newCoursePath) ? new DirectoryInfo(newCoursePath) : Directory.CreateDirectory(newCoursePath); if (chkCopyImage.Checked && File.Exists($"{courseItem.CoursePath}\\image.jpg")) { File.Copy($"{courseItem.CoursePath}\\image.jpg", $"{newCoursePath}\\image.jpg", true); } //Get list all modules in current course List <Module> listModules = courseItem.Course.Modules; if (listModules.Count > 0) { // integer to add 1 if index should start at 1 int startAt1 = Convert.ToInt16(chkStartModuleIndexAt1.Checked); //Get each module foreach (Module module in listModules) { //Generate module hash name string moduleHash = this.ModuleHash(module.Name, module.AuthorHandle); //Generate module path string moduleHashPath = Path.Combine(courseItem.CoursePath, moduleHash); //Create new module path with decryption name string newModulePath = Path.Combine(courseInfo.FullName, $"{(startAt1 + module.Index):00}. {module.Title}"); if (Directory.Exists(moduleHashPath)) { DirectoryInfo moduleInfo = Directory.Exists(newModulePath) ? new DirectoryInfo(newModulePath) : Directory.CreateDirectory(newModulePath); //Decrypt all videos in current module folder this.DecryptAllVideos(moduleHashPath, module, moduleInfo.FullName); } else { bgwDecrypt.ReportProgress(1, new Log { Text = $"Folder {moduleHash} not found in the current course path", TextColor = Color.Red, NewLine = true, IsError = true }); } } } bgwDecrypt.ReportProgress(1, new Log { Text = $"Decrypt \"{courseItem.Course.Title}\" complete!", TextColor = Color.Magenta, NewLine = true, IsError = true }); } if (chkDelete.Checked) { try { Directory.Delete(courseItem.CoursePath, true); } catch (Exception ex) { bgwDecrypt.ReportProgress(1, new Log { Text = $"Delete folder course {courseItem.Course.Title} fail\n{ex.Message}", TextColor = Color.Gray, NewLine = true, IsError = true }); } try { RemoveCourseInDb(courseItem.CoursePath); } catch (Exception ex) { bgwDecrypt.ReportProgress(1, new Log { Text = $"Delete course {courseItem.Course.Title} from db fail\n{ex.Message}", TextColor = Color.Gray, NewLine = true, IsError = true }); } bgwDecrypt.ReportProgress(1, new Log { Text = $"Delete course {courseItem.Course.Title} success!", TextColor = Color.Magenta, NewLine = true }); } } bgwDecrypt.ReportProgress(100); }