Tengo un directorio que contiene millones de subdirectorios y billones de archivos. Y ahora tengo que aclararlo. Diciendo trillón, no estoy hablando del tamaño del archivo, sino del número de archivos.

He intentado borrarlo con del/s, y utilizando el Explorador de Windows. Tampoco puede completar la tarea. He intentado eliminar algunos de los subdirectorios uno por uno, y eso me llevó días. El problema que encontré fue que cada vez, no importa usar del o Explorador, puedo ver en el Administrador de tareas que la instancia del explorador consume una memoria de gran altura y empuja gradualmente mi sistema a bloquearse.

Todavía hay algunos cientos de millones de archivos para ser borrados. ¿Hay alguna posibilidad de lograr con uno (o solo unos pocos) comandos / acciones?

[Editado]

Lo he intentado con Cygwin rm -fr, y dio el mismo resultado. Resumido como:

1. No importa usar el Explorador de Windows, DEL desde el símbolo del sistema, o Cygwin rm comando, la memoria del sistema cae gradualmente a cero, y la caja eventualmente se bloqueará.

2. Si en algún momento, antes de que falle el sistema, el proceso se cierra (mediante CTRL + C o cualquier otra cosa), la caja continuará funcionando normalmente. Sin embargo, no se liberará toda la memoria utilizada. Por ejemplo, detengo el proceso mientras la memoria del sistema alcanza el 91%, el Administrador de tareas indica: 4G de RAM en total, el caché es de 329M y los 335MB disponibles. Luego, el uso de la memoria permanecerá en este nivel hasta que reinicie la máquina. Si detengo la instancia del explorador en el Administrador de tareas, la pantalla se quedará en blanco con la luz de la unidad de disco duro todo el tiempo encendida y nunca regresará. Normalmente, cuando detengo la instancia del explorador en el Administrador de tareas, puedo volver a invocarla presionando Win + E, o se reiniciaron automáticamente.

Bueno, realmente agradable manejo de la memoria!

[EDITAR DE NUEVO] Parece que parte de la memoria utilizada se liberó después de un largo tiempo, pero no todos. Algunos de los en caché y amp; La memoria disponible regresó en el Administrador de tareas. No he esperado más, no estoy seguro de qué pasará entonces.

Explicación técnica

La razón por la que la mayoría de los métodos están causando problemas es que Windows intenta enumerar los archivos y carpetas. Este no es un gran problema con unos pocos cientos, o incluso miles, de archivos / carpetas a unos pocos niveles de profundidad, pero cuando trillones de archivos en millones de carpetas que van a docenas de niveles de profundidad, entonces eso definitivamente atascará el sistema.

Deje que tenga "solo" 100,000,000 archivos, y Windows usa una estructura simple como esta para almacenar cada archivo junto con su ruta (de esa manera usted evita almacenar cada directorio por separado, ahorrando algo de sobrecarga):

struct FILELIST {                   // Total size is 264 to 528 bytes:
  TCHAR         name[MAX_PATH];     // MAX_PATH=260; TCHAR=1 or 2 bytes
  FILELIST*     nextfile;           // Pointers are 4 bytes for 32-bit and 8 for 64-bit
}

Dependiendo de si usa caracteres de 8 bits o caracteres Unicode (usa Unicode) y si su sistema es de 32 bits o de 64 bits, entonces necesitará entre 25 GB y 49 GB de memoria para almacenar la lista (y esto es muy estructura simplificada).

La razón por qué Windows intenta enumerar los archivos y carpetas antes de eliminarlos, según el método que esté utilizando para eliminarlos, pero tanto el Explorador como el intérprete de comandos lo hacen (puede ver una demora cuando inicia el comando). También puede ver el flash de actividad del disco (HDD LED) cuando lee el árbol de directorios de la unidad.

Solución

Su mejor opción para lidiar con este tipo de situación es utilizar una herramienta de eliminación que elimine los archivos y carpetas individualmente, uno a la vez. No sé si hay herramientas preparadas para hacerlo, pero debería Ser posible lograr con un simple archivo por lotes.

@echo off
if not [%1]==[] cd /d %1
del /q *
for /d %%i in (*) do call %0 "%%i"

Lo que esto hace es comprobar si se pasó un argumento. Si es así, entonces cambia al directorio especificado (puede ejecutarlo sin un argumento para comenzar en el directorio actual o especificar un directorio, incluso en una unidad diferente para que comience allí).

A continuación, borra todos los archivos en el directorio actual. En este modo, no debe enumerar nada y simplemente eliminar los archivos sin absorber mucha memoria, si es que la hay.

Luego enumera las carpetas en el directorio actual y se llama a sí mismo, pasándole cada carpeta (auto) para que se retire hacia abajo.

Análisis

La razón por la que esto debería el trabajo es porque no enumera todos los archivos y carpetas en el árbol entero . No enumera ningún archivo, y solo enumera las carpetas en el directorio actual (más el restante unos en los directorios padre). Suponiendo que solo hay unos pocos cientos de subdirectorios en una carpeta determinada, esto no debería ser tan malo y, por supuesto, requiere mucha menos memoria que otros métodos que enumeran todo el árbol.

Usted puede preguntarse sobre el uso de la /r cambiar en lugar de usar (manual) la recursión. Eso no funcionaría porque mientras el /r switch hace recursión, pre-enumera todo el árbol de directorios, que es exactamente lo que queremos evitar; Queremos eliminar a medida que avanzamos sin seguir la pista.

Comparación

Permite comparar este método con los métodos de enumeración completa.

Habías dicho que tenías "millones de directorios"; Digamos 100 millones. Si el árbol está aproximadamente equilibrado, y suponiendo un promedio de aproximadamente 100 subdirectorios por carpeta, entonces el directorio anidado más profundo estaría alrededor de cuatro niveles por debajo: en realidad, habría 101,010,100 subcarpetas en todo el árbol. (Divertido cómo 100M puede descomponerse a solo 100 y 4).

Dado que no estamos enumerando archivos, solo debemos mantener un registro de como máximo 100 nombres de directorio por nivel, por un máximo de 4 × 100 = 400 directorios en un momento dado.

Por lo tanto, el requisito de memoria debe ser ~ 206.25KB, dentro de los límites de cualquier sistema moderno (o de otro tipo).

Prueba

Desafortunadamente (?) No tengo un sistema con billones de archivos en millones de carpetas, por lo que no puedo probarlo (creo que en el último recuento, tenía aproximadamente ~ 800K archivos), por lo que alguien más tendrá que intentarlo. eso.

Advertencia

Por supuesto, la memoria no es la única limitación. La unidad también será un gran cuello de botella porque, por cada archivo y carpeta que elimine, el sistema debe marcarlo como libre. Afortunadamente, muchas de estas operaciones de disco se agruparán (almacenarán en caché) y se escribirán en trozos en lugar de individualmente (al menos para discos duros, no para medios extraíbles), pero aún así causará un poco de palizas a medida que el sistema lea y escribe los datos.

Eliminar todas las carpetas llevará mucho tiempo, y no hay mucho que puedas hacer al respecto. Lo que puede hacer es guardar sus datos y formatear su unidad. No es óptimo, pero funcionará (y rápidamente).

Otra opción es quizás usar una distribución de Linux en un CD en vivo que puede leer desde una partición NTFS. Sé por experiencia personal que rm -rf folderName Puede funcionar durante al menos 2 días sin fallar un sistema con 2GB de RAM. Tomará un tiempo, pero al menos terminará.

Erm ... no quiero saber cómo creaste tantos.

Lo que sucede es que el Explorador está intentando enumerar todos los archivos y almacenar la información en la memoria, antes de que empiece a borrarse. Y obviamente hay demasiados.

¿Has probado el comando? rmdir /s? Siempre que se eliminen los archivos a medida que se encuentren, en lugar de esperar a que se enumeren todos, puede que funcione.

¿Cuántos niveles de subdirectorios hay? Si solo hay uno, o algún otro número bajo, entonces puede funcionar un archivo de proceso rápido que se repite manualmente.

Sin embargo, cualquier método tomará un tiempo.

No puedo hablar con los trillones de archivos, pero hace poco estuve en un recurso compartido de archivos antiguos que contenía archivos ~ 1.8M usando:

robocopy EmptyTMPFolder FolderToDelete /MIR /MT:16 /ETA /R:30 /W:5

"EmptyTMPFolder" es un directorio local vacío. La opción / MIR hará que el objetivo se vea como el origen (vacío).

El beneficio real de este enfoque fue la opción de reintento (/ R: 30). Esto permitió la oportunidad de absorber cualquier problema de conectividad que pueda ocurrir durante este proceso. Las eliminaciones locales podrían no encontrar beneficios en este enfoque.

No tengo puntos de referencia específicos para comparar los tiempos, pero preferiría esto sobre algunas de las otras opciones sugeridas b / c de las opciones de reintento / espera. Las eliminaciones comenzaron casi al instante.

Cambio + Borrar se salta la Papelera de reciclaje y puede acelerar significativamente las cosas.

Si eso no funciona (casos extremos), intente Borrador rápido de carpetas y / o Directorio masivo de borrador

Una posible causa de un problema como este es el aprovisionamiento ligero, que generalmente se encuentra en los entornos SAN. Algunas unidades de estado sólido pueden presentar el mismo problema. Si este es el caso, este cambio de configuración podría resolver su problema:

fsutil behavior set DisableDeleteNotify 1

Tenga en cuenta que este cambio puede afectar el rendimiento de las unidades de estado sólido y puede impedir el rediseño automático y / o manual de las unidades SAN.

Es probable que su antivirus / antimalware consuma toda la memoria y luego bloquee el sistema.

Windows en sí no tiene problemas para eliminar una gran cantidad de archivos, aunque ciertamente es más lento que una operación similar en la mayoría de los sistemas de archivos que no son de Microsoft.

Al probar varios métodos para eliminar más de 10 millones de archivos de registro de fusión, noté que, en promedio, se podían eliminar aproximadamente 30K archivos durante un período de 10 minutos. Eso llevaría unas 55 horas para los 10 millones de archivos ...

Con el siguiente script, la tasa de eliminación aumentó en ~ 75%. Las listas de archivos se crean y ejecutan mediante procesos concurrentes que aumentan las operaciones del disco (pero no de forma lineal). Estoy mostrando 4 bifurcaciones, pero dos pueden ser suficientes.

Hay una opción para usar PowerShell que reduce significativamente el tiempo requerido para preparar las listas.

Por cierto, probé utilizando dos operaciones del del directas que permitían colisiones, pero no hubo una reducción notable en el tiempo de eliminación total en comparación con una sola operación del del. Y aunque podría no ser conveniente crear listas de eliminación, el tiempo ahorrado valió la pena.

@ECHO OFF
SETLOCAL EnableDelayedExpansion

IF /I "%~1"=="timestamp" (
    CALL :ECHOTIMESTAMP
    GOTO END
)

rem directory structure to delete
SET "DELETE=c:\_delete\Content.IE5\???<<<change this>>>???"
rem primary list of discovered files to delete
SET "LIST=delete-list.txt"
rem base path for sub-lists
SET "LISTBASE=.\delete-list"
SET "TITLE=Batch Delete Process"
rem specifies number of batch delete processes to spawn
SET FORKS=4
rem when set to 1, use PowerShell for list building and delete.  Definitely improves time to build fork sublists
SET POWERSHELL=0
rem specifies max files to delete when greater than 0
SET MAXDEL=1000000

rem prompt for confirmatoin
SET /P CONT=About to delete all files and directories from !DELETE!. Continue (Y/N)?
IF /I NOT "!CONT!"=="Y" EXIT /B

CALL :ECHOTIMESTAMP

ECHO Accumulating list of files to delete...
dir /b /s "!DELETE!" > "!LIST!"

FOR /F "delims=" %%c IN ('type "!LIST!" ^| find /C ":"') DO SET "COUNT=%%c"
ECHO Discoverd !COUNT! files and directories to delete.

IF  %MAXDEL% GTR 0 IF !COUNT! GTR %MAXDEL% (
    SET COUNT=%MAXDEL%
    ECHO Limiting files/directories deletion count to  !COUNT!
)

CALL :ECHOTIMESTAMP
ECHO Preparing !FORKS! delete processes...
SET /A LIMIT=!COUNT!/!FORKS!

IF !POWERSHELL! EQU 1 (
    SET SKIP=0
    FOR /L %%n IN (1,1,!FORKS!) DO (
        SET "CURRENT=!LISTBASE!-%%n.txt"
        SET "LIST[%%n]=!CURRENT!"
        DEL /f /q "!CURRENT!" > nul 2>&1
        IF %%n EQU !FORKS! SET /A LIMIT+=!FORKS!
        SET CMD=type \"!LIST!\" ^| select -first !LIMIT! -skip !SKIP!
        powershell -command "& {!CMD!}" > "!CURRENT!"
        SET /A SKIP+=!LIMIT!
    )

) ELSE (
    rem significantly slower but no PowerShell.
    SET L=1
    SET N=!LIMIT!
    SET C=0
    FOR /F %%f  IN (!LIST!) DO (
        IF !C! LSS !COUNT! (
            IF !N! GEQ !LIMIT! (
                SET "CURRENT=!LISTBASE!-!L!.txt"
                SET "LIST[!L!]=!CURRENT!"
                DEL /f /q "!CURRENT!" > nul 2>&1
                SET /A L+=1
                SET /A N=0
            ) ELSE (
                SET /A N+=1
            )
            ECHO %%f >> "!CURRENT!"
        ) ELSE (
            GOTO ENDLIST
        )
        SET /A C+=1
    )
)
:ENDLIST

CALL :ECHOTIMESTAMP
ECHO Forking !FORKS! delete processes...
FOR /L %%t IN (1,1,!FORKS!) DO (

    SET "CURRENT=!LIST[%%t]!"
    IF !POWERSHELL! EQU 1 (
        SET "TAB=        "
        SET BLANK=!TAB!!TAB!!TAB!!TAB!!TAB!!TAB!!TAB!!TAB!
        SET BLANK=!BLANK!!BLANK!!BLANK!!BLANK!
        SET DEL_CMD=del -force -recurse -ea SilentlyContinue -path \"$_\"
        SET $W_CMD=$w=$Host.UI.RawUI.WindowSize.Width
        SET $S_CMD=$s=\"$_\";$i=[math]::max^(0,$s.length-$w^);$s=$s.substring^($i, $s.length-$i^);$s=\"$s !BLANK!\";$s=$s.substring^(0,[math]::min($w,$s.length^)^)
        SET ECHO_CMD=Write-Host \"`r$s\" -NoNewLine
        SET CMD=type \"!CURRENT!\" ^| %% {!DEL_CMD!; !$W_CMD!; !$S_CMD!; !ECHO_CMD!}
        SET CMD=powershell -command "^& {!CMD!}" ^& ECHO\ ^& "%~dpnx0" timestamp
        ECHO CMD !CMD!
    ) ELSE (
        SET LOOP=FOR /F %%%f IN ^(!CURRENT!^) DO
        SET OP=del "%%%f"
        SET CMD=@ECHO OFF ^&^& ^(!LOOP! !OP!  ^> nul 2^>^&1 ^)  ^& "%~dpnx0" timestamp
    )
    rem ECHO !CMD!
    START "!TITLE! %%t" cmd /k  !CMD!
)

GOTO END

:ECHOTIMESTAMP
SETLOCAL
    SET DATESTAMP=!DATE:~10,4!-!DATE:~4,2!-!DATE:~7,2!
    SET TIMESTAMP=!TIME:~0,2!-!TIME:~3,2!-!TIME:~6,2!
    ECHO !DATESTAMP: =0!-!TIMESTAMP: =0!
ENDLOCAL
GOTO :EOF

:END
ENDLOCAL
EXIT /B

Prueba esto, y modifica según lo necesites.

Es un script probado en Win2003 basado en Synetech Explicación técnica y Análisis respondió el 15 de octubre de 13 a las 15:22

@echo off

rem ### USE FULL PATH AS FIRST ARGUMENT TO SCRIPT, DONT FORGET QUOTES !
rem ### If you move this script, fix script path variable...
SET STATICFULLSCRIPTPATH="D:\scripts\FOLDER"
SET SCRIPTNAME="DeleteFast.bat"

rem ### If CD fails or IF condition has problems,
rem ### and DEL or RMDIR runs, its better to be at safe place.
if not exist "%TEMP%\SAFE" mkdir "%TEMP%\SAFE"
if exist "%TEMP%\SAFE" cd /d "%TEMP%\SAFE"

rem ### Fix quote overflow
set var1="%1"
set var1=%var1:"=%

if not [%1]==[] (
    cd /d "%var1%"

    echo # KILLING F AT : "%var1%"
    rem ### uncomment to do damage! ### 
    rem # del /f/q * > nul

    for /d %%i in (*) do call "%STATICFULLSCRIPTPATH%\%SCRIPTNAME%" "%var1%\%%i"

    rem ## Finish deleting the last dir
    cd /d "%var1%\.."

echo # KILLING  DIR : "%var1%"
rem ## Remove dir.. first try
rmdir /q "%var1%"

if exist "%var1%" (
    rem ## Remove dir.. second try
    rem ## If thousands of files/dirs had permission/ownership problems, then prepare to wait a long time.
    rem ### uncomment to do damage! ### 
    rem #cmd.exe /c takeown /f "%var1%" && icacls "%var1%" /grant SOMEBODY:F

    rem ### uncomment to do damage! ### 
    rem #rmdir /s/q "%var1%"
)
)

cd /d "%STATICFULLSCRIPTPATH%"

Prueba de funcionamiento.. Hay carpetas como A1 a A4, B1 a B4 y C1 a C4 anidadas de manera diferente ...

Z:\>"D:\scripts\FOLDER\DeleteFast.bat" "D:\scripts\TESTF\DIRS"
# KILLING F AT : "D:\scripts\TESTF\DIRS"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B1\C 1"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B1\C 1"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B2"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B2\C 2"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B2\C 2"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B2"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A2"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A2\B3"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A2\B3\C 3"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A2\B3\C 3"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A2\B3"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A2"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A3"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A3\B4"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A3\B4\C 4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A3\B4\C 4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A3\B4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A3"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS"

D:\scripts\FOLDER>

No puedo comentar (el sitio se queja de mi reputación), así que agrego mi comentario aquí ..

La solución de Bjv crea listas de archivos temporales inútiles. Y luego los reitera por segunda vez para hacer el trabajo real. https://superuser.com/a/892412/528695

El guión original de Synetech no funcionó para mí. https://superuser.com/a/416469/528695

@echo off
if not [%1]==[] cd /d %1
echo "%1"
for /d %%i in (*) do call %0 "%%i"

Resultados ...

Z:\>C:\privscripts\TESTF\DeleteFastORIGINAL.bat "C:\privscripts\TESTF\DIRS"
""C:\privscripts\TESTF\DIRS""
""A1""
""B1""
""C1""
The system cannot find the path specified.
""B2""
The system cannot find the path specified.
""A2""
The system cannot find the path specified.
""A3""
The system cannot find the path specified.
""A4""

C:\privscripts\TESTF\DIRS\A1\B1\C1>

Hace un tiempo tuve problemas similares con solo 10 millones de archivos, pero en un servidor 2003, para eliminar los archivos, utilicé un servidor / cliente ftp, y dejé que el cliente eliminara los archivos y carpetas. Es una solución lenta pero funciona perfectamente.

Probablemente tendrá un segundo problema con la MFT en NTFS que no tiene solución, la MFT es una matriz que, en Win 2003 (no estoy seguro de que Microsoft tenga una solución después de Win 2003), almacena todos los archivos de manera incremental. con un billón de archivos, el tamaño será una locura, en mi caso la MFT tenía 17 millones de registros y el tamaño de la MFT era de alrededor de 19 GB con solo 45000 archivos, probé en otros sistemas y parece que para 1 millón de registros la MFT Estar alrededor de 1 GB.

Puedes verificar el estado de la MFT con este comando:

defrag C: /a /v

• C: - letra de unidad
• /a - analizar
• /v - verboso

Otra solución difícil, ya que no existe una herramienta que pueda reducir el tamaño de la MFT, las herramientas solo completan con 0 el nombre de los archivos y las propiedades, pero nada más, pero puede usar VMware converter u otro tipo de P2V y crear una máquina virtual basada en En su servidor, de esta manera usted solucionará todos los problemas relacionados con la MFT, nunca probé la conversión de V2P, ahora estoy trabajando solo en entornos virtuales, pero vi mucha información al respecto en internet.

Ese premio de 2003 funciona perfectamente ahora, el tamaño de la MFT es de 40 MB y todo está bien. Si lo desea, puedo brindarle más información acerca de las copias de seguridad, defrags y otras tareas relacionadas con millones de archivos pequeños.

Por esta respuesta en StackOverflow usa una combinación de del y rmdir:

del /f/s/q foldername > nul
rmdir /s/q foldername

Dado que eliminar todos los archivos a la vez consume demasiada memoria, necesita una forma de eliminarlos de uno en uno, pero con el proceso automatizado. Este tipo de cosas es mucho más fácil de hacer en un shell de estilo Unix, así que vamos a usar Cygwin. El siguiente comando genera una lista de archivos ordinarios, transforma esa lista en una secuencia de rm Comandos, luego alimenta el script resultante a un shell.

 find dir \! -type d | sed 's/^/rm /' | sh

El script se está ejecutando incluso mientras se está generando, y no hay bucles, por lo que el shell no (con suerte) tiene que crear ningún archivo temporal grande. Sin duda tomará un tiempo, ya que el script tiene millones de líneas. Es posible que tengas que ajustar la rm comando (tal vez debería haber usado -f? pero entiendes tus archivos mejor que yo) para que funcione.

Ahora no te queda más que directorios. Aquí es donde las cosas se ponen difíciles. Tal vez haya borrado suficientes archivos para que pueda hacer rm -rf sin quedarse sin memoria (y probablemente será más rápido que otro script). Si no, podemos adaptar esto. Respuesta stackoverflow :

 find dir | perl -lne 'print tr:/::, " $_"' | sort -n | cut -d' ' -f2 | sed 's/^/rmdir /' | sh

Una vez más, los ajustes pueden ser necesarios, esta vez con sort, para evitar crear enormes archivos temporales.

Un problema con el que podría encontrarse es que el directorio no se compacta al eliminar un archivo / carpeta, por lo que si tiene una carpeta con 1 millón de archivos y borra los primeros 500k de ellos. Hay una tonelada de bloques al principio de su directorio que están en blanco para todos los intentos.

PERO, el explorador y un indicador de comando aún tienen que revisar esos bloques en caso de que haya un archivo allí. Algo que podría ayudar es "mover" una carpeta de algún lugar del árbol a una nueva carpeta fuera de la base de la unidad, luego eliminar esa nueva carpeta. Mover la carpeta solo moverá el puntero a la carpeta, por lo que debería ir rápidamente y no mover todos los archivos debajo a un nuevo espacio en la unidad.

Otra cosa que puede intentar es usar una herramienta de terceros como "PerfectDisk" para compactar carpetas después de eliminar un montón de archivos.

Me encontré con el mismo problema hace algún tiempo. Escribí una pequeña utilidad que hace exactamente eso: eliminar recursivamente un directorio. No enumerará los archivos y no consumirá mucha memoria (O (n + m) como máximo con n = profundidad máxima del directorio y m = cuenta máxima de archivos / directorios en uno de los subdirectorios). Puede manejar rutas de archivo largas (& gt; 256 caracteres). Me encantaría recibir comentarios si puedes resolver tu problema con esto.

Lo puedes encontrar aquí: https://github.com/McNetic/fdeltree (ejecutable en la carpeta de lanzamientos)