Tworzenie i usuwanie plików

1. Wprowadzenie

Może się wydawać, że plik to prosta rzecz i stworzenie go jest bajecznie łatwe: wystarczy kliknąć prawym przyciskiem myszy (w Windows). Ale w prawdziwych projektach programowe tworzenie i usuwanie plików to klucz do automatyzacji i elastyczności. Na przykład:

• W edytorze tekstu użytkownik klika „Zapisz” — i twój kod tworzy nowy plik, w którym zapisze pracę autora.
• Serwis logowania zdarzeń automatycznie tworzy pliki logów przy starcie aplikacji.
• Archiwizer lub narzędzie do backupu regularnie tworzy tymczasowe pliki, a potem je usuwa.
• Aplikacja gry w C# robi autosave — tworzy lub nadpisuje plik save.
• I jeszcze ty (albo twój skrypt) automatycznie sprzątasz folder ze starych tymczasowych plików, żeby nie zaśmiecać dysku.

Umiejętność automatycznego tworzenia i usuwania plików to jedna z podstawowych zdolności nowoczesnego dewelopera .NET.

2. Szybkie operacje przez File

Tworzenie pliku

W C# plik można stworzyć na różne sposoby. Najszybszy i najprostszy sposób — użyć klasy statycznej File. Spróbujmy:

// Stwórzmy pusty plik "myfile.txt" w bieżącym katalogu
File.Create("myfile.txt").Close(); // FileStream trzeba zamknąć!
Console.WriteLine("Plik 'myfile.txt' utworzony.");

Ważna uwaga:
Metoda File.Create zwraca obiekt FileStream, który trzeba zamknąć (Close()), żeby system operacyjny nie narzekał, że plik jest „zajęty”. Bez tego zamknięcia niektóre inne operacje na tym samym pliku mogą niespodziewanie nie zadziałać. Klasyka: "Plik zajęty przez inny proces", choć tym „innym procesem” jest często nadal twój program, który nie zamknął strumienia.

Jeśli plik już istniał, File.Create go nadpisze (stary zostanie usunięty, nowy pusty powstanie w jego miejscu). Jeśli pliku nie było — pojawi się.

Po co pusty plik?

Najczęściej nowy plik potrzebny jest nie jako pusta skorupka, lecz żeby coś do niego zapisać. Do tego są wygodne metody:

File.WriteAllText("welcome.txt", "Privet, mir faylov!");

Polecenie utworzy plik, zapisze w nim linię i ładnie zamknie drzwi (plik), żeby nic złego się nie stało.

Sprawdzanie istnienia pliku

Zanim stworzysz nowy plik, warto sprawdzić, czy on już nie istnieje. W przeciwnym razie ryzykujesz przypadkowe skasowanie czegoś ważnego.

if (!File.Exists("important.txt"))
{
    File.WriteAllText("important.txt", "Sohranyaem vazhnuiu informatsiu.");
    Console.WriteLine("Plik utworzony.");
}
else
{
    Console.WriteLine("Taki plik już istnieje, można wymyślić coś innego!");
}

3. Przykład z życia: "Zapisujemy powitanie użytkownika"

Console.Write("Vvedite vashe imia: ");
string name = Console.ReadLine();

string filename = $"{name}_greeting.txt";
string message = $"Dobro pozhalovat', {name}!";

// Sprawdzamy, czy taki plik istnieje
if (!File.Exists(filename))
{
    File.WriteAllText(filename, message);
    Console.WriteLine($"Personalny plik privetstviia {filename} utworzon.");
}
else
{
    Console.WriteLine($"Plik {filename} już istnieje! Nadpisać? (y/n)");
    string answer = Console.ReadLine();
    if (answer?.ToLower() == "y")
    {
        File.WriteAllText(filename, message);
        Console.WriteLine($"Plik {filename} nadpisany.");
    }
    else
    {
        Console.WriteLine("Zostawiamy wszystko jak jest.");
    }
}

Co tu robimy:

• Sprawdzamy, czy plik istnieje (File.Exists).
• Jeśli go nie ma — tworzymy i zapisujemy tekst (File.WriteAllText).
• Jeśli jest — pytamy użytkownika, nadpisać czy nie.

4. Usuwanie pliku

Usuwanie plików w C# to niemalże hakerska czynność... ale bezpieczna! Tutaj też wszystko prosto:

Używamy File.Delete

File.Delete("myfile.txt");

Jeśli pliku nie ma — żadnej dramy! Po prostu nic się nie stanie (nie będzie błędu, jeśli ścieżka jest poprawna).

Pułapki dla początkujących

• Jeśli plik jest już otwarty przez twój program (albo kogoś innego), zostanie rzucony wyjątek.
• Jeśli ścieżka zawiera błąd — pojawi się ArgumentException.

Rekomendacja: zawsze sprawdzaj istnienie

if (File.Exists("victim.txt"))
{
    File.Delete("victim.txt");
    Console.WriteLine("Plik usunięty.");
}
else
{
    Console.WriteLine("Nie ma czego usuwać — taki plik nie znaleziono.");
}

5. Foldery i pliki: tworzymy strukturę plików

Tworzenie pliku w folderze

string folder = "Data";
Directory.CreateDirectory(folder); // jeśli folder nie istnieje — zostanie utworzony

string filename = Path.Combine(folder, "info.txt");
File.WriteAllText(filename, "Zdes' hranitsia sekretnoe poslanie!");

Ważne: Przy próbie stworzenia pliku w nieistniejącym folderze zostanie rzucony wyjątek. Dlatego najpierw wywołaj Directory.CreateDirectory(folder). Nie utworzy ona folderu ponownie, jeśli on już istnieje, więc wywołanie jest bezpieczne.

6. Praca na instancjach: FileInfo

Do „oldskulowych” i trochę bardziej zaawansowanych scenariuszy przyda się klasa FileInfo:

FileInfo fi = new FileInfo("example.txt");

// Stworzyć nowy plik (jak File.Create — tworzy pusty plik)
using (var fs = fi.Create())
{
    // można coś zapisać, jeśli chcesz
}

Console.WriteLine($"Plik 'example.txt' utworzony za pomocą FileInfo.");

Usuwanie przez FileInfo:

FileInfo fi = new FileInfo("oldfile.txt");
if (fi.Exists)
{
    fi.Delete();
    Console.WriteLine("Plik usunięty przez FileInfo.");
}

Zalety FileInfo

Jeśli planujesz nie tylko tworzyć/usuwać, ale często odwoływać się do właściwości pliku albo wykonywać na nim różne operacje, podejście z instancją daje wygodę (a czasami i korzyść wydajnościową).

7. Tworzymy i czyścimy "pliki techniczne"

Niech aplikacja zbiera tymczasowe pliki w folderze "temp_data", i chcemy usunąć wszystkie pliki w tym folderze, których nazwy zaczynają się od "temp_".

string tempFolder = "temp_data";
Directory.CreateDirectory(tempFolder);

for (int i = 1; i <= 5; i++)
{
    string tempFile = Path.Combine(tempFolder, $"temp_{i}.txt");
    File.WriteAllText(tempFile, $"Testovye dannye {i}");
}
Console.WriteLine("5 tymczasowych plikow utworzon.");


// Teraz usuniemy wszystkie temp_*.txt
foreach (string file in Directory.GetFiles(tempFolder, "temp_*.txt"))
{
    File.Delete(file);
    Console.WriteLine($"Usunięto plik: {file}");
}

Świetnie działa do automatycznego czyszczenia starych i tymczasowych plików.

8. Ważne szczegóły: wyjątki i bezpieczeństwo

Co może pójść nie tak:

• Brak praw do zapisu/usunięcia w folderze (np. C:\Windows)
• Plik już zajęty przez inny proces (albo przez twoją aplikację)
• Ścieżka zawiera niedozwolone znaki (np. *?<>)
• Plik został usunięty przez inny proces między twoim sprawdzeniem a usunięciem (tak, to się zdarza!)

Jak się zabezpieczyć

W produkcyjnym kodzie takie operacje zawsze warto owijać w blok try-catch:

try
{
    File.Delete("trickyfile.txt");
    Console.WriteLine("Plik usunięty.");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Brak uprawnień do usunięcia pliku.");
}
catch (IOException ex)
{
    Console.WriteLine("Plik może być zajęty przez inny proces.");
}
catch (Exception ex)
{
    Console.WriteLine($"Błąd: {ex.Message}");
}

9. Przydatne niuanse

Pliki, które warto mieć pod kontrolą

• Używaj Path.Combine do składania ścieżek. Dzięki temu nie będzie problemów z brakującymi lub dodatkowymi slashami, a twój kod będzie cross-platformowy.
• Sprawdzaj istnienie pliku przed tworzeniem/usuwaniem, jeśli nie chcesz niespodzianek.
• Owijać swój kod w try-catch, jeśli pracujesz w produkcji i szczególnie w aplikacji „wieloużytkownikowej”.
• Do częstych operacji na tym samym pliku używaj FileInfo, do jednorazowej operacji — File.
• Nie trzymaj plików otwartych dłużej niż trzeba. Masz otwarty plik? Zadaj sobie pytanie: "A pochemu?" i zamknij go! Używaj using tam, gdzie to możliwe.

Techniczna ściągawka

File.Create

File.WriteAllText

File.Exists

File.Delete

Directory.CreateDirectory + File.WriteAllText

new FileInfo(path).Create / Delete / Exists

10. Typowe błędy przy pracy z plikami

Błąd nr 1: zapominają zamknąć strumień po File.Create.
Wielu początkujących tworzy plik przez File.Create, ale nie zamyka zwróconego strumienia. W rezultacie reszta kodu przestaje „widzieć” plik — jakby zniknął do równoległego wszechświata. Zamykaj strumień jawnie (Close()) lub używaj konstrukcji using.

Błąd nr 2: próbują stworzyć plik w nieistniejącym folderze.
Typowa pułapka — próba stworzenia pliku w katalogu, którego jeszcze nie ma. Nie zapomnij wywołać Directory.CreateDirectory wcześniej. To całkowicie bezpieczne: nic „zbędnego” nie zostanie utworzone, a potrzebny folder powstanie.

Błąd nr 3: usuwają plik bez sprawdzenia.
Czasem chce się po prostu wywołać File.Delete, nie sprawdzając istnienia pliku. To dopuszczalne — metoda nie zgłosi błędu, jeśli pliku nie ma. Ale jeśli ścieżka jest błędna albo brak dostępu — wyjątek gwarantowany. Lepiej obsłużyć go wcześniej.

Błąd nr 4: mylą File.Delete i Directory.Delete.
File.Delete działa tylko na plikach, a Directory.Delete — na folderach. Próba usunięcia folderu przy pomocy File.Delete jest jak próba polerowania cegły szczoteczką do zębów: technicznie możliwe, ale raczej bez sensu.