Como excluir um grande número de arquivos no Windows

16

Eu tenho um diretório que contém milhões de subdiretórios e trilhões de arquivos. E agora eu tenho que limpar isso. Dizendo trilhões, não estou falando sobre o tamanho do arquivo, mas o número de arquivos.

Eu tentei excluí-lo com del/s e usando o Windows Explorer. Nenhum deles pode completar a tarefa. Eu tentei excluir alguns dos subdiretórios um por um, e isso me levou dias. O problema que eu encontrei foi que todas as vezes, não importa o del ou o Explorer, eu posso ver no Gerenciador de Tarefas que a instância do explorador consome uma memória muito alta, e gradualmente empurra o meu sistema para travar.

Ainda há algumas centenas de milhões de arquivos a serem excluídos. Existe alguma possibilidade de conseguir com um (ou apenas alguns) comandos / ações?

[EDITADO]

Eu tentei fazer isso com o Cygwin rm -fr e obtive o mesmo resultado. Resumido como:

  1. Independentemente do uso do Windows Explorer, DEL do prompt de comando ou do comando Cygwin rm , a memória do sistema cai gradualmente para zero e a caixa eventualmente falhará.

  2. Se a qualquer momento, antes de o sistema falhar, o processo é fechado (por CTRL + C ou o que mais), a caixa continuará a funcionar normalmente. No entanto, toda a memória usada NÃO será liberada. Dizer, eu paro o processo enquanto a memória do sistema atinge 91%, o Gerenciador de Tarefas informa: 4G RAM no total, Cache é 329M e 335MB Disponível. Em seguida, o uso da memória permanecerá em torno desse nível até que eu reinicialize a máquina. Se eu parar a instância do explorador no Gerenciador de Tarefas, a tela ficará em branco com a luz do disco rígido o tempo todo e nunca mais voltará. Normalmente, quando eu paro a instância do explorador no Gerenciador de Tarefas, posso invocá-lo novamente pressionando Win + E ou ele foi reiniciado automaticamente.

Bom, gerenciamento de memória muito bom!

[EDIT NOVAMENTE] Parece que algumas das memórias usadas foram liberadas depois de um longo tempo, mas não todas. Algumas das opções em cache & A memória disponível voltou no Gerenciador de Tarefas. Eu não esperei mais, não tenho certeza do que acontecerá então.

    
por Jackey Cheung 24.04.2012 / 11:46

14 respostas

5

Explicação técnica

A razão pela qual a maioria dos métodos está causando problemas é que o Windows tenta enumerar os arquivos e pastas. Isso não é um grande problema com algumas centenas - ou mesmo milhares - de arquivos / pastas com alguns níveis de profundidade, mas quando você tem trilhões de arquivos em milhões de pastas com vários níveis de profundidade, então isso definitivamente vai atrapalhar o sistema.

Você tem "apenas" 100.000.000 de arquivos, e o Windows usa uma estrutura simples como essa para armazenar cada arquivo junto com seu caminho (dessa forma, você evita armazenar cada diretório separadamente, economizando um pouco 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
}

Dependendo se ele usa caracteres de 8 bits ou caracteres Unicode (ele usa Unicode) e se seu sistema é de 32 bits ou 64 bits, ele precisará de entre 25 GB e 49 GB de memória para armazenar a lista (e isso é aa estrutura muito simplificada).

O motivo pelo qual o Windows tenta enumerar os arquivos e pastas antes de excluí-los varia dependendo do método que você está usando para excluí-los, mas o Explorer e o interpretador de comandos fazem isso (você pode ver um atraso quando você inicia o comando). Você também pode ver a atividade do disco (LED do HDD) piscar enquanto lê a árvore de diretório da unidade.

Solução

Sua melhor aposta para lidar com esse tipo de situação é usar uma ferramenta de exclusão que exclua os arquivos e as pastas individualmente, um de cada vez. Não sei se existem ferramentas prontas para fazê-lo, mas deve ser possível realizar com um arquivo em lote simples.

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

O que isto faz é verificar se um argumento foi passado. Se assim for, então ele muda para o diretório especificado (você pode executá-lo sem um argumento para iniciar no diretório atual ou especificar um diretório - mesmo em uma unidade diferente para que ele seja iniciado).

Em seguida, exclui todos os arquivos no diretório atual. Nesse modo, ele não deve enumerar nada e simplesmente excluir os arquivos sem sugar muita memória, se houver.

Em seguida, ele enumera as pastas no diretório atual e chama a si mesmo, passando cada pasta para ele (self) para recuar para baixo.

Análise

A razão pela qual isso deve funcionar é porque ele não enumera todos os arquivos e pastas na árvore inteira . Ele não enumera nenhum arquivo e apenas enumera as pastas no diretório atual (mais as restantes nos diretórios pai). Supondo que haja apenas algumas centenas de subdiretórios em uma determinada pasta, isso não deve ser tão ruim, e certamente requer muito menos memória do que outros métodos que enumeram toda a árvore.

Você pode se perguntar sobre o uso da opção /r em vez de usar a recursão (manual). Isso não funcionaria porque, embora a opção /r faça recursão, ela pré-enumera toda a árvore de diretórios, o que é exatamente o que queremos evitar; queremos excluir à medida que avançamos sem acompanhar.

Comparação

Vamos comparar este método com o (s) método (s) de enumeração completa.

Você disse que tinha "milhões de diretórios"; digamos 100 milhões. Se a árvore for aproximadamente balanceada e assumir uma média de cerca de 100 subdiretórios por pasta, o diretório aninhado mais profundo terá cerca de quatro níveis abaixo - na verdade, seriam 101.010.100 subpastas na árvore inteira. (Divertido como 100M pode quebrar para apenas 100 e 4).

Como não estamos enumerando arquivos, precisamos apenas controlar no máximo 100 nomes de diretório por nível, para um máximo de 4 × 100 = 400 diretórios em um dado momento.

Portanto, o requisito de memória deve ser ~ 206,25 KB, bem dentro dos limites de qualquer sistema moderno (ou qualquer outro).

Teste

Infelizmente eu não tenho um sistema com trilhões de arquivos em milhões de pastas, então eu não posso testá-lo (eu acredito na última contagem, eu tinha cerca de 800 mil arquivos), então alguém vai tem que tentar.

Advertência

É claro que a memória não é a única limitação. A unidade também será um grande gargalo porque, para cada arquivo e pasta excluídos, o sistema deve marcá-lo como livre. Felizmente, muitas dessas operações de disco serão empacotadas juntas (em cache) e escritas em blocos, em vez de individualmente (pelo menos para discos rígidos, não para mídias removíveis), mas ainda causará bastante surra enquanto o sistema lê e grava os dados.

    
por 15.10.2013 / 17:22
3

Excluir todas as pastas levará muito tempo e não há muito o que fazer sobre isso. O que você pode fazer é salvar seus dados e formatar sua unidade. Não é o ideal, mas vai funcionar (e rapidamente).

Outra opção é talvez usar alguma distribuição Linux em um live CD que possa ler de uma partição NTFS. Eu sei por experiência pessoal que rm -rf folderName pode rodar por pelo menos 2 dias sem travar um sistema com 2GB de RAM. Vai demorar um pouco, mas pelo menos vai acabar.

    
por 24.04.2012 / 12:00
3

Erm .. Eu não quero saber como você criou tantos.

O que está acontecendo é que o Explorer está tentando enumerar cada arquivo e armazenar as informações na memória antes de começar a excluir. E obviamente há muitos.

Já experimentou o comando rmdir /s ? Contanto que, na verdade, apague os arquivos à medida que são encontrados, em vez de esperar que todos sejam enumerados, isso pode funcionar.

Quantos níveis de subdiretórios existem? Se houver apenas um, ou algum outro número baixo, um arquivo em lote rápido que seja recursivado manualmente poderá funcionar.

No entanto, qualquer método demorará um pouco.

    
por 24.04.2012 / 12:01
3

Eu não posso falar sobre os trilhões de arquivos, mas recentemente eu descobri um antigo compartilhamento de arquivos que continha arquivos ~ 1.8M usando:

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

"EmptyTMPFolder" é um diretório local vazio. a opção / MIR fará com que o alvo se pareça com a fonte (vazia).

O benefício real dessa abordagem foi a opção de repetição (/ R: 30). Isso permitiu uma oportunidade de absorver quaisquer problemas de conectividade que possam ocorrer durante esse processo. Exclusões locais podem não ser benéficas nessa abordagem.

Eu não tenho referências específicas para comparar os tempos, mas eu preferiria isso sobre algumas das outras opções sugeridas b / c das opções de repetição / espera. As exclusões começaram quase instantaneamente.

    
por 08.02.2016 / 17:48
2

Shift + Excluir pula a Lixeira e pode acelerar bastante as coisas.

Se isso não funcionar (casos extremos), tente Apagador de pasta rápida e / ou Borracha do Diretório em Massa

    
por 25.04.2012 / 04:23
2

Uma possível causa de um problema como este é o provisionamento thin, normalmente encontrado em ambientes SAN. Algumas unidades de estado sólido podem exibir o mesmo problema. Se esse for o caso, essa alteração de configuração pode resolver seu problema:

fsutil behavior set DisableDeleteNotify 1

Observe que essa alteração pode afetar o desempenho em unidades de estado sólido e pode impedir a repetição automática e / ou manual de unidades SAN.

    
por 15.10.2013 / 06:07
1

É provavelmente o seu antivírus / antimalware que consome toda a memória e depois falha o sistema.

O próprio Windows não tem problema ao excluir um grande número de arquivos, embora certamente seja mais lento que uma operação semelhante na maioria dos sistemas de arquivos não-Microsoft.

    
por 25.04.2012 / 05:31
1

Tentando várias abordagens para excluir mais de 10 milhões de arquivos de log de fusão, notei que cerca de 30 mil arquivos em média poderiam ser excluídos em um período de 10 minutos. Isso levaria cerca de 55 horas para os 10 milhões de arquivos ...

Usando o script abaixo, a taxa de exclusão aumentou em ~ 75%. Listas de arquivos são criadas e executadas por processos simultâneos, aumentando as operações de disco (mas não linearmente). Eu estou mostrando 4 garfos, mas dois podem ser suficientes.

Há uma opção para usar o PowerShell, que reduz significativamente o tempo necessário para preparar as listas.

BTW, testei usando duas operações dir del, permitindo colisões, mas não houve redução perceptível no tempo de exclusão geral em comparação com uma única operação del. E embora possa não ser desejável criar listas de exclusão, o tempo economizado valeu a 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
    
por 21.03.2015 / 23:32
1

Tente isso e modifique conforme necessário ..

É um script testado no Win2003 baseado na Explicação Técnica da Synetech e Análise respondida em 15 de outubro às 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%"

Testrun .. Há pasta como A1 para A4, B1 para B4 e C1 para C4 aninhados de forma 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>

Eu não posso comentar (o site reclama da reputação da minha), então eu adiciono meu comentário aqui ..

A solução da Bjv cria filelists temporárias usuless. E depois reitera-os pela segunda vez para fazer o trabalho real. link

O roteiro original da Synetech não funcionou para mim. link

@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>
    
por 02.12.2015 / 11:19
1

Eu tive problemas semelhantes há pouco tempo com apenas 10 milhões de arquivos, mas em um servidor 2003, para excluir os arquivos, usei um servidor / cliente FTP e deixei o cliente excluindo os arquivos e pastas. É uma solução lenta, mas funciona perfeitamente.

Provavelmente você terá um segundo problema com a MFT em NTFS que não tem solução, a MFT é uma matriz que no win 2003 (não tenho certeza se a Microsoft tem uma solução após win 2003) está armazenando todos os arquivos em um forma incremental assim com trilhões de arquivos o tamanho vai ficar louco, no meu caso a MFT teve 17 milhões de registros e o tamanho da MFT ficou em torno de 19GB com apenas 45.000 arquivos, testei em outros sistemas e parece por 1 milhão de registros a MFT será de cerca de 1 GB.

Você pode verificar o status da MFT com este comando:

defrag C: /a /v
  • C: - letra de unidade
  • /a - analisar
  • /v - verbose

Outra solução complicada, já que não há ferramenta que possa encolher a MFT, as ferramentas apenas preenchem com 0 o nome dos arquivos e propriedades mas nada mais, mas você pode usar o conversor VMware ou outro tipo de P2V e criar um virtual máquina baseada no seu servidor, dessa forma você vai consertar todos os problemas relacionados à MFT, nunca testei a conversão do V2P, agora estou trabalhando apenas em ambientes virtuais, mas vi muitas informações sobre isso na internet.

Esse win 2003 está funcionando perfeitamente agora, o tamanho da MFT é de 40MB e está tudo bem, se você quiser, posso falar mais sobre backups, defrags ou outras tarefas relacionadas a milhões de arquivos minúsculos.

    
por 09.10.2013 / 11:55
0

Por esta resposta no StackOverflow usa uma combinação de del e rmdir :

del /f/s/q foldername > nul
rmdir /s/q foldername
    
por 24.04.2012 / 15:20
0

Como a exclusão de todos os arquivos de uma vez usa muita memória, você precisa excluí-los um de cada vez, mas com o processo automatizado. Esse tipo de coisa é muito mais fácil de fazer em um shell estilo Unix, então vamos usar o Cygwin. O comando a seguir gera uma lista de arquivos comuns, transforma essa lista em uma sequência de comandos rm e, em seguida, alimenta o script resultante para um shell.

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

O script está sendo executado mesmo quando está sendo gerado, e não há loops, então o shell não precisa criar (esperançosamente) grandes arquivos temporários. Certamente vai demorar um pouco, já que o roteiro tem milhões de linhas. Você pode ter que ajustar o comando rm (talvez eu devesse ter usado -f ? Mas você entende seus arquivos melhor que eu) para fazê-lo funcionar.

Agora você não tem mais nada além de diretórios. Aqui é onde as coisas ficam mais perigosas. Talvez você tenha excluído arquivos suficientes para que você possa fazer rm -rf sem ficar sem memória (e provavelmente será mais rápido que outro script). Caso contrário, podemos adaptar esta resposta do Stackoverflow :

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

Novamente, ajustes podem ser necessários, desta vez com sort , para evitar a criação de arquivos temporários enormes.

    
por 07.09.2012 / 07:13
0

Um problema que você pode estar enfrentando é que o diretório não é compactado quando você exclui um arquivo / pasta, portanto, se você tiver uma pasta com 1 milhão de arquivos e excluir os primeiros 500k deles. Há uma tonelada de blocos no início do seu diretório, que são para todas as intenções em branco.

MAS, o explorador e um prompt de comando ainda precisam examinar esses blocos apenas para o caso de haver um arquivo lá. Algo que pode ajudar é "mover" uma pasta de algum lugar da árvore para uma nova pasta fora da base da unidade e, em seguida, excluir essa nova pasta. Mover a pasta moverá apenas o ponteiro para a pasta, de modo que ela deva ir rapidamente e não mover todos os arquivos sob ela para um novo espaço na unidade.

Outra coisa que você pode tentar é usar uma ferramenta de terceiros como "PerfectDisk" para compactar pastas depois de excluir vários arquivos.

    
por 13.02.2014 / 22:49
0

Eu encontrei o mesmo problema há algum tempo. Eu escrevi um pequeno utilitário que faz exatamente isso: excluir recursivamente um diretório. Ele não irá enumerar os arquivos e não consumirá muita memória (O (n + m) no máximo com n = profundidade máxima do diretório e m = número máximo de arquivos / diretórios em um dos subdiretórios). Ele pode manipular longos caminhos de arquivo (> 256 caracteres). Eu adoraria receber feedback se você puder resolver seu problema com isso.

Você pode encontrá-lo aqui: link (executável na pasta de lançamentos)

    
por 15.11.2016 / 15:15