enviar un archivo a la papelera de reciclaje

Question

Actualmente estoy usando la siguiente función

file.Delete(); 

Pero, ¿cómo puedo usar esta función para enviar un archivo a la papelera de reciclaje en lugar de sólo la supresión de plano?

Answer 1

NOTA: Esto también no funciona con aplicaciones de interfaz de usuario no interactivos como Windows Servicios

Esta envoltura puede proporcionar la funcionalidad que necesitaba:

using System.Runtime.InteropServices; 

public class FileOperationAPIWrapper 
    { 
     /// <summary> 
     /// Possible flags for the SHFileOperation method. 
     /// </summary> 
     [Flags] 
     public enum FileOperationFlags : ushort 
     { 
      /// <summary> 
      /// Do not show a dialog during the process 
      /// </summary> 
      FOF_SILENT = 0x0004, 
      /// <summary> 
      /// Do not ask the user to confirm selection 
      /// </summary> 
      FOF_NOCONFIRMATION = 0x0010, 
      /// <summary> 
      /// Delete the file to the recycle bin. (Required flag to send a file to the bin 
      /// </summary> 
      FOF_ALLOWUNDO = 0x0040, 
      /// <summary> 
      /// Do not show the names of the files or folders that are being recycled. 
      /// </summary> 
      FOF_SIMPLEPROGRESS = 0x0100, 
      /// <summary> 
      /// Surpress errors, if any occur during the process. 
      /// </summary> 
      FOF_NOERRORUI = 0x0400, 
      /// <summary> 
      /// Warn if files are too big to fit in the recycle bin and will need 
      /// to be deleted completely. 
      /// </summary> 
      FOF_WANTNUKEWARNING = 0x4000, 
     } 

     /// <summary> 
     /// File Operation Function Type for SHFileOperation 
     /// </summary> 
     public enum FileOperationType : uint 
     { 
      /// <summary> 
      /// Move the objects 
      /// </summary> 
      FO_MOVE = 0x0001, 
      /// <summary> 
      /// Copy the objects 
      /// </summary> 
      FO_COPY = 0x0002, 
      /// <summary> 
      /// Delete (or recycle) the objects 
      /// </summary> 
      FO_DELETE = 0x0003, 
      /// <summary> 
      /// Rename the object(s) 
      /// </summary> 
      FO_RENAME = 0x0004, 
     } 



     /// <summary> 
     /// SHFILEOPSTRUCT for SHFileOperation from COM 
     /// </summary> 
     [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] 
     private struct SHFILEOPSTRUCT 
     { 

      public IntPtr hwnd; 
      [MarshalAs(UnmanagedType.U4)] 
      public FileOperationType wFunc; 
      public string pFrom; 
      public string pTo; 
      public FileOperationFlags fFlags; 
      [MarshalAs(UnmanagedType.Bool)] 
      public bool fAnyOperationsAborted; 
      public IntPtr hNameMappings; 
      public string lpszProgressTitle; 
     } 

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

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

     /// <summary> 
     /// Send file to recycle bin. Display dialog, display warning if files are too big to fit (FOF_WANTNUKEWARNING) 
     /// </summary> 
     /// <param name="path">Location of directory or file to recycle</param> 
     public static bool Send(string path) 
     { 
      return Send(path, FileOperationFlags.FOF_NOCONFIRMATION | FileOperationFlags.FOF_WANTNUKEWARNING); 
     } 

     /// <summary> 
     /// Send file silently to recycle bin. Surpress dialog, surpress errors, delete if too large. 
     /// </summary> 
     /// <param name="path">Location of directory or file to recycle</param> 
     public static bool MoveToRecycleBin(string path) 
     { 
      return Send(path, FileOperationFlags.FOF_NOCONFIRMATION | FileOperationFlags.FOF_NOERRORUI | FileOperationFlags.FOF_SILENT); 

     } 

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

     public static bool DeleteCompletelySilent(string path) 
     { 
      return deleteFile(path, 
           FileOperationFlags.FOF_NOCONFIRMATION | FileOperationFlags.FOF_NOERRORUI | 
           FileOperationFlags.FOF_SILENT); 
     } 
    } 

Answer 2

Puede DllImport SHFileOperation para hacer esto.

Answer 3

Utilice FileSystem.DeleteFile y especifique la derecha RecycleOption.

Si bien esto funcionará con UI Interactive Apps, no funcionará con aplicaciones interactivas que no sean UI, como una aplicación de servicio de Windows.

Answer 4

Lamentablemente debe recurrir a la API de Win32 para eliminar un archivo a la Papelera de reciclaje. Pruebe el siguiente código, basado en this post. Hace uso de la función genérica SHFileOperation para las operaciones del sistema de archivos a través del shell de Windows.

Defina lo siguiente (en una clase de utilidades es probablemente mejor).

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto, Pack=1)] 
public struct SHFILEOPSTRUCT 
{ 
     public IntPtr hwnd; 
     [MarshalAs(UnmanagedType.U4)] public int wFunc; 
     public string pFrom; 
     public string pTo; 
     public short fFlags; 
     [MarshalAs(UnmanagedType.Bool)] public bool fAnyOperationsAborted; 
     public IntPtr hNameMappings; 
     public string lpszProgressTitle; 
} 

[DllImport("shell32.dll", CharSet=CharSet.Auto)] 
public static extern int SHFileOperation(ref SHFILEOPSTRUCT FileOp); 

public const int FO_DELETE = 3; 
public const int FOF_ALLOWUNDO = 0x40; 
public const int FOF_NOCONFIRMATION = 0x10; // Don't prompt the user 

y utilizarlo para eliminar un archivo, enviarlo a la papelera de reciclaje, usted quiere algo como:

var shf = new SHFILEOPSTRUCT(); 
shf.wFunc = FO_DELETE; 
shf.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION; 
shf.pFrom = @"C:\test.txt"; 
SHFileOperation(ref shf); 

Answer 5

De MSDN:

agregar una referencia al ensamblaje Microsoft.VisualBasic . La clase necesaria se encuentra en esta biblioteca.

Agregue esta instrucción using al principio del archivo using Microsoft.VisualBasic.FileIO;

Utilice FileSystem.DeleteFile para eliminar un archivo, tiene la opción de especificar la papelera de reciclaje o no.

Utilice FileSystem.DeleteDirectory para eliminar un directorio con la opción de especificar para enviarlo a la papelera de reciclaje o no.

Answer 6

¿Son estas respuestas en serio?

using Shell32; 

static class Program 
{ 
    public static Shell shell = new Shell(); 
    public static Folder RecyclingBin = shell.NameSpace(10); 

    static void Main() 
    { 
     RecyclingBin.MoveHere("PATH TO FILE/FOLDER") 
    } 
} 

Eso es todo. También puede hacer prácticamente todo lo demás, con la papelera de reciclaje, utilizando esta biblioteca.

---

Agregue la biblioteca "Microsoft Shell Controls And Automation" en el menú COM, para usar el espacio de nombres Shell32. Esto está vinculado dinámicamente, y no compilado con su programa.