Feedback

C# - Dateien und Ordner rekursiv löschen

Veröffentlicht von am 23.11.2007
(2 Bewertungen)
Mit dieser Klasse können Dateien und Ordner rekursiv gelöscht werden. Die Methode wird nicht abgebrochen, wenn eine Datei nicht gelöscht werden kann (z.B: index.dat), sondern macht mit den nächsten Dateien weiter. Dadurch sind in dem Verzeichnisbaum nur noch nicht löschbare Dateien und Verzeichnisse vorhanden.

Die Methode System.IO.Directory.Delete("Path",true) würde auf eine Exception laufen und abbrechen. Dateien und Verzeichnisse, die eigentlich gelöscht werden könnten, bleiben übrig.
GFU-Schulungen  [Anzeige]

ASP.NET Core und Angular Komplett für .NET-Entwickler

Sie  lernen in drei (3) Tagen wie man mit  ASP.NET Core und den Technologien  MVC, Entity Framework, WebAPI und  Razor professionelle sowie moderne  Web-Anwendungsarchitekturen aufbaut.  Die Schulung ist der perfekte  Einstieg um insbesondere datengetriebene  und präsentationsorientierte  Applikationen auf Basis der robusten und  skalierbaren ASP.NET Core  Plattform zu erstellen. Nach der Veranstaltung kennen Sie die Konzepte von Angular und können Angular in neue und bestehende ASP.NET-Anwendungen einsetzen.

C# Komplett

Sie kennen sich in objektorientierter Programmierung aus. Sie schreiben C++ oder Java? Und nun stehen Sie vor der Aufgabe, in C# Anwendungen zu erstellen. Das C# Komplett-Seminar verschafft Ihnen umfassende Programmierkenntnisse in dieser Sprache. Nach der Schulung entwickeln Sie selbständig Anwendungen mit C#. Sie kennen die Datentypen und Klassenbibliotheken der objektorientierten Programmiersprache C#. Der Komplettkurs setzt bei den Grundlagen von C# ein. Sie arbeiten mit Variablen und konvertieren Typen. Multithreading, Delegates, Generics sind nach dem Seminar für Sie kein Geheimnis mehr.

using System;
using System.Collections.Generic;
using System.Text;


namespace Helper
{
    public class FileSystem
    {
        private static string _operationDirNotExist = "Can not find the directory";
        private static string _operationDirNotEmpty = "Directory is not empty"; 
        private static string _operationSuccess = "success";
        private static string _operationFailed = "failed";

        public static void DeleteAllSubfolders(string directoryPath)
        {
            //find files in the current directory an delete them
            foreach (string fileName in System.IO.Directory.GetFiles(directoryPath))
            {
                try
                {
                    System.IO.File.Delete(fileName);
                }
                catch 
                {
                    //Some files produce an exception if they cannot be deleted
                    //throw Exception ex; 
                }
            }
            //find subdirectorys in the current directory an delete them recursiv
            foreach (string directoryName in System.IO.Directory.GetDirectories(directoryPath))
            {
                DeleteAllSubfolders(directoryName);
                try
                {
                    //If no undeletable files are present the recursive search will be killed
                    System.IO.Directory.Delete(directoryName, true); 
                }
                catch 
                { 
                    //throw Exception ex; 
                }
            }    
        }

        public static string DeleteDirectory(string directoryPath, bool recursiv, bool deleteFiles)
        {
            string result = _operationFailed;
            if (System.IO.Directory.Exists(directoryPath))
            {
                if (recursiv == false && deleteFiles == false)
                {
                    System.IO.Directory.Delete(directoryPath, false);

                    if (System.IO.Directory.Exists(directoryPath))
                    {
                        result = _operationDirNotEmpty;
                    }
                    else
                    {
                        result = _operationSuccess;
                    }
                }

                if(recursiv == true && deleteFiles == false)
                {
                    System.IO.Directory.Delete(directoryPath, true);

                    if (System.IO.Directory.Exists(directoryPath))
                    {
                        result = _operationDirNotEmpty;
                    }
                    else
                    {
                        result = _operationSuccess;
                    }
                }

                if (recursiv == true && deleteFiles == true)
                {
                    System.IO.DirectoryInfo dirInfo = new System.IO.DirectoryInfo(directoryPath);

                    DeleteAllSubfolders(directoryPath);

                    System.IO.Directory.Delete(directoryPath, true);

                    if (System.IO.Directory.Exists(directoryPath))
                    {
                        result = _operationDirNotEmpty;
                    }
                    else
                    {
                        result = _operationSuccess;
                    }
                }

                if (recursiv == false && deleteFiles == true)
                {

                    //find files in the current directory and delete them
                    foreach (string fileName in System.IO.Directory.GetFiles(directoryPath))
                    {
                        try
                        {
                            System.IO.File.Delete(fileName);
                        }
                        catch
                        {
                            //Some files produce an exception if they cannot be deleted
                            //throw Exception ex;
                        }
                    }

                    System.IO.Directory.Delete(directoryPath, false);

                    if (System.IO.Directory.Exists(directoryPath))
                    {
                        result = _operationDirNotEmpty;
                    }
                    else
                    {
                        result = _operationSuccess;
                    }
                }

            }
            else
            {
                result = _operationDirNotExist;
            }
            return result;
        }
    }
}

3 Kommentare zum Snippet

Tim Hartwig schrieb am 25.11.2007:
Hier Frage ich mich allerdings warum so viel aufwand wenn man das alles mit nur einer Zeile Code machen kann nämlich mit dem Befehl "System.IO.Directory.Delete" und als zweiten Paramter True für rekursives löschen. Dann wird der komplette Ordner gelöscht mit allen Dateien und Unterordnern.
freak schrieb am 26.11.2007:
Hallo Herr Hartwig,

sie haben natürlich Recht, aber wenn nicht löschbare Dateien in diesem Verzeichnis liegen, dann bricht die Methode "System.IO.Directory.Delete" mit einer Exception ab und Dateien, die eigentlich gelöscht werden könnten, bleiben liegen. Ich habe die Beschreibung der Methode angepasst.
m-s schrieb am 11.02.2011:
Um die schreibgeschützten Dateien doch zu löschen, habe ich Deine Schnipsel wie folgt verändert. Ob das gut ist weiß ich nicht aber bei mir funktioniert es.
            //find files in the current directory an delete them
foreach (string fileName in System.IO.Directory.GetFiles(directoryPath))
{
try
{
System.IO.File.Delete(fileName);
}
// Falls Datei schreibgeschützt, wird das Attribut geändert und die Datei noch mal versucht zu löschen
catch (UnauthorizedAccessException)
{
try
{
System.IO.File.SetAttributes(fileName, FileAttributes.Normal);
System.IO.File.Delete(fileName);
}
catch
{
}
}
catch
{
//Some files produce an exception if they cannot be deleted
//throw Exception ex;
}
}
 

Logge dich ein, um hier zu kommentieren!