public static void SendToTrash(string path)
{
SHFILEOPSTRUCT fileop = new SHFILEOPSTRUCT();
fileop.wFunc = FO_DELETE;
fileop.pFrom = path + '\0' + '\0';
fileop.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
SHFileOperation(ref fileop);
}
public static bool CopyFiles(String from, String to)
{
SHFILEOPSTRUCT op = new SHFILEOPSTRUCT();
op.wFunc = FO_Func.FO_COPY;
op.fFlags = (ushort)FO_Func.FOF_ALLOWUNDO;
op.pFrom = from;
op.pTo = to;
return (SHFileOperation(ref op) == 0 && !op.fAnyOperationsAborted);
}
public static int deleteFileOrFolder2Bin(string ff)
{
if (ff.EndsWith("\\")) ff = ff.Remove(ff.Length - 1, 1);
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
shf.pFrom = ff + '\0' + '\0';
return SHFileOperation(ref shf);
}
/// <summary>
/// Verschiebt eine Datei in den Papierkorb
/// </summary>
/// <param name="filePath"></param>
private static void DateiInPapierkorb(string filePath)
{
var fileop = new SHFILEOPSTRUCT
{
wFunc = FO_DELETE,
pFrom = (filePath + '\0' + '\0'),
fFlags = (FOF_ALLOWUNDO | FOF_NOCONFIRMATION)
};
SHFileOperation(ref fileop);
}
private static void DeleteFileOperation(string filePath)
{
var fileop = new SHFILEOPSTRUCT
{
wFunc = FoDelete,
pFrom = filePath + '\0' + '\0',
fFlags = FofAllowundo | FofNoconfirmation
};
SHFileOperation(ref fileop);
}
public static void DeleteFileToRecycleBin(string filename)
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
shf.pFrom = filename + "\0";
int result = SHFileOperation(ref shf);
if (result != 0)
Utilities.DebugLine("error: {0} while moving file {1} to recycle bin", result, filename);
}
public static bool CallSH(FileOperationType type, string[] from, string to, FileOperationFlags flags)
{
var fs = new SHFILEOPSTRUCT();
fs.wFunc = type;
if (from.Length > 0)
fs.pFrom = string.Join("\0", from) + "\0\0";
if (to.Length > 0)
fs.pTo = to + "\0\0";
fs.fFlags = flags;
return SHFileOperation(ref fs) == 0;
}
private static bool DeleteFile(string[] path, FileOperationFlags flags) {
if (path == null || path.All(x => x == null)) return false;
try {
var fs = new SHFILEOPSTRUCT {
wFunc = FileOperationType.FO_DELETE,
pFrom = string.Join("\0", path.Where(x => x != null)) + "\0\0",
fFlags = flags
};
SHFileOperation(ref fs);
return true;
} catch (Exception) {
return false;
}
}
/// <summary>
/// Recursively deletes a directory using the shell API which can
/// handle long file names
/// </summary>
/// <param name="dir"></param>
public static void RecursivelyDeleteDirectory(string dir, bool silent = false) {
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT();
fileOp.pFrom = dir + '\0'; // pFrom must be double null terminated
fileOp.wFunc = FO_Func.FO_DELETE;
fileOp.fFlags = FILEOP_FLAGS_ENUM.FOF_NOCONFIRMATION |
FILEOP_FLAGS_ENUM.FOF_NOERRORUI;
if (silent) {
fileOp.fFlags |= FILEOP_FLAGS_ENUM.FOF_SILENT;
}
int res = SHFileOperation(ref fileOp);
if (res != 0) {
throw new IOException("Failed to delete dir " + res);
}
}
public static void DeleteToRecycleBin(string fileName)
{
if (!File.Exists(fileName) && !Directory.Exists(fileName))
throw new FileNotFoundException("File not found.", fileName);
SHFILEOPSTRUCT info = new SHFILEOPSTRUCT();
info.hwnd = Gui.WorkbenchSingleton.MainWin32Window.Handle;
info.wFunc = FO_FUNC.FO_DELETE;
info.fFlags = FILEOP_FLAGS.FOF_ALLOWUNDO | FILEOP_FLAGS.FOF_NOCONFIRMATION;
info.lpszProgressTitle = "Delete " + Path.GetFileName(fileName);
info.pFrom = fileName + "\0"; // pFrom is double-null-terminated
int result = SHFileOperation(ref info);
if (result != 0)
throw new IOException("Could not delete file " + fileName + ". Error " + result, result);
}
/// <summary>
/// Delete a file or directory by moving it to the trash bin
/// </summary>
/// <param name="filePath">Full path of the file.</param>
/// <returns><c>true</c> if successfully deleted.</returns>
public static bool DeleteToRecycleBin(string filePath)
{
if (PlatformUtilities.Platform.IsWindows)
{
if (!File.Exists(filePath) && !Directory.Exists(filePath))
return false;
// alternative using visual basic dll:
// FileSystem.DeleteDirectory(item.FolderPath,UIOption.OnlyErrorDialogs), RecycleOption.SendToRecycleBin);
//moves it to the recyle bin
var shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
string pathWith2Nulls = filePath + "\0\0";
shf.pFrom = pathWith2Nulls;
SHFileOperation(ref shf);
return !shf.fAnyOperationsAborted;
}
// On Linux we'll have to move the file to $XDG_DATA_HOME/Trash/files and create
// a filename.trashinfo file in $XDG_DATA_HOME/Trash/info that contains the original
// filepath and the deletion date. See http://stackoverflow.com/a/20255190
// and http://freedesktop.org/wiki/Specifications/trash-spec/.
// Environment.SpecialFolder.LocalApplicationData corresponds to $XDG_DATA_HOME.
// move file or directory
if (Directory.Exists(filePath) || File.Exists(filePath))
{
var trashPath = Path.Combine(Environment.GetFolderPath(
Environment.SpecialFolder.LocalApplicationData), "Trash");
var trashedFileName = Path.GetRandomFileName();
if (!Directory.Exists(trashPath))
{
// in case the trash bin doesn't exist we create it. This can happen e.g.
// on the build machine
Directory.CreateDirectory(Path.Combine(trashPath, "files"));
Directory.CreateDirectory(Path.Combine(trashPath, "info"));
}
var recyclePath = Path.Combine(Path.Combine(trashPath, "files"), trashedFileName);
WriteTrashInfoFile(trashPath, filePath, trashedFileName);
// Directory.Move works for directories and files
DirectoryUtilities.MoveDirectorySafely(filePath, recyclePath);
return true;
}
return false;
}
public static void DeleteFileOrFolder(string path)
{
try
{
SHFILEOPSTRUCT fileop = new SHFILEOPSTRUCT();
fileop.wFunc = FO_DELETE;
fileop.pFrom = path + '\0' + '\0';
fileop.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
SHFileOperation(ref fileop);
}
catch(Exception ex)
{
throw new ID3SQLException("Recycle option not available on this system", ex);
}
}
public static void DeleteToRecycleBin(string fileName, bool showConfirmation)
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.hwnd = IntPtr.Zero;
shf.wFunc = FO_Func.FO_DELETE;
if (showConfirmation)
{
shf.fFlags = FOF_ALLOWUNDO;
}
else
{
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
}
shf.pFrom = fileName + '\0';
SHFileOperation(ref shf);
}
private static bool DeleteFile(string path, FileOperationFlags flags)
{
try
{
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = flags
};
SHFileOperation(ref fileOp);
return true;
}
catch (Exception)
{
return false;
}
}
private static bool Send(string path, FileOperationFlags flags)
{
try
{
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = (FileOperationFlags)((ushort)(FileOperationFlags.FOF_ALLOWUNDO | flags))
};
SHFileOperation(ref fileOp);
return(true);
}
catch (Exception)
{
return(false);
}
}
public static void DeleteToRecycleBin(string fileName, bool showConfirmation)
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.hwnd = IntPtr.Zero;
shf.wFunc = FO_Func.FO_DELETE;
if (showConfirmation)
{
shf.fFlags = FOF_ALLOWUNDO;
}
else
{
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
}
shf.pFrom = fileName + '\0';
SHFileOperation(ref shf);
}
/// <summary>
/// Send file to recycle bin
/// </summary>
/// <param name="path">Location of directory or file to recycle</param>
/// <param name="flags">FileOperationFlags to add in addition to FOF_ALLOWUNDO</param>
public static bool Send(string path, FileOperationFlags flags)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = FileOperationFlags.FOF_ALLOWUNDO | flags
};
SHFileOperation(ref fs);
return(true);
}
catch (Exception)
{
return(false);
}
}
public static bool CopyItems(List<string> items, string destination)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_COPY,
pFrom = string.Join("\0", items.ToArray()) + '\0' + '\0',
pTo = destination + '\0' + '\0'
};
SHFileOperation(ref fs);
return true;
}
catch (Exception)
{
return false;
}
}
public static bool Perform(string path, FileOperationFlags flags)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = FileOperationFlags.FOF_ALLOWUNDO | flags
};
SHFileOperation(ref fs);
return true;
}
catch (Exception)
{
return false;
}
}
public static bool MoveItems(List <string> items, string destination)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_MOVE,
pFrom = string.Join("\0", items.ToArray()) + '\0' + '\0',
pTo = destination + '\0' + '\0'
};
SHFileOperation(ref fs);
return(true);
}
catch (Exception)
{
return(false);
}
}
private static bool deleteFile(string path, FileOperationFlags flags)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = flags
};
SHFileOperation(ref fs);
return(true);
}
catch (Exception)
{
return(false);
}
}
// Main overload for standard Move\Copy file(s) operation
private static bool DoFileOperation(FileOperationType foType, string[] files, string destination)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = foType,
pFrom = string.Join("\0", files) + '\0' + '\0',
pTo = destination + '\0' + '\0'
};
SHFileOperation(ref fs);
return(true);
}
catch (Exception)
{
return(false);
}
}
public static bool MoveItems(List <string> items, string destination)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_MOVE,
pFrom = string.Join("\0", items.ToArray()) + '\0' + '\0',
pTo = destination + '\0' + '\0'
};
// tbener 3/2018 - changed to return False if cancelled by user
return(SHFileOperation(ref fs) == 0);
}
catch (Exception)
{
// tbener 3/2018 - change from return false (as opposed to cancel)
throw;
}
}
public static void DeleteToRecycleBin(string fileName)
{
if (!File.Exists(fileName) && !Directory.Exists(fileName))
{
throw new FileNotFoundException("File not found.", fileName);
}
SHFILEOPSTRUCT info = new SHFILEOPSTRUCT();
info.wFunc = FO_FUNC.FO_DELETE;
info.fFlags = FILEOP_FLAGS.FOF_ALLOWUNDO | FILEOP_FLAGS.FOF_NOCONFIRMATION;
info.lpszProgressTitle = "Delete " + Path.GetFileName(fileName);
info.pFrom = fileName + "\0"; // pFrom is double-null-terminated
int result = SHFileOperation(ref info);
if (result != 0)
{
throw new IOException("Could not delete file " + fileName + ". Error " + result, result);
}
}
/// <summary>
/// Send file to recycle bin.
/// Returns true on success.
/// </summary>
/// <param name="path">Location of directory or file to recycle</param>
/// <param name="flags">FileOperationFlags to add in addition to FOF_ALLOWUNDO</param>
public static bool Send(string path, FileOperationFlags flags)
{
// TODO find out what this does if recycle bin is disabled
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = FileOperationFlags.FOF_ALLOWUNDO | flags
};
int error = SHFileOperation(ref fs);
return(error == 0);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Send file to recycle bin
/// </summary>
/// <param name="path">Location of directory or file to recycle</param>
/// <param name="flags">FileOperationFlags to add in addition to FOF_ALLOWUNDO</param>
public static bool Send(string path, FileOperationFlags flags)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = FileOperationFlags.FOF_ALLOWUNDO | flags
};
SHFileOperation(ref fs);
return(true);
}
catch (Exception e)
{
Debug.WriteLine("Deletion error: " + path + " " + e.Message);
return(false);
}
}
private static bool DeleteFile(string[] path, FileOperationFlags flags)
{
path = path?.Where(Exists).ToArray();
if (path == null || path.Length == 0 || path.All(x => x == null))
{
return(false);
}
try {
var fs = new SHFILEOPSTRUCT {
wFunc = FileOperationType.FO_DELETE,
pFrom = string.Join("\0", path.Where(x => x != null)) + "\0\0",
fFlags = flags
};
SHFileOperation(ref fs);
return(true);
} catch (Exception) {
return(false);
}
}
static bool DeleteFileOrFolder(string path, bool confirm = false)
{
SHFILEOPSTRUCT fileop = new SHFILEOPSTRUCT();
fileop.wFunc = FO_DELETE;
fileop.pFrom = path + '\0' + '\0';
if (confirm)
{
fileop.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
}
else
{
fileop.fFlags = FOF_ALLOWUNDO;
}
var rc = SHFileOperation(ref fileop);
return(rc == 0);
}
/// <summary>
/// Recursively deletes a directory using the shell API which can
/// handle long file names
/// </summary>
/// <param name="dir"></param>
public static void RecursivelyDeleteDirectory(string dir, bool silent = false)
{
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT();
fileOp.pFrom = dir + '\0'; // pFrom must be double null terminated
fileOp.wFunc = FO_Func.FO_DELETE;
fileOp.fFlags = FILEOP_FLAGS_ENUM.FOF_NOCONFIRMATION |
FILEOP_FLAGS_ENUM.FOF_NOERRORUI;
if (silent)
{
fileOp.fFlags |= FILEOP_FLAGS_ENUM.FOF_SILENT;
}
int res = SHFileOperation(ref fileOp);
if (res != 0)
{
throw new System.IO.IOException("Failed to delete dir " + res);
}
}
/// <summary>
/// Uses the Window Shell UI to move files which behaves similar to Explorer behavior
/// warning for errors and supports undo.
/// </summary>
/// <param name="sourceFolder">Source file (or files via wildcard) or folder name</param>
/// <param name="targetFolder">Target Folder</param>
/// <param name="confirmation">If true prompts for overwrites</param>
/// <returns>true or false</returns>
public static bool MoveFileOrFolder(string sourceFolder, string targetFolder, bool confirmation = false)
{
var shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_MOVE;
if (confirmation)
{
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
}
else
{
shf.fFlags = FOF_ALLOWUNDO;
}
shf.pFrom = sourceFolder + '\0'; // required!
shf.pTo = targetFolder + '\0';
int result = SHFileOperation(ref shf);
return(result == 0);
}
/// <summary>
/// Send file to recycle bin
/// </summary>
/// <param name="path">Location of directory or file to recycle</param>
/// <param name="flags">FileOperationFlags to add in addition to FOF_ALLOWUNDO</param>
public static bool Send(string path, FileOperationFlags flags)
{
try
{
var fs = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = FileOperationFlags.FOF_ALLOWUNDO | flags
};
SHFileOperation(ref fs);
return(true);
}
catch (Exception e)
{
MessageBox.Show(e.Message + Environment.NewLine + Environment.NewLine + e.StackTrace, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
return(false);
}
/// <summary>
/// Wrapper for extern method CreateSymbolicLink. This handles some error cases and provides better information
/// in error cases.
/// </summary>
/// <param name="symlinkPath">Path to the symbolic link you wish to create.</param>
/// <param name="targetPath">Path to the file/directory that the symbolic link should be pointing to.</param>
public static void CreateSymbolicLink(string symlinkPath, string targetPath)
{
// Pre-checks.
if (!(new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator)))
{
throw new UnauthorizedAccessException("Process must be run in elevated permissions in order to create symbolic link.");
}
else if (Directory.Exists(symlinkPath) || File.Exists(symlinkPath))
{
throw new IOException("Path Already Exists. We cannot create a symbolic link here");
}
// Create the correct symbolic link.
bool result;
if (SHFILEOPSTRUCT.Exists(targetPath))
{
result = CreateSymbolicLink(symlinkPath, targetPath, NativeMethods.SymbolicLink.File);
}
else if (Directory.Exists(targetPath))
{
result = CreateSymbolicLink(symlinkPath, targetPath, NativeMethods.SymbolicLink.Directory);
}
else
{
throw new FileNotFoundException("Target File/Directory was not found. Cannot make a symbolic link.");
}
// Validate that we created a symbolic link.
// If we failed and the symlink doesn't exist throw an exception here.
if (!result)
{
if (!Directory.Exists(symlinkPath) && !File.Exists(symlinkPath))
{
throw new FileNotFoundException("Unable to find symbolic link after creation.");
}
else
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
}
}
public bool DeleteDirectory(string strDir)
{
if (!Directory.Exists(strDir))
{
return(false);
}
Stopwatch sw = new Stopwatch();
string[] rgstrFiles = Directory.GetFiles(strDir);
sw.Start();
for (int i = 0; i < rgstrFiles.Length; i++)
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO + FOF_NOCONFIRMATION;
shf.pFrom = strDir + '\0' + '\0';
SHFileOperation(ref shf);
if (m_evtCancel.WaitOne(0))
{
return(false);
}
if (sw.Elapsed.TotalMilliseconds > 1000)
{
m_log.Progress = (double)i / (double)rgstrFiles.Length;
m_log.WriteLine("deleting " + i.ToString("N0") + " of " + rgstrFiles.Length.ToString("N0") + "...");
sw.Restart();
}
}
rgstrFiles = Directory.GetFiles(strDir);
if (rgstrFiles.Length == 0)
{
Directory.Delete(strDir);
}
return(true);
}
/// <summary>
/// 删除单个或多个文件
/// </summary>
/// <param name="fileName">删除的文件名，如果是多个文件，文件名之间以字符串结尾符'\0'隔开</param>
/// <param name="toRecycle">指示是将文件放入回收站还是永久删除，true-放入回收站，false-永久删除</param>
/// <param name="showDialog">指示是否显示确认对话框，true-显示确认删除对话框，false-不显示确认删除对话框</param>
/// <param name="showProgress">指示是否显示进度对话框，true-显示，false-不显示。该参数当指定永久删除文件时有效</param>
/// <param name="errorMsg">反馈错误消息的字符串</param>
/// <returns>操作执行结果标识，删除文件成功返回0，否则，返回错误代码</returns>
private static int ToDelete(string fileName, bool toRecycle, bool showDialog, bool showProgress, ref string errorMsg)
{
SHFILEOPSTRUCT lpFileOp = new SHFILEOPSTRUCT();
lpFileOp.wFunc = wFunc.FO_DELETE;
lpFileOp.pFrom = fileName + "\0"; //将文件名以结尾字符"\0"结束
lpFileOp.fFlags = FILEOP_FLAGS.FOF_NOERRORUI;
if (toRecycle)
{
lpFileOp.fFlags |= FILEOP_FLAGS.FOF_ALLOWUNDO; //设定删除到回收站
}
if (!showDialog)
{
lpFileOp.fFlags |= FILEOP_FLAGS.FOF_NOCONFIRMATION; //设定不显示提示对话框
}
if (!showProgress)
{
lpFileOp.fFlags |= FILEOP_FLAGS.FOF_SILENT; //设定不显示进度对话框
}
lpFileOp.fAnyOperationsAborted = true;
int n = SHFileOperation(ref lpFileOp);
if (n == 0)
{
return(0);
}
string tmp = GetErrorString(n);
//.av 文件正常删除了但也提示 402 错误，不知道为什么。屏蔽之。
if ((fileName.ToLower().EndsWith(".av") && n.ToString("X") == "402"))
{
return(0);
}
errorMsg = string.Format("{0}({1})", tmp, fileName);
return(n);
}
public static void Compress(string folderPath, string fileName)
{
try
{
string extension = ".zip";
string file = folderPath + @"\" + fileName;
fileName = (fileName + extension).Replace(".bak", "");
Thread thread = new Thread(t =>
{
using (ZipFile zip = new ZipFile())
{
zip.Password = "******";
zip.CompressionLevel = CompressionLevel.BestCompression;
FileInfo fileInfo = new FileInfo(fileName);
zip.AddFile(file, "");
DirectoryInfo di = new DirectoryInfo(file);
folderPath = string.Format(@"{0}\{1}", di.Parent.FullName, fileInfo.Name);
zip.Save(folderPath);
File.Delete(file);
var shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
shf.pFrom = file;
SHFileOperation(ref shf);
Console.WriteLine("Compress completed.");
}
});
thread.Start();
}
catch (Exception ex)
{
Console.WriteLine("Compress completed.");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Actually do the move of a file/directory to the recycleBin
/// </summary>
/// <param name="path"></param>
/// <returns>true if it succeed.</returns>
public static bool Recycle(string path)
{
try
{
#if MONO
// TODO: Find a way in Mono to send something to the recycle bin.
try
{
File.Delete(path);
}
catch
{
try
{
Directory.Delete(path);
}
catch
{
}
}
return(true);
#else
//alternative using visual basic dll: FileSystem.DeleteDirectory(item.FolderPath,UIOption.OnlyErrorDialogs), RecycleOption.SendToRecycleBin);
//moves it to the recyle bin
var shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
string pathWith2Nulls = path + "\0\0";
shf.pFrom = pathWith2Nulls;
SHFileOperation(ref shf);
return(!shf.fAnyOperationsAborted);
#endif
}
catch (Exception exception)
{
Palaso.Reporting.ErrorReport.NotifyUserOfProblem(exception, "Could not delete that book.");
return(false);
}
}
public static void DeleteFile(string filepath)
{
if (!File.Exists(filepath))
{
return;
}
ThreadStart ts = new ThreadStart(() =>
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
shf.pFrom = filepath;
SHFileOperation(ref shf);
});
Thread t = new Thread(ts);
t.Start();
}
public static void DeleteToRecycleBin(string fileName)
{
if (!File.Exists(fileName) && !Directory.Exists(fileName))
{
throw new FileNotFoundException("File not found.", fileName);
}
var info = new SHFILEOPSTRUCT
{
hwnd = Altaxo.Current.Gui.MainWindowHandle,
wFunc = FO_FUNC.FO_DELETE,
fFlags = FILEOP_FLAGS.FOF_ALLOWUNDO | FILEOP_FLAGS.FOF_NOCONFIRMATION,
lpszProgressTitle = "Delete " + Path.GetFileName(fileName),
pFrom = fileName + "\0" // pFrom is double-null-terminated
};
int result = SHFileOperation(ref info);
if (result != 0)
{
throw new IOException("Could not delete file " + fileName + ". Error " + result, result);
}
}
// Effective Function
public static int SHFileOperation(SHFILEOPSTRUCT lpFileOp)
{
if (!Is64Bit())
{
return(SHFileOperation32(lpFileOp));
}
var shfileopstruct1 = new SHFILEOPSTRUCT64();
shfileopstruct1.hwnd = lpFileOp.hwnd;
shfileopstruct1.wFunc = lpFileOp.wFunc;
shfileopstruct1.pFrom = lpFileOp.pFrom;
shfileopstruct1.pTo = lpFileOp.pTo;
shfileopstruct1.fFlags = lpFileOp.fFlags;
shfileopstruct1.fAnyOperationsAborted = lpFileOp.fAnyOperationsAborted;
shfileopstruct1.hNameMappings = lpFileOp.hNameMappings;
shfileopstruct1.lpszProgressTitle = lpFileOp.lpszProgressTitle;
var ret = SHFileOperation64(shfileopstruct1);
lpFileOp.fAnyOperationsAborted = shfileopstruct1.fAnyOperationsAborted;
return(ret);
}
static int SHFileOperation(ref SHFILEOPSTRUCT lpFileOp)
{
if (IntPtr.Size == 4)
{
return(SHFileOperation32(ref lpFileOp));
}
SHFILEOPSTRUCT64 shfileopstruct = new SHFILEOPSTRUCT64();
shfileopstruct.hwnd = lpFileOp.hwnd;
shfileopstruct.wFunc = lpFileOp.wFunc;
shfileopstruct.pFrom = lpFileOp.pFrom;
shfileopstruct.pTo = lpFileOp.pTo;
shfileopstruct.fFlags = lpFileOp.fFlags;
shfileopstruct.fAnyOperationsAborted = lpFileOp.fAnyOperationsAborted;
shfileopstruct.hNameMappings = lpFileOp.hNameMappings;
shfileopstruct.lpszProgressTitle = lpFileOp.lpszProgressTitle;
int num2 = SHFileOperation64(ref shfileopstruct);
lpFileOp.fAnyOperationsAborted = shfileopstruct.fAnyOperationsAborted;
return(num2);
}
public void Execute()
{
WindowInteropHelper wih = new WindowInteropHelper(ParentWindow);
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT();
if (this.Flags.HasFlag(FILEOP_FLAGS.FOF_WANTMAPPINGHANDLE))
{
throw new NotImplementedException();
}
fileOp.hwnd = wih.Handle;
fileOp.wFunc = Convert.ToInt32(this.Operation);
fileOp.pFrom = ArrayToMultiString(this.From);
fileOp.pTo = ArrayToMultiString(this.To);
fileOp.fAnyOperationAborted = 0;
fileOp.fFlags = Convert.ToInt16(this.Flags);
fileOp.hNameMapping = IntPtr.Zero;
fileOp.lpszProgressTitle = this.ProgressTitle;
int res = SHFileOperation(ref fileOp);
}
private const uint ERROR_INVALID_LEVEL = 124; //folder not exist
public static void MoveFileToRecycleBin(string path)
{
const uint delete = 3;
const ushort silentNoConfirmationUndo = 84;
var fileOp = new SHFILEOPSTRUCT
{
FileFunc = delete,
NamesFrom = path + "\0", //The NamesFrom and NameTo strings must end with two '\ 0'. One will add p/invoke. The result will be two.
Flags = silentNoConfirmationUndo
};
int hResult = SHFileOperation(ref fileOp);
if (hResult != 0)
{
if (hResult != ERROR_FILE_NOT_FOUND &&
hResult != ERROR_INVALID_LEVEL)
{
throw new Win32Exception(hResult);
}
}
}
/// <summary>
/// 移动文件（如果文件比较多的话，会出现Window Shell的文件拷贝进度条）
/// </summary>
/// <param name="srcList"></param>
/// <param name="dstList"></param>
/// <returns></returns>
public static bool SHMoveFiles(string[] srcList, string[] dstList)
{
string src, dst;
if (!ListToSHStr(srcList, dstList, out src, out dst))
{
return(false);
}
Logger.D(string.Format("moveFile: {0} => {1}", src, dst));
SHFILEOPSTRUCT fileop = new SHFILEOPSTRUCT();
fileop.hwnd = IntPtr.Zero;
fileop.hNameMappings = IntPtr.Zero;
fileop.wFunc = FileFuncFlags.FO_MOVE;
fileop.pFrom = src + '\0' + '\0';
fileop.pTo = dst + '\0' + '\0';
fileop.lpszProgressTitle = "文件移动" + '\0' + '\0';
fileop.fFlags = FILEOP_FLAGS.FOF_SIMPLEPROGRESS | FILEOP_FLAGS.FOF_MULTIDESTFILES;
return(SHFileOperation(ref fileop) == 0);
}
private static bool CopyFilesInternal(List <string> fromList, List <string> toList, FILE_OP_TYPE opType)
{
bool success = false;
string from = FilenamesToShellString(fromList);
string to = FilenamesToShellString(toList);
SHFILEOPSTRUCT lpFileOp = new SHFILEOPSTRUCT()
{
wFunc = opType,
pFrom = from,
pTo = to,
fFlags = FILE_OP_FLAGS.FOF_NOCONFIRMMKDIR | FILE_OP_FLAGS.FOF_MULTIDESTFILES
};
if (SHFileOperation(ref lpFileOp) == 0)
{
success = !lpFileOp.fAnyOperationsAborted;
}
return(success);
}
public static bool RenameFiles(List <string> fromList, List <string> toList)
{
bool success = false;
string from = FilenamesToShellString(fromList);
string to = FilenamesToShellString(toList);
SHFILEOPSTRUCT lpFileOp = new SHFILEOPSTRUCT()
{
wFunc = FILE_OP_TYPE.FO_RENAME,
pFrom = from,
pTo = to,
fFlags = 0
};
if (SHFileOperation(ref lpFileOp) == 0)
{
success = !lpFileOp.fAnyOperationsAborted;
}
return(success);
}
public static bool RenameDirectory(string p_strSource, string p_strDest)
{
SHFILEOPSTRUCT struc = new SHFILEOPSTRUCT();
struc.hNameMappings = IntPtr.Zero;
struc.hwnd = IntPtr.Zero;
struc.lpszProgressTitle = "Rename Release directory";
struc.pFrom = Marshal.StringToHGlobalUni(p_strSource);
struc.pTo = Marshal.StringToHGlobalUni(p_strDest);
struc.wFunc = (uint)Operation.FO_RENAME;
int ret = SHFileOperation(ref struc);
if (ret != 0)
{
return(false);
}
else
{
return(true);
}
}
public static bool WindowsRecycleFile(string path)
{
try
{
SHFILEOPSTRUCT fileop = new SHFILEOPSTRUCT();
fileop.wFunc = FO_DELETE;
fileop.pFrom = path + '\0' + '\0';
fileop.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
int r = SHFileOperation(ref fileop);
if (File.Exists(path))
Log.Error("Unable to recycle file" + path);
else
Log.Info("Recycled file " + path);
}
catch (Exception ex)
{
Log.Error("Unable to recycle file " + path, ex);
return false;
}
return true;
}
private static bool Send(string path, FileOperationFlags flags)
{
try
{
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT
{
wFunc = FileOperationType.FO_DELETE,
pFrom = path + '\0' + '\0',
fFlags = (FileOperationFlags)((ushort)(FileOperationFlags.FOF_ALLOWUNDO | flags))
};
SHFileOperation(ref fileOp);
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Actually do the move of a file/directory to the recycleBin
/// </summary>
/// <param name="path"></param>
/// <returns>true if it succeed.</returns>
public static bool Recycle(string path)
{
try
{
#if MONO
// TODO: Find a way in Mono to send something to the recycle bin.
try
{
File.Delete(path);
}
catch
{
try
{
Directory.Delete(path);
}
catch
{
}
}
return true;
#else
//alternative using visual basic dll: FileSystem.DeleteDirectory(item.FolderPath,UIOption.OnlyErrorDialogs), RecycleOption.SendToRecycleBin);
//moves it to the recyle bin
var shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
string pathWith2Nulls = path + "\0\0";
shf.pFrom = pathWith2Nulls;
SHFileOperation(ref shf);
return !shf.fAnyOperationsAborted;
#endif
}
catch (Exception exception)
{
Palaso.Reporting.ErrorReport.NotifyUserOfProblem(exception, "Could not delete that book.");
return false;
}
}
public InteropSHFileOperation()
{
this.fFlags = new FILEOP_FLAGS();
this._ShFile = new SHFILEOPSTRUCT();
this._ShFile.hwnd = IntPtr.Zero;
this._ShFile.wFunc = FO_Func.FO_COPY;
this._ShFile.pFrom = "";
this._ShFile.pTo = "";
this._ShFile.fAnyOperationsAborted = 0;
this._ShFile.hNameMappings = IntPtr.Zero;
this._ShFile.lpszProgressTitle = "";
}
public String lpszProgressTitle; // Address of a string to use as the title of a progress dialog box.
#region Constructors
// This member is used only if fFlags includes the
// FOF_SIMPLEPROGRESS flag.
public SHFILEOPSTRUCT64(SHFILEOPSTRUCT initializer)
{
this.hwnd = initializer.hwnd;
this.wFunc = initializer.wFunc;
this.pFrom = initializer.pFrom;
this.pTo = initializer.pTo;
this.fFlags = initializer.fFlags;
this.fAnyOperationsAborted = initializer.fAnyOperationsAborted;
this.hNameMappings = initializer.hNameMappings;
this.lpszProgressTitle = initializer.lpszProgressTitle;
}
/// <summary>
/// Move specified files to Recycle.
/// </summary>
/// <param name="filePaths">File paths</param>
public static void MoveToRecycle(string[] filePaths)
{
if ((filePaths == null) || !filePaths.Any())
return;
var filePathCombined = String.Join("\0", filePaths) + '\0' + '\0';
var sh = new SHFILEOPSTRUCT
{
hwnd = IntPtr.Zero,
wFunc = FO.FO_DELETE,
pFrom = filePathCombined,
pTo = null,
// FOF_SILENT is necessary to prevent this application's window from losing focus.
fFlags = FOF.FOF_ALLOWUNDO | FOF.FOF_NOCONFIRMATION | FOF.FOF_SILENT,
fAnyOperationsAborted = false,
hNameMappings = IntPtr.Zero,
lpszProgressTitle = null,
};
var result = SHFileOperation(ref sh);
if (result != 0) // 0 means success or user canceled operation (it will never happen in this application).
throw new Win32Exception(String.Format("Failed to move files to Recycle. Error code: {0} File paths: {1}", result, String.Join(",", filePaths)));
}
public static extern Int32 SHFileOperation(
ref SHFILEOPSTRUCT lpFileOp);
public bool Trash()
{
SHFILEOPSTRUCT fileOp = new SHFILEOPSTRUCT();
fileOp.wFunc = FO_DELETE;
fileOp.pFrom = ImagePath + '\0' + '\0';
fileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI;
int ret = SHFileOperation(ref fileOp);
return (ret == 0 && !fileOp.fAnyOperationsAborted);
}
private static bool CopyFiles(string from, string to)
{
bool success = false;
SHFILEOPSTRUCT lpFileOp = new SHFILEOPSTRUCT();
lpFileOp.hwnd = IntPtr.Zero;
lpFileOp.wFunc = FILE_OP_TYPE.FO_COPY;
lpFileOp.pFrom = from;
lpFileOp.pTo = to;
lpFileOp.fFlags = FILE_OP_FLAGS.FOF_NORECURSION | FILE_OP_FLAGS.FOF_NOCONFIRMMKDIR | FILE_OP_FLAGS.FOF_MULTIDESTFILES;
lpFileOp.fAnyOperationsAborted = false;
lpFileOp.hNameMappings = IntPtr.Zero;
lpFileOp.lpszProgressTitle = string.Empty;
//do copy operation and store result
int result = SHFileOperation(ref lpFileOp);
//we also need to check for user aborted operations
if (result == 0)
{
success = !lpFileOp.fAnyOperationsAborted;
}
return success;
}
public static bool RecycleFile(Form parentForm, String filename)
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.hwnd = parentForm.Handle;
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
shf.pFrom = filename + "\0\0";
int res = SHFileOperation(ref shf);
return (res == 0);
}
// this function needs to carry out the specified operation. This
// parameter must contain a valid value that is not NULL. You are
// responsibile for validating the value. If you do not validate it,
// you will experience unexpected results.
public static Int32 SHFileOperation(ref SHFILEOPSTRUCT lpFileOp)
{
MachineType mt = GetMachineType();
Int32 result;
switch (mt)
{
case MachineType.win32:
SHFILEOPSTRUCT32 fos32 = new SHFILEOPSTRUCT32(lpFileOp);
result = SHFileOperation32(ref fos32);
lpFileOp.CopyFrom(fos32);
break;
case MachineType.win64:
SHFILEOPSTRUCT64 fos64 = new SHFILEOPSTRUCT64(lpFileOp);
result = SHFileOperation64(ref fos64);
lpFileOp.CopyFrom(fos64);
break;
default:
throw new ArgumentException("Hell, what kind of computer are you using? It's not 32 and not 64 bit");
}
return result;
}
public static void SendFileToRecycleBin(string filePath)
{
SHFILEOPSTRUCT shf = new SHFILEOPSTRUCT();
shf.wFunc = FO_DELETE;
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
shf.pFrom = filePath;
SHFileOperation(ref shf);
}
static extern int SHFileOperation(ref SHFILEOPSTRUCT FileOp);
private static extern int SHFileOperation(ref SHFILEOPSTRUCT lpFileOp);
