Dataczwartek, 13 sierpnia 2026 Czas17:45:36
← Aplikacje desktopowe (WPF)

Lekcja 2. Visual Studio 2026 — środowisko pracy i interfejs

Podstawowy

Po co się tego uczymy?

Zanim zaczniesz pisać aplikacje WPF, musisz swobodnie poruszać się po Visual Studio — inaczej każda kolejna lekcja będzie polegać na klikaniu "gdzieś tam", bez rozumienia, gdzie właściwie jesteś. Ta lekcja pokazuje wszystkie kluczowe okna i narzędzia IDE, których będziesz używać codziennie: Solution Explorer, Toolbox, Properties, debugger i NuGet — to realizacja INF.04.5.1 ("wykorzystuje środowisko programistyczne dla aplikacji desktopowych").

Teoria

Visual Studio to bardzo rozbudowany program — na pierwszy rzut oka może przytłoczyć liczbą okien, przycisków i menu. Na szczęście do codziennej pracy z WPF potrzebujesz naprawdę tylko kilku z nich. Poznajmy je po kolei.

Solution i Project — dwa poziomy organizacji

Solution (rozwiązanie, plik .sln) to "teczka", która może zawierać jeden lub więcej projektów (plik .csproj). W tym dziale każde solution będzie zawierać jeden projekt WPF, ale w większych systemach jedno solution potrafi grupować kilkanaście projektów (np. aplikację, bibliotekę wspólną i projekt testów jednostkowych).

Solution Explorer — mapa projektu

Solution Explorer (domyślnie po prawej stronie, Widok → Eksplorator rozwiązań / View → Solution Explorer, skrót Ctrl+Alt+L) to drzewko wszystkich plików projektu. W świeżym projekcie WPF znajdziesz tam m.in.:

  • App.xaml / App.xaml.cs — punkt startowy całej aplikacji, tu można zdefiniować zasoby (style, kolory) współdzielone przez wszystkie okna;
  • MainWindow.xaml / MainWindow.xaml.cs — główne okno aplikacji i jego kod w tle (code-behind);
  • Properties (a w nim AssemblyInfo.cs) — metadane aplikacji (nazwa, wersja);
  • Zależności / Dependencies — lista zainstalowanych pakietów NuGet i odwołań do bibliotek;
  • foldery bin i obj — pliki WYGENEROWANE automatycznie podczas kompilacji (skompilowane .exe/.dll). Nigdy nie edytuje się ich ręcznie i nie dodaje do repozytorium Git — jeśli je usuniesz, powstaną od nowa przy kolejnej kompilacji.

Toolbox — skrzynka z kontrolkami

Toolbox (domyślnie zwinięty pasek po lewej krawędzi, Widok → Przybornik / View → Toolbox) zawiera wszystkie gotowe kontrolki WPF — Button, TextBox, Label i dziesiątki innych — pogrupowane kategoriami. Kontrolkę dodajesz do okna, przeciągając ją myszą z Toolboxa na obszar projektanta (Designer). To alternatywa dla ręcznego wpisywania znaczników XAML — obie metody dają dokładnie ten sam efekt, bo przeciągnięcie kontrolki po prostu dopisuje odpowiedni XAML za Ciebie.

Projektant XAML (Designer) — podgląd na żywo

Kiedy otworzysz plik .xaml, Visual Studio domyślnie dzieli okno edytora na dwie części: u góry podgląd wizualny (jak będzie wyglądać okno), u dołu kod XAML. Zmiana w jednym miejscu natychmiast aktualizuje drugie — możesz przeciągać kontrolki myszą w podglądzie ALBO pisać znaczniki ręcznie w kodzie, w zależności od tego, co jest wygodniejsze w danej chwili. Doświadczeni programiści WPF najczęściej piszą XAML ręcznie (jest to szybsze i bardziej precyzyjne), a podglądu używają tylko do sprawdzenia efektu.

Properties (Właściwości) — panel ustawień kontrolki

Okno Properties (domyślnie prawy dolny róg, F4 albo Widok → Okno właściwości) pokazuje wszystkie właściwości aktualnie zaznaczonej kontrolki — kolor, rozmiar, nazwę, czcionkę — w formie formularza z polami i listami rozwijanymi. To wygodny sposób na odkrywanie, jakie właściwości w ogóle ma dana kontrolka, bez przeszukiwania dokumentacji: zaznacz kontrolkę w projektancie i przewiń listę właściwości w oknie Properties.

Output i Lista błędów (Error List)

Okno Output (Widok → Output) pokazuje szczegółowy log kompilacji — co dokładnie się kompiluje i czy się udało. Lista błędów / Error List (Widok → Lista błędów) to bardziej czytelna, przefiltrowana lista błędów (czerwone ikony) i ostrzeżeń (żółte ikony) — dwuklik na wpisie przenosi kursor dokładnie do problematycznej linijki kodu.

Konfiguracja Debug / Release

U góry okna głównego, obok przycisku uruchamiania, znajduje się rozwijana lista z konfiguracją: Debug (domyślna — kompilacja zawiera dodatkowe informacje ułatwiające debugowanie, uruchamianie jest wolniejsze) oraz Release (kompilacja zoptymalizowana pod wydajność, używana przy publikowaniu gotowej aplikacji do użytkowników — w tej konfiguracji breakpointy mogą nie działać poprawnie).

Uruchamianie i debugowanie — najważniejsze skróty

Skrót Działanie
F5 Uruchom z debugowaniem (Start Debugging) — zatrzymuje się na breakpointach.
Ctrl+F5 Uruchom bez debugowania — szybsze, breakpointy są ignorowane.
Shift+F5 Zatrzymaj debugowanie.
F9 Ustaw/usuń breakpoint (czerwona kropka) w bieżącej linijce kodu.
F10 Krok przez kod — wykonaj bieżącą linijkę, ale NIE wchodź do wnętrza wywoływanej metody.
F11 Krok do wewnątrz — wykonaj bieżącą linijkę i wejdź do wnętrza wywoływanej metody, jeśli to możliwe.
Ctrl+Shift+B Zbuduj (skompiluj) całe rozwiązanie bez uruchamiania.

Kiedy program zatrzyma się na breakpoincie, na dole ekranu pojawiają się okna Locals (aktualne wartości zmiennych lokalnych) i Watch (wartości wybranych przez Ciebie wyrażeń, które śledzisz na bieżąco) — to podstawowe narzędzia do znajdowania błędów logicznych, kiedy program się kompiluje, ale działa niepoprawnie.

NuGet — instalowanie bibliotek zewnętrznych

Menu Narzędzia → Menedżer pakietów NuGet → Zarządzaj pakietami NuGet dla rozwiązania (Tools → NuGet Package Manager) otwiera okno, w którym możesz wyszukać i zainstalować gotowe biblioteki — np. w dalszych lekcjach zainstalujemy w ten sposób bibliotekę do obsługi bazy SQLite. NuGet automatycznie pobiera bibliotekę z internetu i dodaje odwołanie do projektu — dokładnie tak, jak przy instalowaniu paczek w innych ekosystemach (npm w JavaScript, pip w Pythonie).

IntelliSense — podpowiedzi podczas pisania

Podczas pisania kodu C# lub XAML, Visual Studio na bieżąco podpowiada dostępne właściwości, metody i typy w rozwijanej liście (możesz też wywołać ją ręcznie skrótem Ctrl+Spacja). Czerwone faliste podkreślenie oznacza błąd składniowy, zielone — ostrzeżenie (np. nieużywana zmienna). To ogromne ułatwienie, zwłaszcza przy nauce nowych kontrolek — wystarczy wpisać kropkę po nazwie kontrolki, żeby zobaczyć wszystkie jej dostępne właściwości.

Schemat

Rozklad glownych okien Visual Studio przy edycji pliku XAML:

+---------------------------------------------------------------+
| Pasek menu (Plik, Edycja, Widok, Projekt, Build, Debug...)    |
| Pasek narzedzi:  [Debug v] [Uruchom (F5) >] ...                |
+------------+----------------------------------+----------------+
|            |                                  |                |
| Toolbox    |     PROJEKTANT XAML              |   Properties   |
| (kontrolki |     (podglad na gorze,           |   (wlasciwosci |
|  do        |      kod XAML na dole)           |    zaznaczonej |
|  przeciag- |                                  |    kontrolki)  |
|  niecia)   |                                  |                |
|            |                                  |                |
+------------+----------------------------------+----------------+
| Solution Explorer (drzewko plikow projektu)   |  Output /      |
| - App.xaml                                     |  Error List    |
| - MainWindow.xaml                              |  (bledy,       |
| - Dependencies                                 |   ostrzezenia) |
+-------------------------------------------------+---------------+

Przykład z życia

Visual Studio można porównać do kokpitu samochodu: Solution Explorer to nawigacja pokazująca, gdzie w ogóle jesteś, Toolbox to schowek z narzędziami, Properties to panel ustawień (klimatyzacja, radio), a Error List to kontrolki na desce rozdzielczej ostrzegające, że coś jest nie tak. Dobry kierowca nie musi znać każdego elementu kokpitu na pamięć od razu — ale musi wiedzieć, gdzie jest kierownica (edytor kodu) i hamulec (Stop debugowania), zanim ruszy w trasę.

MojaAplikacja.csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWPF>true</UseWPF>
  </PropertyGroup>

</Project>

Komentarz i wyjaśnienie kodu

To zawartość pliku .csproj — "ustawień" każdego projektu WPF, widocznych w Solution Explorer po dwukliku na nazwę projektu. Warto rozumieć te kilka linijek, bo czasem trzeba je ręcznie poprawić:

  • OutputType>WinExe</OutputType> — mówi, że efektem kompilacji ma być aplikacja okienkowa (Windows Executable), a nie konsolowa (dlatego przy uruchomieniu WPF nie pojawia się czarne okno konsoli);
  • TargetFramework>net9.0-windows</TargetFramework> — wersja .NET, na której działa projekt, plus dopisek -windows informujący, że projekt korzysta z API dostępnych tylko na Windows (bo WPF jest technologią wyłącznie windowsową);
  • Nullable>enable</Nullable> — włącza ostrzeżenia kompilatora o potencjalnych wartościach null (bezpieczniejszy kod);
  • UseWPF>true</UseWPF> — kluczowa linijka: mówi kompilatorowi, żeby dołączył biblioteki WPF i umiał przetwarzać pliki .xaml. Bez niej projekt w ogóle by się nie skompilował.

Ćwiczenie samodzielne

Otwórz dowolny projekt WPF z poprzedniej lekcji i wykonaj po kolei:

  1. Znajdź i otwórz okno Solution Explorer — rozwiń folder projektu i zlokalizuj pliki App.xaml oraz MainWindow.xaml;
  2. Otwórz MainWindow.xaml i sprawdź, czy widzisz podzielony widok (podgląd + kod). Kliknij dowolną kontrolkę w podglądzie i sprawdź, czy w oknie Properties (skrót F4) pojawiają się jej właściwości;
  3. Ustaw breakpoint (F9) w pierwszej linijce konstruktora MainWindow() w pliku MainWindow.xaml.cs;
  4. Uruchom aplikację przez F5 — program powinien zatrzymać się na Twoim breakpoincie. Sprawdź okno Locals na dole ekranu;
  5. Naciśnij F10 kilka razy, obserwując żółtą strzałkę przesuwającą się po kodzie, a potem Shift+F5, żeby zatrzymać debugowanie.

Zadania do pracy własnej

  1. Dopasuj okno Visual Studio do sytuacji: (a) chcę sprawdzić, jaki kolor tła ma zaznaczony przycisk, (b) chcę dodać do okna nowy TextBox bez pisania XAML ręcznie, (c) kompilacja się nie powiodła i chcę zobaczyć, w której linijce jest błąd. Podaj nazwę odpowiedniego okna dla każdej sytuacji.

  2. Celowo wprowadź błąd składniowy do kodu C# (np. usuń średnik na końcu linijki) i spróbuj uruchomić aplikację przez F5. Zapisz, co pojawiło się w Error List, a następnie napraw błąd i sprawdź, że wpis zniknął.

  3. W dowolnym projekcie z poprzedniej lekcji ustaw DWA breakpointy w różnych miejscach kodu, uruchom debugowanie (F5), a następnie przejdź między nimi używając F5 (kontynuuj do następnego breakpointa) oraz F11 (wejdź do wnętrza wywoływanej metody, jeśli na danej linijce coś wywołujesz). Opisz krótko, co zaobserwowałeś w oknie Locals na każdym zatrzymaniu.

Typowe błędy

Ręczna edycja plików w folderach bin/obj — te pliki są generowane automatycznie przy każdej kompilacji i wszelkie ręczne zmiany zostaną nadpisane bez ostrzeżenia.

Uruchamianie w konfiguracji Release i dziwienie się, że breakpointy nie działają — do nauki i debugowania zawsze używaj konfiguracji Debug (domyślnej). Release jest przeznaczony do finalnego publikowania aplikacji.

Mylenie Ctrl+F5 z F5 — jeśli ustawiłeś breakpoint, a program "przelatuje" przez niego bez zatrzymania, sprawdź, czy przypadkiem nie uruchomiłeś aplikacji przez Ctrl+F5 (bez debugowania) zamiast F5.

Brak zapisanych zmian przed uruchomieniem — Visual Studio zwykle zapisuje pliki automatycznie przed budowaniem, ale w razie wątpliwości bezpieczniej jest ręcznie nacisnąć Ctrl+Shift+S (zapisz wszystko).

Nawiązanie do egzaminu zawodowego

To bezpośrednia realizacja INF.04.5.1 — "wykorzystuje środowisko programistyczne dla aplikacji desktopowych". Sprawna nawigacja po Visual Studio (Solution Explorer, Toolbox, Properties, debugger) jest też niezbędna praktycznie na egzaminie — czas poświęcony na szukanie odpowiedniego okna to czas odjęty od rozwiązywania właściwego zadania.