Lucrul cu directoarele

Pentru lucrul cu directoarele în spațiul de nume System.IO sunt destinate două clase: Directory și DirectoryInfo.

Clasa Directory

Clasa statică Directory oferă o serie de metode pentru gestionarea directoarelor. Unele dintre aceste metode sunt:

• CreateDirectory(path): creează un director la calea specificată path
• Delete(path): șterge directorul la calea specificată path
• Exists(path): determină dacă directorul există la calea specificată path. Dacă există, returnează true, dacă nu există, returnează false
• GetCurrentDirectory(): obține calea către folderul curent
• GetDirectories(path): obține lista subdirectoarelor din directorul path
• GetFiles(path): obține lista fișierelor din directorul path
• GetFileSystemEntries(path): obține lista subdirectoarelor și fișierelor din directorul path
• Move(sourceDirName, destDirName): mută directorul
• GetParent(path): obține directorul părinte
• GetLastWriteTime(path): returnează timpul ultimei modificări a directorului
• GetLastAccessTime(path): returnează timpul ultimei accesări a directorului
• GetCreationTime(path): returnează timpul creării directorului

Clasa DirectoryInfo

Această clasă oferă funcționalitate pentru crearea, ștergerea, mutarea și alte operațiuni cu directoare. În multe privințe este similară cu Directory, dar nu este statică.

Pentru a crea un obiect al clasei DirectoryInfo se folosește constructorul care primește ca parametru calea către director:

public DirectoryInfo (string path);

Principalele metode ale clasei DirectoryInfo:

• Create(): creează un director
• CreateSubdirectory(path): creează un subdirector la calea specificată path
• Delete(): șterge directorul
• GetDirectories(): obține lista subdirectoarelor din folder sub forma unui array de DirectoryInfo
• GetFiles(): obține lista fișierelor din folder sub forma unui array de FileInfo
• MoveTo(destDirName): mută directorul

Principalele proprietăți ale clasei DirectoryInfo:

• CreationTime: reprezintă timpul creării directorului
• LastAccessTime: reprezintă timpul ultimei accesări a directorului
• LastWriteTime: reprezintă timpul ultimei modificări a directorului
• Exists: determină dacă directorul există
• Parent: obține directorul părinte
• Root: obține directorul rădăcină
• Name: numele directorului
• FullName: calea completă către director

Directory sau DirectoryInfo

După cum se poate observa din funcționalitate, ambele clase oferă posibilități similare. Când și ce să folosești? Dacă trebuie să efectuezi una-două operațiuni cu un singur director, atunci este mai simplu să folosești clasa Directory. Dacă este necesar să executăm o serie de operațiuni cu același director, atunci este mai bine să folosim clasa DirectoryInfo.

De ce? Pentru că metodele clasei Directory efectuează verificări suplimentare de securitate, iar pentru clasa DirectoryInfo aceste verificări nu sunt întotdeauna necesare.

Exemplu pentru obținerea listei de fișiere și subdirectoare:

string dirName = "C:\\";
// dacă folderul există
if (Directory.Exists(dirName))
{
   Console.WriteLine("Subdirectoare:");
   string[] dirs = Directory.GetDirectories(dirName);
   foreach (string s in dirs)
   {
       Console.WriteLine(s);
   }
   Console.WriteLine();
   Console.WriteLine("Fișiere:");
   string[] files = Directory.GetFiles(dirName);
   foreach (string s in files)
   {
       Console.WriteLine(s);
   }
}

Atenție la utilizarea slash-urilor în numele fișierelor. Fie folosim slash dublu: "C:\\", fie unul singur, dar atunci punem semnul @ înaintea întregii căi: @"C:\Program Files"

Exemplu similar cu DirectoryInfo:

string dirName = "C:\\";

var directory = new DirectoryInfo(dirName);

if (directory.Exists)
{
   Console.WriteLine("Subdirectoare:");
   DirectoryInfo[] dirs = directory.GetDirectories();
   foreach (DirectoryInfo dir in dirs)
   {
       Console.WriteLine(dir.FullName);
   }
   Console.WriteLine();
   Console.WriteLine("Fișiere:");
   FileInfo[] files = directory.GetFiles();
   foreach (FileInfo file in files)
   {
       Console.WriteLine(file.FullName);
   }
}

Filtrarea folderelor și fișierelor

Metodele de obținere a folderelor și fișierelor permit efectuarea filtrării. Ca filtru, în aceste metode se transmite un șablon care poate conține două plaseholdere: * sau simbolul-asterisc (corespunde oricărui număr de caractere) și ? sau semnul de întrebare (corespunde unui singur caracter).

De exemplu, să găsim toate folderele care încep cu "books":

// clasa Directory
string[] dirs = Directory.GetDirectories(dirName, "books*.");

// clasa DirectoryInfo
var directory = new DirectoryInfo(dirName);
DirectoryInfo[] dirs = directory.GetDirectories("books*.");

Sau să obținem toate fișierele cu extensia ".exe":

// clasa Directory
string[] files = Directory.GetFiles(dirName, "*.exe");

// clasa DirectoryInfo
var directory = new DirectoryInfo(dirName);
FileInfo[] files = directory.GetFiles("*.exe");

Crearea unui director

Clasa DirectoryInfo:

string path = @"C:\SomeDir";
string subpath = @"program\avalon";
DirectoryInfo dirInfo = new DirectoryInfo(path);
if (!dirInfo.Exists)
{
   dirInfo.Create();
}
dirInfo.CreateSubdirectory(subpath);

La început verificăm dacă directorul creat există, și dacă nu există, atunci îl creăm. În final, vom obține următoarea cale: "C:\SomeDir\program\avalon".

Exemplu similar cu clasa Directory:

string path = @"C:\SomeDir";
string subpath = @"program\avalon";
if (!Directory.Exists(path))
{
   Directory.CreateDirectory(path);
}
Directory.CreateDirectory($"{path}/{subpath}");

Obținerea informațiilor despre un director

string dirName = "C:\\Program Files";

DirectoryInfo dirInfo = new DirectoryInfo(dirName);

Console.WriteLine($"Numele directorului: {dirInfo.Name}");
Console.WriteLine($"Numele complet al directorului: {dirInfo.FullName}");
Console.WriteLine($"Timpul creării directorului: {dirInfo.CreationTime}");
Console.WriteLine($"Director rădăcină: {dirInfo.Root}");

Ștergerea unui director

Dacă aplicăm pur și simplu metoda Delete unui folder care nu este gol, ce conține fișiere sau subdirectoare, aplicația va genera o eroare. Prin urmare, trebuie să transmitem în metoda Delete un parametru suplimentar de tip boolean care indică faptul că folderul trebuie șters împreună cu tot conținutul. În plus, înainte de ștergere, ar trebui să verificăm existența folderului care urmează să fie șters, altfel aplicația va genera o excepție:

string dirName = @"C:\SomeDir";

DirectoryInfo dirInfo = new DirectoryInfo(dirName);
if (dirInfo.Exists)
{
   dirInfo.Delete(true);
   Console.WriteLine("Directorul a fost șters");
}
else
{
   Console.WriteLine("Directorul nu există");
}

Sau așa:

string dirName = @"C:\SomeDir";
if (Directory.Exists(dirName))
{
   Directory.Delete(dirName, true);
   Console.WriteLine("Directorul a fost șters");
}
else
{
   Console.WriteLine("Directorul nu există");
}

Mutarea unui director

La mutare, trebuie să ținem cont că noul director în care dorim să mutăm tot conținutul vechiului director nu trebuie să existe.

string oldPath = @"C:\SomeFolder";
string newPath = @"C:\SomeDir";
DirectoryInfo dirInfo = new DirectoryInfo(oldPath);
if (dirInfo.Exists && !Directory.Exists(newPath))
{
   dirInfo.MoveTo(newPath);
   // sau așa
   // Directory.Move(oldPath, newPath);
}

Mutarea unui director în cadrul aceluiași folder (ca în exemplul de mai sus) este, de fapt, similară cu redenumirea folderului.