Das C#-Programm schätzt die Ordnergröße

Einführung

In diesem Artikel lernen wir das C#-Programm zum Schätzen der Ordnergröße kennen. Auf unseren Computern speichern wir Dateien in Verzeichnissen, die Ordner genannt werden. Wir werden auch sehen, wie wir die Größe der in den Dateien vorhandenen Ordner abschätzen können. Die bloße Berechnung der Dateigröße reicht nicht aus, um unsere Ziele zu erreichen. Stattdessen müssen wir auch die Größe von Ordnern und Unterordnern berechnen.

Der folgende Artikel erklärt in drei Teilen, wie man die Ordnergröße berechnet. Der erste Teil, den wir kennen müssen, ist die GetFolderSize-Methode, die uns die Größe des Ordners angibt. Der zweite Teil ist die FormatBytes-Methode, die die Größe in ein für Menschen lesbares Format umwandelt. Wir werden auch kurz auf verschiedene Ansätze eingehen, die für die weitere Entwicklung dieses Artikels von entscheidender Bedeutung sein werden.

Methode

Wir lernen fünf Methoden kennen, die wir im Code verwenden, um die Größe eines Ordners zu berechnen.

• DirectoryInfo(dir_path) – Diese Methode verwendet einen Verzeichnispfad als Eingabeparameter und gibt seine Informationen zurück, z. B. Informationen zu seinen Dateien, Unterordnern und Unterverzeichnissen.

• GetFiles() − Gibt die Namen aller Dateien in einem einzelnen Verzeichnis zurück.

• Length− Gibt die Größe der Datei in Bytes zurück.

• GetDirectories() − Diese Methode funktioniert in unserem Code am besten, da sie alle Ordner, Unterordner und Unterverzeichnisse für eine einzelne Datei zurückgibt.

Zusätzlich zu diesen Methoden, die direkt in unserem Code verwendet werden, gibt es eine weitere wichtige Methode, die die Ausgabekonsole berücksichtigt.

• FormatBytes() − Die von der Längenmethode ermittelte Größe ist in Bytes angegeben und liegt nicht in einem für Menschen lesbaren Format vor. Um sie also in das richtige Zeichenfolgenformat zu konvertieren, müssen wir sie mit der FormatBytes-Methode konvertieren . Die Methode verwendet Bytes als Eingabe, wandelt sie je nach Bedarf in MB oder KB um, rundet sie dann auf zwei Dezimalstellen und wandelt sie in eine Zeichenfolge um.

Wir werden uns auch mit der Funktionsweise der DirectoryInfo-Klasse und ihrer Verwendung im Code befassen.

Es ermöglicht die Durchführung verschiedener Vorgänge an Dateien oder Verzeichnissen. Mit dieser Klasse können Dateien erstellt, verschoben und gelöscht werden. Es befindet sich unter dem System.Io-Namespace. Es bietet sogar Methoden zum Arbeiten mit Dateien.

Algorithmus

Schritt 1 −Wir müssen zunächst alle Dateien an einem Ort ablegen. Hier speichern wir alle Dateien in der Variablen „Alle Dateien“.

Schritt 2 − Jetzt gehen wir zu allen Dateien, indem wir die Schleife durchlaufen und die Länge jeder Datei mithilfe der Längenmethode berechnen.

Schritt 3 − Jetzt müssen wir sicherstellen, dass keine in der Datei vorhandenen Unterverzeichnisse, Unterordner und Ordner zurückbleiben.

Schritt 4 −Wir bewegen uns rekursiv zu jeder Datei und prüfen, ob sie Unterverzeichnisse, Unterordner oder Ordner enthält.

Schritt 5−Wir berechnen nun die Länge jeder darin enthaltenen Datei und speichern sie in der Variable „Gesamtordnergröße“.

Schritt 6 − Jetzt müssen wir sicherstellen, dass wir die Formatbyte-Methode verwenden, um die endgültige Antwort in ein für Menschen lesbares Format umzuwandeln, indem wir sie von der Bytegröße in das String-Format umwandeln.

Schritt 7 −Abschließend können wir die Konsolenfunktion verwenden, um die Antwort auszudrucken.

Beispiel

using System;
using System.IO;
Class Tutorials_point{

   // Driver code
   static public void Main() {

      DirectoryInfo folder = new DirectoryInfo("D://d2c articles");
      
      //Here we are getting the complete folder information.
      
      //This is a class that is used to get complete information about directories.
      long totalFolderSize = folderSize(folder);
      
      //here folderSize is called and we are storing the answer
      
      // in the totalFolderSize variable.
      long ans= FormatBytes(totalFolderSize);
      
      //here we are formatting the bytes size into a readable format by
      
      //calling the FormatBytes function.
      Console.WriteLine("Total folder size in bytes: " + ans);
      
      //final ans is printed.
   }
   static long folderSize(DirectoryInfo folder) {
      long totalSizeOfDir = 0;

      // Get all files into the directory
      FileInfo[] allFiles = folder.GetFiles();

      // Loop through every file and get the size of it
      foreach (FileInfo file in allFiles) {
         totalSizeOfDir += file.Length;
         
         // we are calculating the length here.
      }

      DirectoryInfo[] subFolders = folder.GetDirectories();
      
      //here we are finding if there are any subfolders or directories present inside a file.
      foreach (DirectoryInfo dir in subFolders) {
         totalSizeOfDir += folderSize(dir);
         
         //here we are recursively calling to check all the subfolders.
      }
      return totalSizeOfDir;
      
      // we return the total size here.
   }
}
public static string FormatBytes(long bytes) {
   /*This method is basically used to determine the size of the file. It determines first whether we have to complete in bytes or KB or MB or GB. If the size is between 1KB and 1MB, then we will calculate the size in KB. Similarly, if it is between MB and GB, then we will calculate it in MB.*/
   string[] sizes = { "bytes", "KB", "MB", "GB", "TB" };
   
   //here we are storing all sizes in sizes string.
   int order = 0;
   
   // we have initialized the order with zero so that it does not give us some garbage value in return.
   while (bytes >= 1024 && order < sizes.Length - 1) {
      order++;
      bytes /= 1024;
   }
   return $"{bytes:0.##} {sizes[order]}";
}

Ausgabe

Total folder size in bytes:850757

Zeitliche Komplexität

Im oben angegebenen Code sehen wir, dass die einzige Schleife, über die wir iterieren, die rekursive Schleife ist. In dieser rekursiven Schleife sehen wir, dass wir einfach iterieren, bis wir alle Unterordner, Dateien, Verzeichnisse, Unterverzeichnisse und Ordner erreicht haben. Die zeitliche Komplexität beträgt also O (Dateigröße). Abgesehen davon benötigen alle anderen Methoden nur eine konstante Zeitkomplexität. Dies stellt eine zeitliche Komplexität von O(1) in der Big-O-Notation dar. Die endgültige Zeitkomplexität ist also nur die Gesamtgröße des Ordners.

Fazit

In diesem Artikel haben wir ausführlich besprochen, wie man die Größe eines Ordners berechnet. Wir lernen die verschiedenen Methoden und Klassen kennen, die in unserem Code verwendet werden. Wir haben auch gelernt, dass wir allein durch das Zählen der Dateigrößen keine Schlussfolgerungen ziehen können. Wir müssen auch sicherstellen, dass die Größe aller Ordner, Verzeichnisse, Unterverzeichnisse und Unterordner berechnet wird. Wir haben uns auch den Algorithmus des Codes, den Code selbst und die zeitliche Komplexität angesehen. Wir hoffen, dass dieser Artikel Ihnen dabei geholfen hat, Ihre C#-Kenntnisse zu erweitern.

Das obige ist der detaillierte Inhalt vonDas C#-Programm schätzt die Ordnergröße. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!