如何用C#硬删除（Shift Delete）目录及其文件？

当然可以！针对你服务器上批量处理临时文件的场景，完全能实现跳过回收站的硬删除，避免回收站堆积的问题。这里我按推荐程度给你梳理几个方案：

方案1：最简单高效的方式——直接删除整个文件夹 #

既然你要删除的是整个tempFolder及其下所有文件，**优先用Directory.Delete**就够了！这个方法默认就是直接删除（不进回收站），代码简洁高效，完全适配你的需求：

// 递归删除tempFolder及所有子文件/子文件夹，直接硬删除不进回收站
Directory.Delete(tempFolderPath, true);

为什么这个方法可行？ #

.NET的Directory.Delete和File.Delete底层调用的是Windows原生的DeleteFile/RemoveDirectory API，默认是绕过回收站直接删除的。如果你之前用File.Delete发现文件进了回收站，大概率是系统特殊设置或云同步盘的额外回收站机制导致，但针对本地临时文件夹，这个方法基本能解决问题。

方案2：强制跳过回收站的Win32 API方法 #

如果方案1在你的环境中还是会把文件移到回收站，那可以通过调用Windows Shell API强制实现“Shift+Delete”的效果，这里给你两种实现方式：

方法A：兼容性好的传统SHFileOperation API #

这个方法适配所有Windows版本，适合需要兼容老系统的场景：

using System;
using System.Runtime.InteropServices;

public static class HardDeleteHelper
{
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct SHFILEOPSTRUCT
    {
        public IntPtr hwnd;
        public FileOperationFunc wFunc;
        public string pFrom;
        public string pTo;
        public FileOperationFlags fFlags;
        public bool fAnyOperationsAborted;
        public IntPtr hNameMappings;
        public string lpszProgressTitle;
    }

    private enum FileOperationFunc : uint
    {
        FO_DELETE = 0x0003,
    }

    [Flags]
    private enum FileOperationFlags : ushort
    {
        FOF_ALLOWUNDO = 0x0040,  // 允许撤销（进回收站），硬删除不要加这个
        FOF_NOCONFIRMATION = 0x0010,  // 不弹出确认对话框
        FOF_SILENT = 0x0004,  // 不显示进度条
        FOF_NOERRORUI = 0x0400,  // 出错时不弹提示框
    }

    [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
    private static extern int SHFileOperation(ref SHFILEOPSTRUCT lpFileOp);

    // 硬删除单个文件
    public static void HardDeleteFile(string filePath)
    {
        var fileOp = new SHFILEOPSTRUCT
        {
            wFunc = FileOperationFunc.FO_DELETE,
            pFrom = filePath + "\0\0",  // API要求必须以双空字符结尾
            fFlags = FileOperationFlags.FOF_SILENT | 
                     FileOperationFlags.FOF_NOCONFIRMATION | 
                     FileOperationFlags.FOF_NOERRORUI
        };

        int result = SHFileOperation(ref fileOp);
        if (result != 0)
        {
            throw new System.ComponentModel.Win32Exception(result);
        }
    }

    // 硬删除整个文件夹
    public static void HardDeleteDirectory(string directoryPath)
    {
        HardDeleteFile(directoryPath);
    }
}

使用示例：

HardDeleteHelper.HardDeleteDirectory(tempFolderPath);

方法B：现代灵活的IFileOperation API #

对于Windows Vista及以上的系统（大部分服务器都满足），推荐用更强大的IFileOperation接口：

using System;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;

public static class ModernHardDeleteHelper
{
    [ComImport]
    [Guid("947aab5f-0a5c-4c13-b4d6-4bf7836fc9f8")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    private interface IFileOperation
    {
        void SetOperationFlags(uint dwOperationFlags);
        void SetProgressNotification(IntPtr hwnd, IntPtr pszMessage, uint dwNotifyFlags);
        void SetProgressDialog(IntPtr hwnd);
        void SetProperties(ref PROPERTYKEY key, ref PROPVARIANT propVar);
        void SetOwnerWindow(IntPtr hwnd);
        void ApplyPropertiesToItems(uint cItems, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] rgItems);
        void ApplyPropertiesToItem(IntPtr psiItem);
        uint DeleteItems(uint cItems, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] rgItems);
        uint RenameItems(uint cItems, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] rgItems, [MarshalAs(UnmanagedType.LPArray)] string[] rgszNewNames);
        uint MoveItems(uint cItems, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] rgItems, IntPtr psiDestination);
        uint CopyItems(uint cItems, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] rgItems, IntPtr psiDestination);
        void PerformOperations();
        void GetAnyOperationsAborted(out bool pfAnyOperationsAborted);
    }

    [ComImport]
    [Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe")]
    private class FileOperation { }

    [StructLayout(LayoutKind.Sequential)]
    private struct PROPERTYKEY
    {
        public Guid fmtid;
        public uint pid;
    }

    [StructLayout(LayoutKind.Explicit)]
    private struct PROPVARIANT
    {
        [FieldOffset(0)]
        public ushort vt;
        [FieldOffset(2)]
        public ushort wReserved1;
        [FieldOffset(4)]
        public ushort wReserved2;
        [FieldOffset(6)]
        public ushort wReserved3;
        [FieldOffset(8)]
        public uint uintVal;
    }

    [ComImport]
    [Guid("000214e6-0000-0000-c000-000000000046")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    private interface IShellItem
    {
        void BindToHandler(IntPtr pbc, [MarshalAs(UnmanagedType.LPStruct)] Guid bhid, [MarshalAs(UnmanagedType.LPStruct)] Guid riid, out IntPtr ppv);
        void GetParent(out IShellItem ppsi);
        void GetDisplayName(uint sigdnName, out string ppszName);
        void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
        void Compare(IShellItem psi, uint hint, out int piOrder);
    }

    [ComImport]
    [Guid("b63ea76d-1f85-456f-a19c-48159efa858b")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    private interface IShellItemFactory
    {
        void CreateItemFromParsingName([MarshalAs(UnmanagedType.LPWStr)] string pszPath, IntPtr pbc, [MarshalAs(UnmanagedType.LPStruct)] Guid riid, out IntPtr ppv);
    }

    private const uint FOF_NOCONFIRMATION = 0x0010;
    private const uint FOF_SILENT = 0x0004;
    private const uint FOF_NOERRORUI = 0x0400;

    public static void HardDelete(string path)
    {
        IShellItemFactory shellItemFactory = new FileOperation() as IShellItemFactory;
        if (shellItemFactory == null)
            throw new NotSupportedException("当前系统不支持IFileOperation API");

        shellItemFactory.CreateItemFromParsingName(path, IntPtr.Zero, typeof(IShellItem).GUID, out IntPtr shellItemPtr);
        if (shellItemPtr == IntPtr.Zero)
            throw new System.IO.FileNotFoundException("未找到目标路径", path);

        try
        {
            IFileOperation fileOp = new FileOperation() as IFileOperation;
            fileOp.SetOperationFlags(FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI);

            IntPtr[] items = new IntPtr[] { shellItemPtr };
            uint result = fileOp.DeleteItems(1, items);
            if (result != 0)
                throw new System.ComponentModel.Win32Exception((int)result);

            fileOp.PerformOperations();
        }
        finally
        {
            Marshal.Release(shellItemPtr);
        }
    }
}

使用示例：

ModernHardDeleteHelper.HardDelete(tempFolderPath);

额外注意事项 #

1. 权限问题：服务器环境下，确保程序/服务账号有足够的权限删除目标文件夹，必要时可调整文件夹权限或以管理员身份运行。
2. 批量处理效率：优先删除整个文件夹而非逐个删除文件，能大幅减少IO操作，提升处理速度。
3. 错误处理：记得添加异常捕获逻辑，避免单个文件删除失败导致整个流程中断。

内容的提问来源于stack exchange，提问作者Tempuslight