Działania Na Plikach w C# - Praktyka

Tworząc różne aplikacje, często będziesz miał do zaimplementowania funkcje, które wymagają współpracy z zewnętrznymi plikami. Może to być zapis jakichś ważnych danych, których nie chcemy utracić, a chcemy mieć do nich łatwy dostęp. Ponadto odczyt różnych danych, modyfikacje, kopiowanie, usuwanie itd. Na szczęście w C# możemy sobie z tymi działaniami łatwo poradzić i pokaże Ci jak to robić w tym artykule na przykładzie.

Działania Na Plikach w C# - Praktyka

Możemy sobie na początek założyć nowy projekt w Visual Studio. Nie ma znaczenia, czy będzie to aplikacja konsolowa, desktopowa, czy webowa. Wszędzie ten kod będzie wyglądał tak samo. Myślę, że najprościej będzie utworzyć prostą aplikację desktopową w Windows Forms. Także taki projekt sobie utworzymy.

Otwórz proszę Visual Studio. W moim przypadku będzie to Visual Studio 2022.

Działania Na Plikach w C# - Praktyka - 1

Kliknij przycisk Create a new project.

Działania Na Plikach w C# - Praktyka - 2

Wpisz na górze w filtrze windows forms app i wybierz pierwszy projekt Windows Forms App (C#). Następnie kliknij przycisk Next.

Działania Na Plikach w C# - Praktyka - 3

Działania Na Plikach w C# - Praktyka - 3

Wpisz nazwę projektu, może to być np. FileApp.
Kliknij przycisk Next.

Działania Na Plikach w C# - Praktyka - 4

Wybierz wersję Frameworka. Może to być .NET 7.0
Kliknij przycisk Create.

Działania Na Plikach w C# - Praktyka - 5

Powinien zostać utworzony nowy projekt Windows Forms.
Będziemy tutaj wprowadzać zmiany na formatce głównej Form1.cs. Tutaj możesz dodawać kontrolki z tzw. Toolboxa za pomocą drag & drop. Dla każdej kontrolki będziesz mógł zmieniać właściwości w oknie Properties. Natomiast cały kod C# będziemy implementować w code behind. Aby przejść do code behind wystarczy kliknąć prawym przyciskiem myszy na formatkę główną, następnie wybrać View Code. Tak wygląda teraz nasz kod C#:

namespace FileApp
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
    }
}

Tworzenie plików

Na początek po kliknięciu w przycisk zapisz, będziemy chcieli utworzyć nowy plik tekstowy z dowolnym tekstem.

W takim razie dodaj proszę na formatkę główną kontrolkę Button. Ustaw dla właściwości Text Zapisz oraz dla Name btnSave (po tej nazwie będziemy się odnosić do tej kontrolki wewnątrz code behind).

Działania Na Plikach w C# - Praktyka - 6

Działania Na Plikach w C# - Praktyka - 6

Następnie kliknij dwukrotnie na przycisk i w code behind zostanie utworzona nowa metoda o nazwie btnSave_Click, która zostanie wywołana po kliknięciu w ten przycisk.

private void btnSave_Click(object sender, EventArgs e)
{

}

Właśnie w tej metodzie na początek będziemy chcieli utworzyć nowy plik tekstowy.

Jeżeli chcemy pracować na plikach w C#, to musimy się zaznajomić przede wszystkim z namespacem System.IO, który udostępnia nam różne klasy i metody, dzięki którym możemy łatwo wykonywać wszystkie działania na plikach.

Pierwsza rzecz, którą potrzebujemy, to ścieżka do pliku na którym będziemy pracować. W tym przypadku będzie to plik, który dopiero będziemy tworzyć.

Możemy sobie do zmiennej path przypisać po prostu nazwę pliku. Dzięki temu plik o takiej nazwie zostanie utworzony w folderze uruchomieniowym aplikacji obok pliku exe.

var path = "SampleFile.txt";

Za chwilę pokaże Ci też jak tę ścieżkę podawać w sposób bardziej dynamiczny, natomiast na teraz wystarczy nam taki zapis.

Chcąc utworzyć nowy plik potrzebujemy obiektu FileStream, który zgodnie z najlepszymi praktykami powinien zostać utworzony wewnątrz usinga, dzięki czemu po zakończeniu z nim pracy zostanie prawidłowo zwolnione po nim miejsce w pamięci.

private void btnSave_Click(object sender, EventArgs e)
{
    var path = "SampleFile.txt";

    using (FileStream fileStream = File.Create(path))
    {
        var text = "123";
        var content = Encoding.UTF8.GetBytes(text);
        fileStream.Write(content, 0, content.Length);
    }
}

Aby utworzyć nowy plik korzystamy tutaj z klasy File, która znajduje się właśnie w przestrzeni nazw System.IO i konkretnie metody Create do które jako parametr zostanie przekazana kompletna ścieżka do pliku, który chcemy utworzyć wraz z nazwą tego pliku.

Poniżej za pomocą metody Write zapisujemy tekst, który wcześniej zamieniamy jeszcze na tablicę byteów. Oczywiście w pliku możemy zapisać cokolwiek, może to być nawet zdjęcie.

Możemy teraz uruchomić naszą aplikację i zobaczymy czy faktycznie po kliknięciu w przycisk zostanie utworzony plik tekstowy z tekstem 123.

Uruchom proszę aplikację, kliknij przycisk Zapisz. Następnie przejdź do plików aplikacji i zobacz czy w folderze bin znajduje się plik w SampleFile.txt z tekstem 123.

Działania Na Plikach w C# - Praktyka - 7

Działania Na Plikach w C# - Praktyka - 7

Faktycznie tak jest.

Super, jak widzisz wszystko działa. Natomiast chciałbym jeszcze pokazać Ci w jaki sposób przekazywać ścieżkę do pliku w bardziej dynamiczny sposób.

Załóżmy, że chciałbyś utworzyć ten plik w konkretnym folderze. Na przykład na dysku d i w folderze pliki.

var path = "d:\\pliki\\SampleFile.txt";

Czy taki zapis jest prawidłowy?
Niestety nie, ponieważ jeżeli klient, który będzie chciał uruchomić Twoją aplikację nie będzie miał dysku d i tak samo utworzonej całej ścieżki folderów, to otrzyma błąd i aplikacja przestanie działać. Także zawsze jak podajesz na sztywno jakąś ścieżkę, to musisz wziąć taki problem pod uwagę.

Jak w takim razie podawać ścieżkę takiego pliku?
Najlepiej podać ścieżkę względną właśnie do folderu uruchomieniowego aplikacji. W takim przypadku mamy gwarancję, że taka ścieżka istnieje na dysku naszego klienta. Możemy sobie na początek zapisać do zmiennej ścieżkę do folderu głównego i później dostosować już konkretnie ścieżkę na podstawie tego folderu.

Dodajmy sobie teraz nową zmienną binPath, która będzie przechowywać właśnie ścieżkę do folderu bin aplikacji. Czyli tam są pliki uruchomieniowe aplikacji takie jak exe itp.

Oprócz tego do tej ścieżki chcemy dokleić nazwę folderu (myfiles) oraz nazwę pliku (SampleFile.txt).

private void btnSave_Click(object sender, EventArgs e)
{
    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var path = binPath + "\\" + "myfiles" + "\\" + "SampleFile.txt";

    using (FileStream fileStream = File.Create(path))
    {
        var text = "123";
        var content = Encoding.UTF8.GetBytes(text);
        fileStream.Write(content, 0, content.Length);
    }
}

Wszystko wydaje się, że jest ok. Natomiast zobacz co się stanie przy próbie utworzenia pliku.

Działania Na Plikach w C# - Praktyka - 8

Otrzymaliśmy błąd, który informuje nas o tym, że taki folder (myfiles) nie istnieje. Przed próbą utworzenia pliku w taki sposób musimy się upewnić, że istnieją wszystkie foldery nadrzędne. W jaki sposób możemy to zrobić?

Możemy tutaj skorzystać tym razem z klasy Directory i za pomocą metody Exists sprawdzić czy istnieje folder, który nas interesuje. Jeżeli folder nie istnieje, to za pomocą metody CreateDirectory możemy go utworzyć.

private void btnSave_Click(object sender, EventArgs e)
{
    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var expectedDirectory = binPath + "\\" + "myfiles";

    if (!Directory.Exists(expectedDirectory))
        Directory.CreateDirectory(expectedDirectory);

    var path = expectedDirectory + "\\" + "SampleFile.txt";

    using (FileStream fileStream = File.Create(path))
    {
        var text = "123";
        var content = Encoding.UTF8.GetBytes(text);
        fileStream.Write(content, 0, content.Length);
    }
}

Jeżeli teraz uruchomisz aplikację, klikniesz przycisk Zapisz, to zobaczysz, że tym razem plik został już utworzony poprawnie.

Wszystko działa, natomiast nie do końca podoba mi się jeszcze budowanie ścieżek za pomocą konkatencji stringów. Nie wygląda to dobrze i łatwo w ten sposób popełnić również błąd.

Do budowania ścieżek powinniśmy skorzystać z klasy Path i metody Combine, która zbuduje nam poprawnie ścieżkę na podstawie przekazanych do niej argumentów. Będziemy w tym miejscu zabezpieczeni przed różnymi błędami.

private void btnSave_Click(object sender, EventArgs e)
{
    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var expectedDirectory = Path.Combine(binPath, "myfiles");

    if (!Directory.Exists(expectedDirectory))
        Directory.CreateDirectory(expectedDirectory);

    var path = Path.Combine(expectedDirectory, "SampleFile.txt");

    using (FileStream fileStream = File.Create(path))
    {
        var text = "123";
        var content = Encoding.UTF8.GetBytes(text);
        fileStream.Write(content, 0, content.Length);
    }
}

Ok, aplikacja dalej działa poprawnie, a samo kod wygląda co raz lepiej.

Możemy jeszcze wprowadzić kilka zmiennych w naszej aplikacji, dzięki czemu będziemy mogli bardziej rozszerzyć jej działanie.

Wróćmy do formatki głównej. Dodamy sobie TextBoxa w którym wprowadzimy nazwę pliku oraz RichTextBox w którym będziemy wpisywali tekst, jaki chcemy żeby zapisał się w pliku. Ponadto 2 etykiety (label) w celu opisania tych pól.

Działania Na Plikach w C# - Praktyka - 9

Działania Na Plikach w C# - Praktyka - 9

Dla TextBoxa ustaw właściwość Name jako tbFileName, a dla RichTextBoxa rtbContent.

Przejdź teraz do code behind. Będziemy sobie pobierać nazwę pliku z TextBoxa, a tekst do zapisania z RichTextBoxa.

Przy okazji możemy sobie dodać podstawową walidację dla nazwy pliku i sprawdzać, czy w ogóle został wpisany jakiś tekst. Jeżeli nazwa pliku nie została wpisana, to wyświetlimy komunikat i zakończymy działanie tej metody.

private void btnSave_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var expectedDirectory = Path.Combine(binPath, "myfiles");

    if (!Directory.Exists(expectedDirectory))
        Directory.CreateDirectory(expectedDirectory);

    var path = Path.Combine(expectedDirectory, fileName);

    using (FileStream fileStream = File.Create(path))
    {
        var text = rtbContent.Text;
        var content = Encoding.UTF8.GetBytes(text);
        fileStream.Write(content, 0, content.Length);
    }
}

Możemy teraz uruchomić naszą aplikację i zobaczymy czy wszystko działa zgodnie z naszymi oczekiwaniami.

Działania Na Plikach w C# - Praktyka - 10

Działania Na Plikach w C# - Praktyka - 11

Super, jak widzisz wszystko jest ok. Natomiast nasz kod możemy jeszcze zrefaktoryzować. Klasa File udostępnia nam jeszcze szereg innych metod, które ułatwiają nam zapisywanie danych w pliku. Możemy skorzystać np. z metody WriteAllText, do której wystarczy przekazać ścieżkę oraz tekst, który chcemy zapisać i nie musimy się niczym więcej przejmować. Ta metoda tworzy plik, jeżeli jeszcze nie istnieje, zapisuje tekst, który przekazujemy i na koniec również zwalnia miejsce w pamięci. Jest ona w pełni bezpieczna i warto z niej korzystać.

private void btnSave_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var expectedDirectory = Path.Combine(binPath, "myfiles");

    if (!Directory.Exists(expectedDirectory))
        Directory.CreateDirectory(expectedDirectory);

    var path = Path.Combine(expectedDirectory, fileName);

    File.WriteAllText(path, fileName);
}

Możesz teraz to zweryfikować i zobaczysz, że wszystko dalej działa, tak jak wcześniej.

Oprócz metody WriteAllText możemy skorzystać z metody AppendAllText, która z kolei doklei nowy tekst do tekstu, który został wcześniej zapisany w tym pliku. Czyli metoda WriteAllText zapisuje nowy tekst. Jeżeli wcześniej w pliku był inny tekst, to zostanie on nadpisany, a metoda AppendAllText dokleja nowy tekst do tego, który już tam wcześniej był.

Jeżeli chcesz zapisać inny format danych niż sam tekst, to również możesz skorzystać z innych dedykowanych metod, takich jak np. WriteAllBytes.

Odczytywanie plików

Tyle jeżeli chodzi o tworzenie i zapisywanie plików. Oprócz zapisywania danych do pliku ważne będzie również odczyt tych danych. Dodajmy sobie do naszej aplikacji na formatce głównej nowy przycisk wczytaj dane i za chwilę go zaimplementujemy.

Działania Na Plikach w C# - Praktyka - 12

Działania Na Plikach w C# - Praktyka - 12

Ustaw dla tego przycisku właściwość Name na btnRead.
Kliknij dwukrotnie na przycisk, dzięki czemu zostanie utworzone zdarzenie Click i powiązanie z metodą btnRead_Click.

private void btnRead_Click(object sender, EventArgs e)
{

}

Będziemy teraz chcieli dodać nową funkcjonalność do naszej aplikacji. Chcemy, żeby po kliknięciu przycisku wczytaj dane została w RichTextBoxie wyświetlona zawartość pliku tekstowego, którego nazwę wpiszemy w TextBoxie.

Skorzystamy tym razem z metody ReadAllText, która umożliwia nam pobranie całego tekstu z wybranego pliku. Sporo kodu moglibyśmy skopiować z metody, którą napisaliśmy wcześniej.

private void btnRead_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var expectedDirectory = Path.Combine(binPath, "myfiles");

    if (!Directory.Exists(expectedDirectory))
        Directory.CreateDirectory(expectedDirectory);

    var path = Path.Combine(expectedDirectory, fileName);

    File.ReadAllText(path);
}

Natomiast to nie jest dobre rozwiązanie, ponieważ mamy teraz sporo duplikacji kodu. Dużo lepszym rozwiązaniem będzie wyodrębnienie wspólnego kodu do nowej metody i wywołanie tej nowej metody dwukrotnie w każdej z naszych metod powiązanych z tymi zdarzeniami.

private void btnSave_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var path = GetFullPath(fileName);

    File.WriteAllText(path, fileName);
}

private void btnRead_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var path = GetFullPath(fileName);

     File.ReadAllText(path);
}

private string GetFullPath(string fileName)
{
    var binPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

    var expectedDirectory = Path.Combine(binPath, "myfiles");

    if (!Directory.Exists(expectedDirectory))
        Directory.CreateDirectory(expectedDirectory);

    return Path.Combine(expectedDirectory, fileName);
}

Tak teraz będą wyglądać nasze metody. Oprócz wywołania metody GetFullPath będziemy jeszcze wcześniej mieli podstawową walidację danych.

Wracając do metody btnRead_Click, w tym momencie tylko pobieramy tekst z pliku, natomiast musimy sobie jeszcze ten tekst wyświetlić na RichTextBoxie.

private void btnRead_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var path = GetFullPath(fileName);

    rtbContent.Text = File.ReadAllText(path);
}

Uruchom teraz aplikację i zobacz, że faktycznie to działa. Możemy sobie pobrać i wyświetlić tekst z pliku text123.txt, który wcześniej utworzyliśmy.

Działania Na Plikach w C# - Praktyka - 13

Działania Na Plikach w C# - Praktyka - 13

Super, wszystko działa.
Możesz sobie teraz tworzyć nowy plik, zmieniać jego zawartość i wyświetlać w naszej aplikacji.

Usuwanie plików

Oprócz zapisu danych do pliku oraz ich odczytu mamy szereg innych często używanych metod, takich jak na przykład usuwanie plików, które realizujemy za pomocą metody Delete.

Działania Na Plikach w C# - Praktyka - 14

Działania Na Plikach w C# - Praktyka - 14

private void btnDelete_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var path = GetFullPath(fileName);

    File.Delete(path);
}

Po kliknięciu w przycisk usuń plik, zostanie usunięty plik o nazwie wpisanej w TextBoxie.

Kopiowanie plików

Możemy też kopiować pliki. Tutaj skorzystamy z metody Copy.

Działania Na Plikach w C# - Praktyka - 15

Metody Copy przyjmuje 2 parametry. Pierwszy to ścieżka do pliku źródłowego, który chcemy skopiować oraz drugi, czyli ścieżkę wraz z nazwą nowego utworzonego pliku. Możemy nazwę nowego pliku przekazywać również z formatki głównej, natomiast, żeby nie przedłużać wpiszę sobie tę ścieżkę na tutaj na sztywno w kodzie.

private void btnCopy_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var path = GetFullPath(fileName);

    File.Copy(path, "C:\\ProjektyCsharp\\FileApp\\bin\\Debug\\net7.0-windows\\myfiles\\nowy-plik.txt");
}

Po kliknięciu w przycisk Kopiuj plik zostanie skopiowana zawartość pliku o nazwie wpisanej w TextBoxie do nowego pliku tekstowego o nazwie nowy-plik.txt.

Sprawdzanie czy plik istnieje

Często również będziemy chcieli zweryfikować, czy dany plik został już utworzony. Do tego przydatna będzie metoda Exists.

W celu pokazania Ci jak możesz użyć tej metody, wróć proszę do metody btnSave_Click. Możemy sobie dodać tutaj taką nową walidację, która sprawdzi czy plik, który chcemy utworzyć już istnieje. Jeżeli plik istnieje, to wyświetlimy tylko odpowiedni komunikat i nie nadpiszemy go. A jeżeli plik jeszcze nie istnieje, to tylko w takim przypadku go utworzymy.

private void btnSave_Click(object sender, EventArgs e)
{
    var fileName = tbFileName.Text;

    if (string.IsNullOrWhiteSpace(fileName))
    {
        MessageBox.Show("Proszę podaj nazwę pliku!");
        return;
    }

    var path = GetFullPath(fileName);

    if (File.Exists(path))
    {
        MessageBox.Show("Plik o takiej nazwie już istnieje! Wpisz proszę inną nazwę pliku");
        return;
    }

    File.WriteAllText(path, fileName);
}

Jeżeli teraz uruchomisz aplikację i będziesz chciał zmienić zawartość pliku, który już istnieje, to zostanie wyświetlony komunikat.

Działania Na Plikach w C# - Praktyka - 16

Działania Na Plikach w C# - Praktyka - 16

Zachęcam Cię również do zweryfikowana i pobawienia się innymi metodami i właściwościami, które znajdziesz w klasach File, Directory i Path, a także na obiektach FileInfo oraz DirectoryInfo.

Jeżeli wpiszesz sobie np. File. lub Directory. to intelisense pokaże Ci mnóstwo metod i właściwości, które mogą być dla Ciebie pomocne w różnych sytuacjach.

Zadanie

Na koniec, mam dla Ciebie jeszcze praktyczne zadanie do wykonania, oczywiście związane z plikami.

Wiedza, którą poznałeś w tym artykule powinna być wystarczająco do tego byś sobie z tym poradził.

Treść zadania:
Do naszej aplikacji, na której pracujemy w tym odcinku dodaj nową funkcjonalność, dzięki której po uruchomieniu aplikacji, w prawym górnym rogu będzie wyświetlana nazwa użytkownika, która została wcześniej przez niego ustawiona. Czyli jeżeli użytkownik ustawił swoją nazwę, to zawsze przy każdym uruchomieniu będzie ona widoczna.

Spróbuj teraz napisać własną implementację, a poniżej pokaże Ci moje przykładowe rozwiązanie. Oczywiście jeżeli Twoje rozwiązanie będzie inne, to nie oznacza, że jest ono złe, ponieważ można to zaimplementować na kilka różnych sposobów.

Rozwiązanie zadania:
Na początek warto zastanowić się, co w ogóle chcemy zrobić, a później przejść dopiero do implementacji.

Mamy tutaj do zrobienia kilka rzeczy:
1) Możliwość ustawienia nazwy użytkownika.
2) Zapis nazwy użytkownika do pliku.
3) Wyświetlenie nazwy użytkownika.

Przejdźmy od razu do implementacji.

Na początek na formatce głównej dodamy:
1) Pusty Label (Name: lbUserName, TextAlign: MiddleRight, AutoSize: false) – tutaj będzie wyświetlana nazwa użytkownika (w prawym górnym rogu).
2) Label (Name: lbUserInfo) - etykieta dla TextBoxa.
3) TextBox (Name: tbUserName) - do wpisania nazwy użytkownika.
4) Button (Name: btnUserNameSave) – do zapisania nazwy użytkownika.

Działania Na Plikach w C# - Praktyka - 17

Działania Na Plikach w C# - Praktyka - 17

Kliknij dwukrotnie na przycisk Zapisz tak, aby utworzyć nową metodę btnUserNameSave_Click, która zostanie wywołana po kliknięciu przez użytkownika na ten przycisk.

W tej metodzie pobierzemy sobie wartość TextBoxa z tbUserName.
Następnie zweryfikujemy czy jakaś wartość została wpisana.
Zapiszemy sobie nazwę użytkownika wpisaną w tym TextBoxie w jakimś nowym pliku, np o nazwie user-name.txt.
Wyświetlimy nazwę użytkownika w prawym górnym rogu i ukryjemy kontrolki do wprowadzania nazwy użytkownika (nie będzie nam to już potrzebne).

private void btnUserNameSave_Click(object sender, EventArgs e)
{
    var userName = tbUserName.Text;

    if (string.IsNullOrWhiteSpace(userName))
    {
        MessageBox.Show("Proszę podaj nazwę użytkownika!");
        return;
    }

    var path = GetFullPath("user-name.txt");

    File.WriteAllText(path, userName);

    lbUserName.Text = $"Witaj {userName}!";

    lbUserInfo.Visible = false;
    tbUserName.Visible = false;
    btnUserNameSave.Visible = false;
}

Tak może wyglądać przykładowy kod.

Oprócz tego, chcemy, żeby po uruchomieniu aplikacji również została zweryfikowana wartość tego pliku user-name.txt. Jeżeli ten plik istnieje, to oznacza, że użytkownik wprowadził już swoją nazwę. W związku z tym, wyświetlamy nazwę wpisaną w pliku i ukrywamy kontrolki.

public Form1()
{
    InitializeComponent();

    var userNamePath = GetFullPath("user-name.txt");

    if (File.Exists(userNamePath))
    {
        var userName = File.ReadAllText(userNamePath);

        lbUserName.Text = $"Witaj {userName}!";

        lbUserInfo.Visible = false;
        tbUserName.Visible = false;
        btnUserNameSave.Visible = false;
    }
}

Mamy tutaj kilka duplikacji kodu, także możemy dodać sobie nową metodę np. o nazwie SetUserName i tam umieścić kod, który używamy w różnych miejsach. Następnie wywołamy tylko metodę SetUserName.

Oprócz tego w dwóch miejscach podajemy nazwę tego samego pliku user-name.txt. Dobrą praktyką jest również przypisanie tej nazwy do pola i w miejscach, gdzie odnosimy się to nazwy pliku, będziemy odnosić się poprzez nazwę pola. Dzięki temu możemy zabezpieczyć się przed literówkami i jeżeli np. w przyszłości chcielibyśmy zmienić nazwę tego pliku, to wystarczy to zrobić tylko w 1 miejscu.

private const string FileNameUserName = "user-name.txt";

private void SetUserName(string userName)
{
    lbUserName.Text = $"Witaj {userName}!";
    lbUserInfo.Visible = false;
    tbUserName.Visible = false;
    btnUserNameSave.Visible = false;
}

public Form1()
{
    InitializeComponent();

    var userNamePath = GetFullPath(FileNameUserName);

    if (File.Exists(userNamePath))
    {
        var userName = File.ReadAllText(userNamePath);
        SetUserName(userName);
    }
}

private void btnUserNameSave_Click(object sender, EventArgs e)
{
    var userName = tbUserName.Text;

    if (string.IsNullOrWhiteSpace(userName))
    {
        MessageBox.Show("Proszę podaj nazwę użytkownika!");
        return;
    }

    var path = GetFullPath(FileNameUserName);

    File.WriteAllText(path, userName);

    SetUserName(userName);
}

Na koniec zweryfikujemy tylko działanie aplikacji.

Pierwsze uruchomienie aplikacji.

Działania Na Plikach w C# - Praktyka - 18

Zapisuję nazwę użytkownika.

Kolejne uruchomienie aplikacji.

Działania Na Plikach w C# - Praktyka - 19

Super. Wszystko działa zgodnie z założeniami tego zadania.

To wszystkie na dzisiaj. Jeżeli taki artykuł Ci się spodobał, to koniecznie dołącz do mojej społeczności – darmowe zapisy, gdzie będziesz również miał dostęp do dodatkowych materiałów i przede wszystkim bonusów. Do zobaczenia w kolejnym artykule.

Poprzedni artykuł - Jak Nauczyłem się Programowania? Moja Historia