Utilizzando C #, come posso eliminare tutti i file e le cartelle da una directory, ma mantenere comunque la directory principale?
Utilizzando C #, come posso eliminare tutti i file e le cartelle da una directory, ma mantenere comunque la directory principale?
Risposte:
System.IO.DirectoryInfo di = new DirectoryInfo("YourPath");
foreach (FileInfo file in di.GetFiles())
{
file.Delete();
}
foreach (DirectoryInfo dir in di.GetDirectories())
{
dir.Delete(true);
}
Se la tua directory può contenere molti file, EnumerateFiles()
è più efficiente di GetFiles()
, perché quando lo usi EnumerateFiles()
puoi iniziare a enumerarlo prima che venga restituita l'intera raccolta, al contrario di GetFiles()
dove devi caricare l'intera raccolta in memoria prima di iniziare a enumerarla. Vedi questa citazione qui :
Pertanto, quando si lavora con molti file e directory, EnumerateFiles () può essere più efficiente.
Lo stesso vale per EnumerateDirectories()
e GetDirectories()
. Quindi il codice sarebbe:
foreach (FileInfo file in di.EnumerateFiles())
{
file.Delete();
}
foreach (DirectoryInfo dir in di.EnumerateDirectories())
{
dir.Delete(true);
}
Ai fini di questa domanda, non c'è davvero alcun motivo per usare GetFiles()
e GetDirectories()
.
Directory.Delete(path, true)
si occuperà di tutto :)
file.Delete()
.
Sì, questo è il modo corretto di farlo. Se stai cercando di darti una funzione "Clean" (o, come preferirei chiamarla, funzione "Empty"), puoi creare un metodo di estensione.
public static void Empty(this System.IO.DirectoryInfo directory)
{
foreach(System.IO.FileInfo file in directory.GetFiles()) file.Delete();
foreach(System.IO.DirectoryInfo subDirectory in directory.GetDirectories()) subDirectory.Delete(true);
}
Questo ti permetterà quindi di fare qualcosa come ..
System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(@"C:\...");
directory.Empty();
Empty
esiste già in C #, per string
. Se vedessi qualcos'altro chiamato Empty
sarei sorpreso se modificasse l'oggetto (o il filesystem) invece di darmi un messaggio bool
che dice se è vuoto o no. Per questo motivo, vorrei andare con il nome Clean
.
Is
(cioè IsEmpty
piuttosto che Empty
).
Il seguente codice cancellerà la cartella in modo ricorsivo:
private void clearFolder(string FolderName)
{
DirectoryInfo dir = new DirectoryInfo(FolderName);
foreach(FileInfo fi in dir.GetFiles())
{
fi.Delete();
}
foreach (DirectoryInfo di in dir.GetDirectories())
{
clearFolder(di.FullName);
di.Delete();
}
}
new System.IO.DirectoryInfo(@"C:\Temp").Delete(true);
//Or
System.IO.Directory.Delete(@"C:\Temp", true);
Delete
verrà lanciato se la directory non esiste, quindi sarebbe più sicuro fare Directory.Exists
prima un controllo.
Directory.Exists
non è abbastanza; dopo il controllo, un altro thread potrebbe aver rinominato o rimosso la directory. È più sicuro try-catch
.
Directory.Create
perché Directory.Delete
purtroppo il ricorsivo non è garantito per essere sincrono ..
Possiamo anche mostrare amore per LINQ :
using System.IO;
using System.Linq;
…
var directory = Directory.GetParent(TestContext.TestDir);
directory.EnumerateFiles()
.ToList().ForEach(f => f.Delete());
directory.EnumerateDirectories()
.ToList().ForEach(d => d.Delete(true));
Nota che la mia soluzione qui non è performante, perché sto usando Get*().ToList().ForEach(...)
quale genera lo stesso IEnumerable
due volte. Uso un metodo di estensione per evitare questo problema:
using System.IO;
using System.Linq;
…
var directory = Directory.GetParent(TestContext.TestDir);
directory.EnumerateFiles()
.ForEachInEnumerable(f => f.Delete());
directory.EnumerateDirectories()
.ForEachInEnumerable(d => d.Delete(true));
Questo è il metodo di estensione:
/// <summary>
/// Extensions for <see cref="System.Collections.Generic.IEnumerable"/>.
/// </summary>
public static class IEnumerableOfTExtensions
{
/// <summary>
/// Performs the <see cref="System.Action"/>
/// on each item in the enumerable object.
/// </summary>
/// <typeparam name="TEnumerable">The type of the enumerable.</typeparam>
/// <param name="enumerable">The enumerable.</param>
/// <param name="action">The action.</param>
/// <remarks>
/// “I am philosophically opposed to providing such a method, for two reasons.
/// …The first reason is that doing so violates the functional programming principles
/// that all the other sequence operators are based upon. Clearly the sole purpose of a call
/// to this method is to cause side effects.”
/// —Eric Lippert, “foreach” vs “ForEach” [http://blogs.msdn.com/b/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx]
/// </remarks>
public static void ForEachInEnumerable<TEnumerable>(this IEnumerable<TEnumerable> enumerable, Action<TEnumerable> action)
{
foreach (var item in enumerable)
{
action(item);
}
}
}
foreach (var dir in info.GetDirectories("*", SearchOption.AllDirectories).OrderByDescending(dir => dir.FullName.Length)) dir.Delete();
potrebbe essere utile.
directory.EnumerateFiles()
e directory.EnumerateDirectories()
invece dei directory.Get*()
metodi.
IEnumerable<T>.ForEach()
estensione ha un commento XML sommario, "Violazione! Violazione! Impuro!".
Il modo più semplice:
Directory.Delete(path,true);
Directory.CreateDirectory(path);
Tenere presente che ciò potrebbe cancellare alcune autorizzazioni per la cartella.
private void ClearFolder(string FolderName)
{
DirectoryInfo dir = new DirectoryInfo(FolderName);
foreach(FileInfo fi in dir.GetFiles())
{
try
{
fi.Delete();
}
catch(Exception) { } // Ignore all exceptions
}
foreach(DirectoryInfo di in dir.GetDirectories())
{
ClearFolder(di.FullName);
try
{
di.Delete();
}
catch(Exception) { } // Ignore all exceptions
}
}
Se sai che non ci sono sottocartelle, qualcosa del genere potrebbe essere la più semplice:
Directory.GetFiles(folderName).ForEach(File.Delete)
Ogni metodo che ho provato, hanno fallito ad un certo punto con errori System.IO. Il seguente metodo funziona sicuramente, anche se la cartella è vuota o no, sola lettura o no, ecc.
ProcessStartInfo Info = new ProcessStartInfo();
Info.Arguments = "/C rd /s /q \"C:\\MyFolder"";
Info.WindowStyle = ProcessWindowStyle.Hidden;
Info.CreateNoWindow = true;
Info.FileName = "cmd.exe";
Process.Start(Info);
Ecco lo strumento con cui ho finito dopo aver letto tutti i post. Lo fa
Ha a che fare con
Non utilizza Directory.Delete perché il processo viene interrotto in caso di eccezione.
/// <summary>
/// Attempt to empty the folder. Return false if it fails (locked files...).
/// </summary>
/// <param name="pathName"></param>
/// <returns>true on success</returns>
public static bool EmptyFolder(string pathName)
{
bool errors = false;
DirectoryInfo dir = new DirectoryInfo(pathName);
foreach (FileInfo fi in dir.EnumerateFiles())
{
try
{
fi.IsReadOnly = false;
fi.Delete();
//Wait for the item to disapear (avoid 'dir not empty' error).
while (fi.Exists)
{
System.Threading.Thread.Sleep(10);
fi.Refresh();
}
}
catch (IOException e)
{
Debug.WriteLine(e.Message);
errors = true;
}
}
foreach (DirectoryInfo di in dir.EnumerateDirectories())
{
try
{
EmptyFolder(di.FullName);
di.Delete();
//Wait for the item to disapear (avoid 'dir not empty' error).
while (di.Exists)
{
System.Threading.Thread.Sleep(10);
di.Refresh();
}
}
catch (IOException e)
{
Debug.WriteLine(e.Message);
errors = true;
}
}
return !errors;
}
Il seguente codice pulirà la directory, ma lascerà lì la directory root (ricorsiva).
Action<string> DelPath = null;
DelPath = p =>
{
Directory.EnumerateFiles(p).ToList().ForEach(File.Delete);
Directory.EnumerateDirectories(p).ToList().ForEach(DelPath);
Directory.EnumerateDirectories(p).ToList().ForEach(Directory.Delete);
};
DelPath(path);
ero solito
Directory.GetFiles(picturePath).ToList().ForEach(File.Delete);
per eliminare la vecchia immagine e non ho bisogno di alcun oggetto in questa cartella
L'uso di soli metodi statici con File e Directory anziché FileInfo e DirectoryInfo funzionerà più velocemente. (vedi la risposta accettata in Qual è la differenza tra File e FileInfo in C #? ). Risposta mostrata come metodo di utilità.
public static void Empty(string directory)
{
foreach(string fileToDelete in System.IO.Directory.GetFiles(directory))
{
System.IO.File.Delete(fileToDelete);
}
foreach(string subDirectoryToDeleteToDelete in System.IO.Directory.GetDirectories(directory))
{
System.IO.Directory.Delete(subDirectoryToDeleteToDelete, true);
}
}
string directoryPath = "C:\Temp";
Directory.GetFiles(directoryPath).ToList().ForEach(File.Delete);
Directory.GetDirectories(directoryPath).ToList().ForEach(Directory.Delete);
In Windows 7, se l'hai appena creato manualmente con Esplora risorse, la struttura delle directory è simile a questa:
C:
\AAA
\BBB
\CCC
\DDD
Ed eseguendo il codice suggerito nella domanda originale per pulire la directory C: \ AAA, la riga di.Delete(true)
fallisce sempre con IOException "La directory non è vuota" quando si tenta di eliminare BBB. Probabilmente è a causa di qualche tipo di ritardo / memorizzazione nella cache in Esplora risorse.
Il seguente codice funziona in modo affidabile per me:
static void Main(string[] args)
{
DirectoryInfo di = new DirectoryInfo(@"c:\aaa");
CleanDirectory(di);
}
private static void CleanDirectory(DirectoryInfo di)
{
if (di == null)
return;
foreach (FileSystemInfo fsEntry in di.GetFileSystemInfos())
{
CleanDirectory(fsEntry as DirectoryInfo);
fsEntry.Delete();
}
WaitForDirectoryToBecomeEmpty(di);
}
private static void WaitForDirectoryToBecomeEmpty(DirectoryInfo di)
{
for (int i = 0; i < 5; i++)
{
if (di.GetFileSystemInfos().Length == 0)
return;
Console.WriteLine(di.FullName + i);
Thread.Sleep(50 * i);
}
}
Questa versione non utilizza chiamate ricorsive e risolve il problema di sola lettura.
public static void EmptyDirectory(string directory)
{
// First delete all the files, making sure they are not readonly
var stackA = new Stack<DirectoryInfo>();
stackA.Push(new DirectoryInfo(directory));
var stackB = new Stack<DirectoryInfo>();
while (stackA.Any())
{
var dir = stackA.Pop();
foreach (var file in dir.GetFiles())
{
file.IsReadOnly = false;
file.Delete();
}
foreach (var subDir in dir.GetDirectories())
{
stackA.Push(subDir);
stackB.Push(subDir);
}
}
// Then delete the sub directories depth first
while (stackB.Any())
{
stackB.Pop().Delete();
}
}
L'esempio seguente mostra come farlo. Crea prima alcune directory e un file, quindi le rimuove tramite Directory.Delete(topPath, true);
:
static void Main(string[] args)
{
string topPath = @"C:\NewDirectory";
string subPath = @"C:\NewDirectory\NewSubDirectory";
try
{
Directory.CreateDirectory(subPath);
using (StreamWriter writer = File.CreateText(subPath + @"\example.txt"))
{
writer.WriteLine("content added");
}
Directory.Delete(topPath, true);
bool directoryExists = Directory.Exists(topPath);
Console.WriteLine("top-level directory exists: " + directoryExists);
}
catch (Exception e)
{
Console.WriteLine("The process failed: {0}", e.Message);
}
}
È preso da https://msdn.microsoft.com/en-us/library/fxeahc5f(v=vs.110).aspx .
Non è il modo migliore per affrontare il problema sopra. Ma è alternativo ...
while (Directory.GetDirectories(dirpath).Length > 0)
{
//Delete all files in directory
while (Directory.GetFiles(Directory.GetDirectories(dirpath)[0]).Length > 0)
{
File.Delete(Directory.GetFiles(dirpath)[0]);
}
Directory.Delete(Directory.GetDirectories(dirpath)[0]);
}
DirectoryInfo Folder = new DirectoryInfo(Server.MapPath(path));
if (Folder .Exists)
{
foreach (FileInfo fl in Folder .GetFiles())
{
fl.Delete();
}
Folder .Delete();
}
questo mostrerà come eliminiamo la cartella e per controllarla usiamo la casella di testo
using System.IO;
namespace delete_the_folder
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Deletebt_Click(object sender, EventArgs e)
{
//the first you should write the folder place
if (Pathfolder.Text=="")
{
MessageBox.Show("ples write the path of the folder");
Pathfolder.Select();
//return;
}
FileAttributes attr = File.GetAttributes(@Pathfolder.Text);
if (attr.HasFlag(FileAttributes.Directory))
MessageBox.Show("Its a directory");
else
MessageBox.Show("Its a file");
string path = Pathfolder.Text;
FileInfo myfileinf = new FileInfo(path);
myfileinf.Delete();
}
}
}
using System.IO;
string[] filePaths = Directory.GetFiles(@"c:\MyDir\");
foreach (string filePath in filePaths)
File.Delete(filePath);
Chiama dalla rete principale
static void Main(string[] args)
{
string Filepathe =<Your path>
DeleteDirectory(System.IO.Directory.GetParent(Filepathe).FullName);
}
Aggiungi questo metodo
public static void DeleteDirectory(string path)
{
if (Directory.Exists(path))
{
//Delete all files from the Directory
foreach (string file in Directory.GetFiles(path))
{
File.Delete(file);
}
//Delete all child Directories
foreach (string directory in Directory.GetDirectories(path))
{
DeleteDirectory(directory);
}
//Delete a Directory
Directory.Delete(path);
}
}
Per eliminare la cartella, si tratta di un codice che utilizza la casella di testo e un pulsante using System.IO;
:
private void Deletebt_Click(object sender, EventArgs e)
{
System.IO.DirectoryInfo myDirInfo = new DirectoryInfo(@"" + delete.Text);
foreach (FileInfo file in myDirInfo.GetFiles())
{
file.Delete();
}
foreach (DirectoryInfo dir in myDirInfo.GetDirectories())
{
dir.Delete(true);
}
}
private void ClearDirectory(string path)
{
if (Directory.Exists(path))//if folder exists
{
Directory.Delete(path, true);//recursive delete (all subdirs, files)
}
Directory.CreateDirectory(path);//creates empty directory
}
Directory.CreateDirectory
IO.Directory.Delete(HttpContext.Current.Server.MapPath(path), True)
Non hai bisogno di altro