Le programme C# estime la taille du dossier

Présentation

Dans cet article, nous découvrirons le programme C# pour estimer la taille des dossiers. Sur nos ordinateurs, nous stockons les fichiers dans des répertoires appelés dossiers. Nous verrons également comment estimer la taille des dossiers présents dans les fichiers. Le simple calcul de la taille du fichier ne suffit pas pour atteindre nos objectifs. Au lieu de cela, nous devons également calculer la taille des dossiers et des sous-dossiers.

L'article suivant explique comment calculer la taille du dossier en trois parties. La première partie que nous devons connaître est la méthode GetFolderSize, qui nous donnera la taille du dossier. La deuxième partie est la méthode FormatBytes, qui convertit la taille dans un format lisible par l'homme. Nous examinerons également brièvement différentes approches, qui seront cruciales pour le développement ultérieur de cet article.

Méthode

Nous apprendrons cinq méthodes que nous utiliserons dans le code pour calculer la taille d'un dossier.

• DirectoryInfo(dir_path) - Cette méthode prend un chemin de répertoire comme paramètre d'entrée et renvoie ses informations, telles que des informations sur ses fichiers, sous-dossiers et sous-répertoires.

• GetFiles() − Il renvoie les noms de tous les fichiers dans un seul répertoire.

• Length− Il renvoie la taille du fichier en octets.

• GetDirectories() − Cette méthode fonctionnera mieux dans notre code car elle renvoie tous les dossiers, sous-dossiers et sous-répertoires d'un seul fichier.

En plus de ces méthodes qui seront utilisées directement dans notre code, il existe une autre méthode importante considérant la console de sortie.

• FormatBytes() − La taille supprimée par la méthode length est en octets, elle n'est pas dans un format lisible par l'homme, donc pour la convertir au format de chaîne correct, nous devons la convertir en utilisant la méthode FormatBytes . La méthode prend des octets en entrée, les convertit en Mo ou Ko selon les besoins, puis arrondit à deux décimales et les convertit en chaîne.

Nous examinerons également le fonctionnement de la classe DirectoryInfo et son utilisation dans le code.

Il permet d'effectuer diverses opérations sur des fichiers ou des répertoires. On peut utiliser cette classe pour créer, déplacer et supprimer des fichiers. Il se trouve sous l’espace de noms System.Io. Il fournit même des méthodes pour travailler avec des fichiers.

Algorithme

Étape 1 −Nous devons d'abord mettre tous les fichiers au même endroit. Ici, nous stockons tous les fichiers dans la variable all files.

Étape 2 − Nous allons maintenant passer à tous les fichiers en parcourant la boucle et en calculant la longueur de chaque fichier via la méthode Longueur.

Étape 3 − Nous devons maintenant nous assurer qu'aucun sous-répertoire, sous-dossier et dossier présent dans le fichier n'est laissé de côté.

Étape 4 −Nous nous déplaçons récursivement vers chaque fichier et vérifions s'il contient des sous-répertoires, des sous-dossiers ou des dossiers.

Étape 5−Nous allons maintenant calculer la longueur de chaque fichier présent et le stocker dans la variable de taille totale du dossier.

Étape 6 − Nous devons maintenant nous assurer d'utiliser la méthode format bytes afin de convertir la réponse finale dans un format lisible par l'homme, en la convertissant de la taille en octets au format chaîne.

Étape 7 −Enfin, nous pouvons utiliser la fonction console pour imprimer la réponse.

Exemple

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]}";
}

Sortie

Total folder size in bytes:850757

Complexité temporelle

Dans le code donné ci-dessus, nous voyons que la seule boucle sur laquelle nous parcourons est la boucle récursive. Dans cette boucle récursive, nous voyons que nous itérons simplement jusqu'à atteindre tous les sous-dossiers, fichiers, répertoires, sous-répertoires et dossiers. La complexité temporelle est donc O (taille du fichier). En dehors de cela, toutes les autres méthodes ne nécessitent qu’une complexité temporelle constante. Cela constitue une complexité temporelle de O(1) en notation Big-O. La complexité temporelle finale correspond donc simplement à la taille totale du dossier.

Conclusion

Dans cet article, nous avons expliqué en détail comment calculer la taille d'un dossier. Nous découvrons les différentes méthodes et classes utilisées dans notre code. Nous avons également appris que nous ne pouvons pas tirer des conclusions simplement en comptant la taille des fichiers. Nous devons également nous assurer de calculer la taille de tous les dossiers, répertoires, sous-répertoires et sous-dossiers. Nous avons également examiné l'algorithme du code, le code lui-même et la complexité temporelle. Nous espérons que cet article vous a été utile pour améliorer vos connaissances de C#.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!