Przejdź do głównej treści
INF.04-02-26.06-SGCzerwiec 2026 · 20 kroków · ok. 60 min · 33 kryteria z klucza

Rozwiązanie krok po kroku: Aplikacja notatek konsolowa i mobilna (C# + .NET MAUI)

Rozwiązanie dotyczy arkusza z notatnikiem w wersji C# + .NET MAUI: w konsoli klasa Notatka z tytułem, treścią, priorytetem i datą dodania, dwoma konstruktorami i metodą, która wypisuje notatkę między liniami podkreślników - przetestowana na notatce ważnej i na notatce z tytułem z klawiatury; w aplikacji mobilnej .NET MAUI lista notatek i formularz, którym dopisuje się nową notatkę na koniec listy. Do tego nagłówek metody według wzoru z arkusza, zrzuty i plik egzamin.

To drugie rozwiązanie tego arkusza - pierwsze, w zakładce obok, robi to samo w Javie i Android Studio. Arkusz pokazuje oba środowiska (ilustracje 2 i 3 to .NET MAUI), a klucz ocenia je tymi samymi kryteriami - z jednym warunkiem dla MAUI: kolekcja notatek musi być obserwowalna (ObservableCollection).

Kroki idą zdanie po zdaniu za treścią arkusza, a kod od początku jest taki, jak w porządnym projekcie. Na końcu dwa kroki porównują to rozwiązanie z wariantem w Javie.

Co widać w podglądzie. Wyniki programu konsolowego pochodzą z prawdziwego uruchomienia kodu z danego kroku (.NET 10) - data dodania to chwila tego uruchomienia. Ekran telefonu to symulacja w przeglądarce zbudowana z pliku XAML danego kroku; jej zachowanie odpowiada kodowi C# z kroku - wpisz tytuł i treść, kliknij „DODAJ”. Każdy stan aplikacji zbudowano też naprawdę (dotnet build) i porównano z emulatorem Pixel 8 (Android 16).

Jak liczą się punkty. Klucz ma 33 kryteria (R.1.1 - R.4.9), każde za 1 punkt. Próg zdania części praktycznej to 75%, czyli 25 punktów - można stracić 8 kryteriów i nadal zdać. Przy każdym kroku jest napisane, które kryteria spełnia; egzaminator ocenia spełnienie kryteriów z klucza, nie zgodność z tym kodem.

  1. Etap 1: Przygotowanie

    Krok 1 · po tym etapie masz 0 z 33 kryteriów (pkt)

    Krok 1: Folder zdającego i podfoldery

    ok. 1 min
    Polecenie z arkusza

    Utwórz folder i nazwij go numerem zdającego. W folderze utwórz trzy podfoldery o nazwach: konsolowa, mobilna, dokumentacja. Po wykonaniu zadania umieścisz w nich rezultaty swojej pracy.

    Na pulpicie zakładasz folder o nazwie z numerem PESEL, a w nim konsolowa, mobilna i dokumentacja. Arkusz nie ma załączników.

  2. Etap 2: Aplikacja konsolowa

    Kroki 2-7 · po tym etapie masz 17 z 33 kryteriów (pkt)

    Krok 2: Projekt konsola w C#

    ok. 3 min
    Polecenie z arkusza

    Napisz program implementujący klasę Notatka służącą programowi do notatek użytkownika. Program wykonywany w konsoli. Zastosowany obiektowy język programowania zgodny z zainstalowanym na stanowisku egzaminacyjnym: C++ lub C#, lub Java, lub Python.

    Wybierasz C# - ten sam język posłuży w .NET MAUI, więc klasę Notatka przeniesiesz do aplikacji mobilnej. W Visual Studio: Utwórz nowy projekt → Aplikacja konsolowa, nazwa konsola (dotnet new console -n konsola). Program główny piszesz w Program.cs jako instrukcje najwyższego poziomu, klasę - w osobnym pliku (Dodaj → Klasa...). Nazwa klasy jest z arkusza, więc pola i metody też nazwiesz po polsku.

    konsola/Program.cs C# nowy plik
    Console.WriteLine("Hello, World!");
    Wynik programu po tym kroku
    > konsola.exe
    Hello, World!
  3. Krok 3: Klasa Notatka i cztery pola public

    Kryteria: , , ,

    R.2.1 Program składa się z programu głównego oraz definicji klasy Notatka (Note), w której zdefiniowane przynajmniej jedno pole

    R.2.2 Klasa zawiera cztery pola o zasięgu public: dwa tekstowe, logiczny, oraz do zapisu daty, w zależności od języka programowania: DateTime, Date lub inne w tym prosty o ile jest dobrze obsługiwany (w języku Python typy wynikają z przypisanych im danych)

    R.1.4 Polskie lub angielskie, znaczące nazewnictwo pól. Wyjątkami od reguły są zmienne bufor, tmp, iteratory pętli itp. Kryterium nie jest spełnione tylko wtedy, gdy nazwy zmiennych nic nie znaczą, np. x, fun, foo, tab, tablica

    R.1.5 Typy zmiennych pasują do problemu np. typ tekstowy dla tytułu i treści notatki, bool dla określenia priorytetu notatki, typ daty dla przypisania aktualnej daty dodania notatki (w przypadku języka Python typ wynika z przypisanych danych)

    ok. 3 min
    Polecenie z arkusza

    Zawiera klasę Notatka (Note) oraz sprawdzenie działania klasy w programie głównym. Ogólnodostępne pola klasy, zawierające: tytuł notatki, typu napisowego, treść notatki, typu napisowego, priorytet notatki, typu logicznego, notatka jest ważna lub nie jest ważna, datę dodania notatki typu przechowującego datę.

    Plik Notatka.cs (R.2.1). „Ogólnodostępne” to public (R.2.2): dwa napisy string, priorytet jako bool Wazna (true = ważna) i data dodania typu DateTime - przechowuje datę i godzinę, a ilustracja 1 pokazuje obie (R.1.5). Pola publiczne w C# zwyczajowo nazywa się wielką literą.

    Visual Studio podkreśla teraz pola napisowe ostrzeżeniem, że mogą zostać null - zniknie, gdy konstruktory je wypełnią.

    konsola/Notatka.cs C# nowy plik
    namespace konsola;
    
    public class Notatka
    {
        public string Tytul;
        public string Tresc;
        public bool Wazna;
        public DateTime DataDodania;
    }

    Wynik programu bez zmian - taki jak po kroku 2.

  4. Krok 4: Dwa konstruktory: trój- i jednoargumentowy

    Kryteria: ,

    R.2.3 Klasa zawiera dwa konstruktory (w języku Python jeden konstruktor z dwoma argumentami domyślnymi) o argumentach: 1) tytuł, treść i priorytet 2) tytuł

    R.2.4 Konstruktory przypisują wartości argumentów do odpowiednich pól, polu daty aktualną datę oraz w przypadku konstruktora jednoargumentowego jawnie przypisane są wartości do treści: "" i priorytetu: false

    ok. 4 min
    Polecenie z arkusza

    Konstruktor trójargumentowy, którego argumentami są: tytuł, treść i priorytet, mający za zadanie: przypisać wartości argumentów do odpowiednich pól klasy, przypisać dacie dodania notatki aktualną datę. Konstruktor jednoargumentowy, którego argumentem jest tytuł, mający za zadanie: przypisać wartość argumentu do pola tytułu, przypisać treści pusty napis, priorytet notatki ustawić na wartość oznaczającą, że notatka nie jest ważna, przypisać dacie dodania notatki aktualną datę.

    C# pozwala na przeciążanie konstruktorów - dwa konstruktory o tej samej nazwie różnią się listą parametrów (R.2.3).

    • Trójargumentowy przepisuje argumenty do pól. Pola mają nazwy wielką literą, parametry - małą, więc this. nie jest potrzebne.
    • Jednoargumentowy ustawia tytuł, a resztę jawnie: pusty napis "" i false (R.2.4). Klucz wymaga jawnych przypisań - dlatego nie skracasz go wywołaniem : this(tytul, "", false).
    • Oba wpisują DateTime.Now - bieżącą datę i godzinę w chwili utworzenia notatki.
    Typowe błędy

    W konstruktorze jednoargumentowym brak przypisania Tresc = "" - pole zostaje null, a kompilator ostrzega (CS8618), że pole nieakceptujące null nie zostało ustawione (R.2.4).

    konsola/Notatka.cs C# zmienione: 16 linii
    namespace konsola;
    
    public class Notatka
    {
        public string Tytul;
        public string Tresc;
        public bool Wazna;
        public DateTime DataDodania;
    
        public Notatka(string tytul, string tresc, bool wazna)
        {
            Tytul = tytul;
            Tresc = tresc;
            Wazna = wazna;
            DataDodania = DateTime.Now;
        }
    
        public Notatka(string tytul)
        {
            Tytul = tytul;
            Tresc = "";
            Wazna = false;
            DataDodania = DateTime.Now;
        }
    }

    Wynik programu bez zmian - taki jak po kroku 2.

  5. Krok 5: Metoda Wyswietl: notatka między liniami

    Kryteria: , , , ,

    R.2.5 Zdefiniowana metoda bezargumentowa, która nie zwraca wartości i ma zakres public

    R.2.6 Metoda wyświetla na ekranie w osobnych liniach: - linię poziomą, - tytuł notatki, poprzedzony słowem WAŻNA tylko wtedy, gdy priorytet notatki jest równy true, - treść notatki, - datę notatki, - linię poziomą

    R.1.3 Polskie lub angielskie, znaczące nazewnictwo metod

    R.1.1 Kod źródłowy zapisany w sposób czytelny: instrukcje w osobnych liniach, stosowane spacje pomiędzy operatorami, konsekwentnie stosowana wybrana konwencja dla nawiasów klamrowych

    R.1.2 Kod zapisany z wcięciami dla zagnieżdżeń bloków

    ok. 4 min
    Polecenie z arkusza

    Ogólnodostępna metoda wypisująca notatkę, bezargumentowa i niezwracająca wartości. Wyświetla na ekranie w osobnych liniach: linię poziomą utworzoną z kilkunastu podkreślników, jeżeli notatka jest ważna, tekst: „Notatka WAŻNA! <tytuł>”, w przeciwnym razie, tekst: „Notatka <tytuł>” gdzie <tytuł> jest wartością odpowiedniego pola klasy, treść notatki, datę dodania notatki, linię poziomą utworzoną z kilkunastu podkreślników.

    Metoda public void bez parametrów (R.2.5, R.1.3). Wypisuje po kolei, każde w osobnej linii (R.2.6):

    1. linię z 20 podkreślników,
    2. tytuł - ze słowem „WAŻNA!” tylko dla ważnej notatki (if (Wazna)); tekst składasz interpolacją $"Notatka {Tytul}",
    3. treść,
    4. datę w formacie z ilustracji 1 - ToString("dd.MM.yyyy HH:mm:ss"): dd dzień, MM miesiąc (wielkie M - małe mm to minuty), yyyy rok, HH godzina w zapisie 24-godzinnym,
    5. drugą linię.
    Typowe błędy

    Wzorzec "dd.mm.yyyy" - w miejscu miesiąca pojawiają się minuty, np. 14.37.2024 zamiast 14.02.2024.

    konsola/Notatka.cs C# zmienione: 16 linii
    namespace konsola;
    
    public class Notatka
    {
        public string Tytul;
        public string Tresc;
        public bool Wazna;
        public DateTime DataDodania;
    
        public Notatka(string tytul, string tresc, bool wazna)
        {
            Tytul = tytul;
            Tresc = tresc;
            Wazna = wazna;
            DataDodania = DateTime.Now;
        }
    
        public Notatka(string tytul)
        {
            Tytul = tytul;
            Tresc = "";
            Wazna = false;
            DataDodania = DateTime.Now;
        }
    
        public void Wyswietl()
        {
            Console.WriteLine("____________________");
            if (Wazna)
            {
                Console.WriteLine($"Notatka WAŻNA! {Tytul}");
            }
            else
            {
                Console.WriteLine($"Notatka {Tytul}");
            }
            Console.WriteLine(Tresc);
            Console.WriteLine(DataDodania.ToString("dd.MM.yyyy HH:mm:ss"));
            Console.WriteLine("____________________");
        }
    }

    Wynik programu bez zmian - taki jak po kroku 2.

  6. Krok 6: Program główny: dwie notatki i ich wyświetlenie

    Kryteria: , ,

    R.2.8 W programie głównym jest tworzony obiekt notatki konstruktorem trójargumentowym oraz jednoargumentowym. Dana do konstruktora jednoargumentowego jest wprowadzona z klawiatury (w Python w przypadku konstruktora jednoargumentowego dla parametrów treść oraz priorytet wartości ustawione na domyślne)

    R.2.9 Program wypisuje na ekranie dane obu notatek korzystając z metody wypisującej

    R.1.7 Komunikacja z użytkownikiem prowadzona jest w sposób zrozumiały. Jeżeli kod nie uruchamia się z powodu błędów kompilacji - sprawdzić w kodzie aplikacji

    ok. 3 min
    Polecenie z arkusza

    Program główny ma za zadanie: utworzyć obiekt klasy Notatka za pomocą konstruktora trójargumentowego (podając trzy argumenty). Notatka jest ważna, wartości argumentów konstruktora dowolne – statycznie wpisane w kodzie. Utworzyć obiekt klasy Notatka za pomocą konstruktora jednoargumentowego (podając jeden argument). Tytuł notatki został pobrany z klawiatury. Wyświetlić dane obu obiektów za pomocą metody do tego przeznaczonej (ilustracja 1).

    using konsola; udostępnia klasę z przestrzeni nazw projektu. Pierwszą notatkę tworzysz konstruktorem trójargumentowym z wartościami wpisanymi w kodzie i true - jest ważna. Drugą - jednoargumentowym, z tytułem wczytanym z klawiatury (R.2.8). Console.ReadLine() może zwrócić null (koniec danych), więc ?? "" podstawia wtedy pusty napis. Obie wyświetlasz metodą Wyswietl (R.2.9, R.1.7).

    Podgląd to prawdziwe uruchomienie z tytułem „spotkanie z kolegami”, jak na ilustracji 1 - druga notatka ma pustą treść.

    konsola/Program.cs C# zmienione: 10 linii
    using konsola;
    
    Notatka waznaNotatka = new Notatka("tenis", "Gra z Ewą w poniedziałek", true);
    
    Console.WriteLine("Podaj tytuł notatki:");
    string tytul = Console.ReadLine() ?? "";
    Notatka zwyklaNotatka = new Notatka(tytul);
    
    waznaNotatka.Wyswietl();
    zwyklaNotatka.Wyswietl();
    Wynik programu po tym kroku
    > konsola.exe
    Podaj tytuł notatki:
    spotkanie z kolegami
    ____________________
    Notatka WAŻNA! tenis
    Gra z Ewą w poniedziałek
    09.10.2026 15:51:42
    ____________________
    ____________________
    Notatka spotkanie z kolegami
    
    09.10.2026 15:51:42
    ____________________
  7. Krok 7: Folder konsolowa: archiwum, źródła i zrzut

    Kryteria: , ,

    R.1.6 Podjęta próba uruchomienia kodu, na zrzucie ekranowym widoczny jest uruchomiony program lub błędy jego kompilacji / interpretacji

    R.2.7 Program uruchamia się w konsoli, udokumentowane zrzutem ekranu

    R.4.6 Zapisany przynajmniej jeden zrzut ekranu z uruchomienia lub kompilacji aplikacji konsolowej

    ok. 3 min
    Polecenie z arkusza

    Kod aplikacji przygotuj do nagrania na płytę. W folderze konsolowa należy umieścić archiwum całego projektu i skopiowany z projektu plik z kodem źródłowym programu oraz plik wykonywalny, jeżeli istnieje. Aplikacja konsolowa – dowolna liczba zrzutów nazwanych konsola1, konsola2 ...

    Zrzut całego ekranu z Visual Studio i oknem konsoli (widoczny pasek zadań) - konsola1 w folderze dokumentacja (R.1.6, R.2.7, R.4.6). Folder projektu pakujesz do archiwum (po dopisaniu komentarza z części III), obok kopiujesz Notatka.cs, Program.cs i plik wykonywalny konsola.exe z bin\Debug\net8.0 razem z konsola.dll.

    Wynik programu bez zmian - taki jak po kroku 6.

  8. Etap 3: Aplikacja mobilna

    Kroki 8-10 · po tym etapie masz 21 z 33 kryteriów (pkt)

    Krok 8: Nowy projekt Notatnik (.NET MAUI)

    ok. 3 min
    Polecenie z arkusza

    Za pomocą środowiska programistycznego dostępnego na stanowisku egzaminacyjnym wykonaj aplikację mobilną służącą do zapisywania notatek użytkownika. Do wykonania zadania można zastosować klasę Notatka z aplikacji konsolowej.

    W Visual Studio: Utwórz nowy projekt → Aplikacja .NET MAUI, nazwa Notatnik (dotnet new maui -n Notatnik). Będziesz zmieniać MainPage.xaml (wygląd) i MainPage.xaml.cs (kod strony) i dodasz klasę Notatka. Strona jest osadzona w Shell - stąd pasek „Home” u góry.

    Ważne przy wyborze emulatora: klucz zaznacza, że aplikacja MAUI uruchomiona jako aplikacja Windows (Windows Machine) nie spełnia kryterium R.3.7 - na liście urządzeń trzeba wybrać emulator Androida.

    Notatnik/MainPage.xaml XAML nowy plik
    <?xml version="1.0" encoding="utf-8" ?>
    <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
                 xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                 x:Class="Notatnik.MainPage">
    
        <ScrollView>
            <VerticalStackLayout
                Padding="30,0"
                Spacing="25">
                <Image
                    Source="dotnet_bot.png"
                    HeightRequest="185"
                    Aspect="AspectFit"
                    SemanticProperties.Description="dot net bot in a submarine number ten" />
    
                <Label
                    Text="Hello, World!"
                    Style="{StaticResource Headline}"
                    SemanticProperties.HeadingLevel="Level1" />
    
                <Label
                    Text="Welcome to &#10;.NET Multi-platform App UI"
                    Style="{StaticResource SubHeadline}"
                    SemanticProperties.HeadingLevel="Level2"
                    SemanticProperties.Description="Welcome to dot net Multi platform App U I" />
    
                <Button
                    x:Name="CounterBtn"
                    Text="Click me" 
                    SemanticProperties.Hint="Counts the number of times you click"
                    Clicked="OnCounterClicked"
                    HorizontalOptions="Fill" />
            </VerticalStackLayout>
        </ScrollView>
    
    </ContentPage>
    Notatnik/MainPage.xaml.cs C# nowy plik
    namespace Notatnik;
    
    public partial class MainPage : ContentPage
    {
    	int count = 0;
    
    	public MainPage()
    	{
    		InitializeComponent();
    	}
    
    	private void OnCounterClicked(object? sender, EventArgs e)
    	{
    		count++;
    
    		if (count == 1)
    			CounterBtn.Text = $"Clicked {count} time";
    		else
    			CounterBtn.Text = $"Clicked {count} times";
    
    		SemanticScreenReader.Announce(CounterBtn.Text);
    	}
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  9. Krok 9: Strona AliceBlue, napis „Notatki” i lista CollectionView

    Kryteria: , , ,

    R.3.1 Interfejs użytkownika zdefiniowany zgodnie z wybraną technologią (np. XML, XAML lub w przypadku Swift w kodzie źródłowym) oraz zastosowano rozkład liniowy (LinearLayout / StackLayout lub inny o tej idei)

    R.3.2 Zastosowana kontrolka widoku listy (np. ListView)

    R.3.3 Zastosowane kontrolki: cztery tekstowe ("Notatki", "Dodanie notatki", "Tytuł notatki:", "Treść notatki:") , dwie edycyjne oraz przycisku o treści DODAJ

    R.3.4 Nadane kolory: tła rozkładu lub strony AliceBlue (#F0F8FF) , czcionki przycisku i napisów "Notatki", "Dodanie notatki": MediumBlue (#0000CD) . Powiększona czcionka napisów "Notatki" i "Dodanie notatki"

    ok. 3 min
    Polecenie z arkusza

    Interfejs użytkownika zapisany za pomocą języka znaczników wspieranego w danym środowisku (np. XAML, XML). Zastosowany liniowy typ rozkładu z kolorem tła AliceBlue (#F0F8FF). Rozkład zawiera: napis o treści „Notatki”, rozmiar czcionki większy od pozostałych napisów, kolor tekstu MediumBlue (#0000CD). Lista (widok listy), której źródłem jest kolekcja przechowująca notatki jako elementy.

    Usuwasz przykładową treść szablonu (i licznik z MainPage.xaml.cs). Strona ma tło BackgroundColor="AliceBlue", a elementy stoją jeden pod drugim w VerticalStackLayout (R.3.1, R.3.4). Napis „Notatki” - kolor MediumBlue, największa czcionka 26 (R.3.3, R.3.4).

    Widok listy to CollectionView (R.3.2) - w .NET MAUI to zalecana kontrolka listy; starszy ListView też by przeszedł, ale w .NET 10 jest oznaczony jako przestarzały. Lista w VerticalStackLayout nie ma z góry ograniczonej wysokości, więc dajesz jej HeightRequest="420" - formularz dodawania stanie pod nią, w dolnej części ekranu, jak na ilustracji 2. Lista jest pusta, dopóki kod nie poda jej danych.

    Notatnik/MainPage.xaml XAML zmienione: 9 linii
    <?xml version="1.0" encoding="utf-8" ?>
    <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
                 xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                 x:Class="Notatnik.MainPage"
                 BackgroundColor="AliceBlue">
    
        <VerticalStackLayout Padding="10">
            <Label Text="Notatki"
                   FontSize="26"
                   TextColor="MediumBlue" />
    
            <CollectionView x:Name="NotesView"
                            HeightRequest="420" />
        </VerticalStackLayout>
    
    </ContentPage>
    Notatnik/MainPage.xaml.cs C# zmienione: 4 linie
    namespace Notatnik;
    
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  10. Krok 10: Formularz dodania: napisy, dwa pola i DODAJ

    Kryteria: ,

    R.3.3 Zastosowane kontrolki: cztery tekstowe ("Notatki", "Dodanie notatki", "Tytuł notatki:", "Treść notatki:") , dwie edycyjne oraz przycisku o treści DODAJ

    R.3.4 Nadane kolory: tła rozkładu lub strony AliceBlue (#F0F8FF) , czcionki przycisku i napisów "Notatki", "Dodanie notatki": MediumBlue (#0000CD) . Powiększona czcionka napisów "Notatki" i "Dodanie notatki"

    ok. 3 min
    Polecenie z arkusza

    Napis o treści „Dodanie notatki”, rozmiar czcionki większy od domyślnego rozmiaru, kolor tekstu MediumBlue (#0000CD). Napis o treści „Tytuł notatki: ”. Pole do wprowadzania tekstu. Napis o treści „Treść notatki: ”. Pole do wprowadzania tekstu. Przycisk o treści „DODAJ” o kolorze czcionki MediumBlue (#0000CD).

    Pod listą: „Dodanie notatki” w kolorze MediumBlue i czcionką 20 - większą od domyślnych 14, mniejszą od tytułu (R.3.3, R.3.4), dwa napisy z polami Entry o nazwach TitleEntry i ContentEntry oraz przycisk z tekstem MediumBlue (R.3.3, R.3.4).

    Przycisk ze stylu szablonu ma fioletowe tło #512BD4 - granatowy napis byłby na nim prawie nieczytelny. Dajesz mu jasne tło LightGray, jak na ilustracji 2 (arkusz koloru tła przycisku nie narzuca).

    Notatnik/MainPage.xaml XAML zmienione: 14 linii
    <?xml version="1.0" encoding="utf-8" ?>
    <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
                 xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                 x:Class="Notatnik.MainPage"
                 BackgroundColor="AliceBlue">
    
        <VerticalStackLayout Padding="10">
            <Label Text="Notatki"
                   FontSize="26"
                   TextColor="MediumBlue" />
    
            <CollectionView x:Name="NotesView"
                            HeightRequest="420" />
    
            <Label Text="Dodanie notatki"
                   FontSize="20"
                   TextColor="MediumBlue" />
    
            <Label Text="Tytuł notatki: " />
            <Entry x:Name="TitleEntry" />
    
            <Label Text="Treść notatki: " />
            <Entry x:Name="ContentEntry" />
    
            <Button Text="DODAJ"
                    TextColor="MediumBlue"
                    BackgroundColor="LightGray" />
        </VerticalStackLayout>
    
    </ContentPage>
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  11. Etap 4: Aplikacja mobilna - działanie

    Kroki 11-15 · po tym etapie masz 26 z 33 kryteriów (pkt)

    Krok 11: Klasa Notatka w projekcie MAUI: pola jako właściwości

    ok. 3 min
    Polecenie z arkusza

    Do wykonania zadania można zastosować klasę Notatka z aplikacji konsolowej.

    Kopiujesz Notatka.cs z konsoli do projektu i zmieniasz przestrzeń nazw na Notatnik. Jedna zmiana jest konieczna: lista MAUI wyświetla dane przez powiązania ({Binding Tytul}), a powiązania działają tylko z właściwościami, nie z polami. Dlatego dopisujesz { get; set; } - public string Tytul { get; set; } to właściwość automatyczna: z zewnątrz używa się jej jak pola, ale ma metody odczytu i zapisu, które widzi mechanizm powiązań.

    Konstruktory zostają bez zmian. Metodę Wyswietl pomijasz - pisze do konsoli, której w aplikacji mobilnej nie widać.

    Typowe błędy

    Publiczne pola zamiast właściwości w klasie wyświetlanej przez {Binding} - lista pokazuje puste wiersze: powiązanie nie znajduje właściwości o tej nazwie.

    Notatnik/Notatka.cs C# nowy plik
    namespace Notatnik;
    
    public class Notatka
    {
        public string Tytul { get; set; }
        public string Tresc { get; set; }
        public bool Wazna { get; set; }
        public DateTime DataDodania { get; set; }
    
        public Notatka(string tytul, string tresc, bool wazna)
        {
            Tytul = tytul;
            Tresc = tresc;
            Wazna = wazna;
            DataDodania = DateTime.Now;
        }
    
        public Notatka(string tytul)
        {
            Tytul = tytul;
            Tresc = "";
            Wazna = false;
            DataDodania = DateTime.Now;
        }
    }

    Ekran telefonu bez zmian - taki jak po kroku 10.

  12. Krok 12: ObservableCollection notatek jako źródło listy

    Kryteria: ,

    R.3.5 Jako źródło danych do widoku listy zdefiniowana jest dowolna kolekcja, tak aby jej zmiana powodowała zmianę wyświetlenia listy na ekranie. Lista przechowuje elementy notatki. Np. ArrayList<Notatka>, ObservableCollection<Notatka> (W Xamarin i .NET Maui kolekcja musi być Observable; w Android Studio stosowane jest notifyDataSetChanged() w połączeniu z ArrayAdapterem do ListView)

    R.3.7 Aplikacja kompiluje się i uruchamia w emulatorze aplikacji mobilnej, co udokumentowane jest zrzutem ekranu. Jej układ jest zgodny z ilustracją 2 lub 4 w arkuszu egzaminacyjnym. W stanie początkowym jest wyświetlana jedna notatka z dowolnym tytułem i treścią (w uruchomionej aplikacji lub na zrzucie i obowiązkowo w kodzie)

    ok. 4 min
    Polecenie z arkusza

    Lista (widok listy), której źródłem jest kolekcja przechowująca notatki jako elementy (kolekcja musi być typu, który jest możliwy do zastosowania z widokiem listy. Dodanie elementów do kolekcji jest widoczne w widoku listy). Stan początkowy: wyświetlona jest jedna notatka z dowolnym tytułem i treścią (ilustracja 2 lub 4).

    Kolekcja to ObservableCollection<Notatka> - lista obiektów notatek, która powiadamia podłączoną kontrolkę o każdym dodaniu i usunięciu elementu. Klucz pisze wprost: „w Xamarin i .NET MAUI kolekcja musi być Observable” (R.3.5). Na start dokładasz jedną notatkę (R.3.7), a NotesView.ItemsSource = notes łączy listę z kolekcją.

    Jak wygląda jeden wiersz, mówi ItemTemplate w XAML: dwa napisy powiązane z właściwościami notatki - pogrubiony tytuł i szara treść, jak na ilustracji 2. x:DataType="local:Notatka" podaje typ elementu (przestrzeń nazw local to twój projekt): powiązania są wtedy sprawdzane przy kompilacji i działają szybciej. Bez szablonu lista pokazałaby w każdym wierszu tylko nazwę klasy „Notatnik.Notatka”.

    Notatnik/MainPage.xaml XAML zmienione: 13 linii
    <?xml version="1.0" encoding="utf-8" ?>
    <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
                 xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                 xmlns:local="clr-namespace:Notatnik"
                 x:Class="Notatnik.MainPage"
                 BackgroundColor="AliceBlue">
    
        <VerticalStackLayout Padding="10">
            <Label Text="Notatki"
                   FontSize="26"
                   TextColor="MediumBlue" />
    
            <CollectionView x:Name="NotesView"
                            HeightRequest="420">
                <CollectionView.ItemTemplate>
                    <DataTemplate x:DataType="local:Notatka">
                        <VerticalStackLayout Padding="0,5">
                            <Label Text="{Binding Tytul}"
                                   FontAttributes="Bold" />
                            <Label Text="{Binding Tresc}"
                                   TextColor="Gray" />
                        </VerticalStackLayout>
                    </DataTemplate>
                </CollectionView.ItemTemplate>
            </CollectionView>
    
            <Label Text="Dodanie notatki"
                   FontSize="20"
                   TextColor="MediumBlue" />
    
            <Label Text="Tytuł notatki: " />
            <Entry x:Name="TitleEntry" />
    
            <Label Text="Treść notatki: " />
            <Entry x:Name="ContentEntry" />
    
            <Button Text="DODAJ"
                    TextColor="MediumBlue"
                    BackgroundColor="LightGray" />
        </VerticalStackLayout>
    
    </ContentPage>
    Notatnik/MainPage.xaml.cs C# zmienione: 6 linii
    using System.Collections.ObjectModel;
    
    namespace Notatnik;
    
    public partial class MainPage : ContentPage
    {
        private readonly ObservableCollection<Notatka> notes = [];
    
        public MainPage()
        {
            InitializeComponent();
            notes.Add(new Notatka("tenis", "Gra z Ewą w poniedziałek", true));
            NotesView.ItemsSource = notes;
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  13. Krok 13: DODAJ: nowa notatka na liście

    Kryteria: ,

    R.3.6 Zdefiniowana funkcja powiązana ze zdarzeniem kliknięcia przycisku. Funkcja dodaje do kolekcji notatkę, której tytuł i treść wpisane są w pola edycyjne

    R.3.8 Po wpisaniu tekstu do obu pól edycyjnych i wciśnięciu przycisku jest widoczny dodany nowy element listy (w uruchomionej aplikacji lub na zrzucie i obowiązkowo w kodzie)

    ok. 3 min
    Polecenie z arkusza

    Działanie aplikacji po wybraniu przycisku (ilustracja 3 lub 5): tworzony jest nowy element notatki z wartościami tytułu i treści pobranymi z pól edycyjnych, notatka nie jest ważna. Element jest dodawany do kolekcji oraz jest widoczny w widoku listy.

    Kliknięcie wiążesz w XAML: Clicked="OnAddClicked" (R.3.6). Metoda tworzy notatkę konstruktorem trójargumentowym z tytułem i treścią z pól (TitleEntry.Text, ContentEntry.Text) i false - nie jest ważna - i dodaje ją do kolekcji. Nic więcej nie trzeba: ObservableCollection sama powiadamia listę i nowa notatka pojawia się na końcu (R.3.8). W Androidzie to samo robi ręczne notifyDataSetChanged().

    Wpisz w podglądzie „Lekarz” i „Wizyta u laryngologa wtorek”, kliknij „DODAJ” - jak na ilustracji 3.

    Typowe błędy

    List<Notatka> zamiast ObservableCollection<Notatka> - notatka trafia do kolekcji, ale lista na ekranie się nie zmienia (R.3.5, R.3.8).

    Notatnik/MainPage.xaml XAML zmienione: 1 linia
    <?xml version="1.0" encoding="utf-8" ?>
    <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
                 xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                 xmlns:local="clr-namespace:Notatnik"
                 x:Class="Notatnik.MainPage"
                 BackgroundColor="AliceBlue">
    
        <VerticalStackLayout Padding="10">
            <Label Text="Notatki"
                   FontSize="26"
                   TextColor="MediumBlue" />
    
            <CollectionView x:Name="NotesView"
                            HeightRequest="420">
                <CollectionView.ItemTemplate>
                    <DataTemplate x:DataType="local:Notatka">
                        <VerticalStackLayout Padding="0,5">
                            <Label Text="{Binding Tytul}"
                                   FontAttributes="Bold" />
                            <Label Text="{Binding Tresc}"
                                   TextColor="Gray" />
                        </VerticalStackLayout>
                    </DataTemplate>
                </CollectionView.ItemTemplate>
            </CollectionView>
    
            <Label Text="Dodanie notatki"
                   FontSize="20"
                   TextColor="MediumBlue" />
    
            <Label Text="Tytuł notatki: " />
            <Entry x:Name="TitleEntry" />
    
            <Label Text="Treść notatki: " />
            <Entry x:Name="ContentEntry" />
    
            <Button Text="DODAJ"
                    Clicked="OnAddClicked"
                    TextColor="MediumBlue"
                    BackgroundColor="LightGray" />
        </VerticalStackLayout>
    
    </ContentPage>
    Notatnik/MainPage.xaml.cs C# zmienione: 5 linii
    using System.Collections.ObjectModel;
    
    namespace Notatnik;
    
    public partial class MainPage : ContentPage
    {
        private readonly ObservableCollection<Notatka> notes = [];
    
        public MainPage()
        {
            InitializeComponent();
            notes.Add(new Notatka("tenis", "Gra z Ewą w poniedziałek", true));
            NotesView.ItemsSource = notes;
        }
    
        private void OnAddClicked(object? sender, EventArgs e)
        {
            notes.Add(new Notatka(TitleEntry.Text, ContentEntry.Text, false));
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  14. Krok 14: Bez pustych notatek, pola gotowe na następną

    ok. 2 min
    Polecenie z arkusza

    Tworzony jest nowy element notatki z wartościami tytułu i treści pobranymi z pól edycyjnych, notatka nie jest ważna.

    Kliknięcie „DODAJ” przy pustych polach dodaje pusty wiersz. string.IsNullOrWhiteSpace sprawdza, czy tytuł nie jest pusty albo złożony z samych spacji - wtedy wychodzisz z metody (return) i notatka nie powstaje. Tytuł i treść przycinasz Trim(), a po dodaniu czyścisz oba pola - gotowe na następną notatkę.

    Klucz tego nie sprawdza, ale to dwie linie, które na zrzucie z egzaminu odróżniają dopracowaną aplikację od takiej, która przyjmuje puste wpisy.

    Notatnik/MainPage.xaml.cs C# zmienione: 7 linii
    using System.Collections.ObjectModel;
    
    namespace Notatnik;
    
    public partial class MainPage : ContentPage
    {
        private readonly ObservableCollection<Notatka> notes = [];
    
        public MainPage()
        {
            InitializeComponent();
            notes.Add(new Notatka("tenis", "Gra z Ewą w poniedziałek", true));
            NotesView.ItemsSource = notes;
        }
    
        private void OnAddClicked(object? sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(TitleEntry.Text))
            {
                return;
            }
            notes.Add(new Notatka(TitleEntry.Text.Trim(), ContentEntry.Text.Trim(), false));
            TitleEntry.Text = "";
            ContentEntry.Text = "";
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  15. Krok 15: Uruchomienie w emulatorze, zrzuty i folder mobilna

    Kryteria: ,

    R.3.7 Aplikacja kompiluje się i uruchamia w emulatorze aplikacji mobilnej, co udokumentowane jest zrzutem ekranu. Jej układ jest zgodny z ilustracją 2 lub 4 w arkuszu egzaminacyjnym. W stanie początkowym jest wyświetlana jedna notatka z dowolnym tytułem i treścią (w uruchomionej aplikacji lub na zrzucie i obowiązkowo w kodzie)

    R.4.7 Zapisany przynajmniej jeden zrzut ekranu z uruchomienia lub kompilacji aplikacji mobilnej, na zrzucie widoczne jest środowisko, w którym powstała aplikacja

    ok. 3 min
    Polecenie z arkusza

    Podejmij próbę kompilacji i emulacji aplikacji. Aplikacja mobilna – dowolna liczba zrzutów nazwanych mobilna1, mobilna2 ... (np. stan początkowy, po dodaniu elementu). W folderze mobilna: spakowany cały projekt aplikacji mobilnej, modyfikowane pliki źródłowe.

    Uruchamiasz aplikację (F5) na emulatorze Androida. Zrzuty całego ekranu z Visual Studio do folderu dokumentacja: mobilna1 - stan początkowy, mobilna2 - po dodaniu notatki (R.3.7, R.4.7). W folderze mobilna: archiwum projektu (bez folderów bin i obj), MainPage.xaml, MainPage.xaml.cs i Notatka.cs.

    Ekran telefonu bez zmian - taki jak po kroku 14.

  16. Etap 5: Dokumentacja

    Kroki 16-17 · po tym etapie masz 32 z 33 kryteriów (pkt)

    Krok 16: Nagłówek metody Wyswietl według listingu 1

    Kryteria: , , , ,

    R.4.1 Komentarz jest zgodny z Listingiem 1 arkusza egzaminacyjnego. Komentarz może być wieloliniowy lub kilka jednoliniowych, lub Docstrings (potrójny cudzysłów)

    R.4.2 W komentarzu umieszczona nazwa metody oraz opisane jej działanie

    R.4.3 W komentarzu umieszczone nazwa i krótki opis wszystkich parametrów lub "brak", gdy nie ma parametrów

    R.4.4 W komentarzu umieszczona nazwa typu zwracanego i opis co jest zwracane lub "brak"

    R.4.5 W komentarzu umieszczony numer zdającego

    ok. 3 min
    Polecenie z arkusza

    W kodzie źródłowym aplikacji konsolowej za pomocą komentarza utwórz jeden nagłówek do metody według wzoru z listingu 1. Komentarz powinien znaleźć się nad lub pod nazwą funkcji. W miejscu nawiasów <> należy podać odpowiednie opisy. W miejscu autor należy podać numer zdającego.

    Komentarz wieloliniowy /* ... */ nad metodą Wyswietl z polami listingu 1 (R.4.1): nazwa i opis działania (R.4.2), parametry - brak, bo metoda jest bezargumentowa (R.4.3), zwracany typ - brak (void) (R.4.4) - i autor (R.4.5). Na egzaminie w polu autor wpisujesz numer PESEL - tu stoi Bartosz Bryniarski. Klucz ocenia komentarz metody, nie konstruktora.

    konsola/Notatka.cs C# zmienione: 8 linii
    namespace konsola;
    
    public class Notatka
    {
        public string Tytul;
        public string Tresc;
        public bool Wazna;
        public DateTime DataDodania;
    
        public Notatka(string tytul, string tresc, bool wazna)
        {
            Tytul = tytul;
            Tresc = tresc;
            Wazna = wazna;
            DataDodania = DateTime.Now;
        }
    
        public Notatka(string tytul)
        {
            Tytul = tytul;
            Tresc = "";
            Wazna = false;
            DataDodania = DateTime.Now;
        }
    
        /*
          nazwa:        Wyswietl
          opis:         wypisuje notatkę w osobnych liniach: linia podkreślników, tytuł (ze słowem WAŻNA!
                        dla ważnej notatki), treść, data dodania, linia podkreślników
          parametry:    brak
          zwracany typ: brak (void)
          autor:        Bartosz Bryniarski
        */
        public void Wyswietl()
        {
            Console.WriteLine("____________________");
            if (Wazna)
            {
                Console.WriteLine($"Notatka WAŻNA! {Tytul}");
            }
            else
            {
                Console.WriteLine($"Notatka {Tytul}");
            }
            Console.WriteLine(Tresc);
            Console.WriteLine(DataDodania.ToString("dd.MM.yyyy HH:mm:ss"));
            Console.WriteLine("____________________");
        }
    }
    Wynik programu po tym kroku
    > konsola.exe
    Podaj tytuł notatki:
    spotkanie z kolegami
    ____________________
    Notatka WAŻNA! tenis
    Gra z Ewą w poniedziałek
    09.10.2026 15:51:46
    ____________________
    ____________________
    Notatka spotkanie z kolegami
    
    09.10.2026 15:51:46
    ____________________
  17. Krok 17: Plik egzamin

    Kryteria:

    R.4.8 Dokumentacja zawiera: nazwę systemu operacyjnego, nazwy środowisk programistycznych, emulatora, nazwy języków programowania

    ok. 2 min
    Polecenie z arkusza

    Utwórz plik tekstowy i nazwij go egzamin. Dokument powinien zawierać informacje o narzędziach wykorzystanych na egzaminie: nazwę systemu operacyjnego, nazwy środowisk programistycznych, nazwę emulatora dla aplikacji mobilnej, nazwy języków programowania.

    Plik tekstowy egzamin.txt (wystarczy Notatnik) w folderze dokumentacja: system, środowisko, emulator i języki (R.4.8).

    egzamin.txt Tekst nowy plik
    System operacyjny: Windows 11
    Środowisko programistyczne: Visual Studio (aplikacja konsolowa i aplikacja .NET MAUI)
    Emulator: Android Emulator - Pixel 8 (Android 16, API 36)
    Języki programowania: C# (aplikacja konsolowa i mobilna), XAML (wygląd aplikacji mobilnej)

    Wynik programu bez zmian - taki jak po kroku 16.

  18. Etap 6: Porównanie z wariantem Java + Android

    Kroki 18-19 · po tym etapie masz 32 z 33 kryteriów (pkt)

    Krok 18: Te same kryteria, inny zapis

    ok. 3 min
    Polecenie z arkusza

    Zastosowany obiektowy język programowania zgodny z zainstalowanym na stanowisku egzaminacyjnym: C++ lub C#, lub Java, lub Python.

    wymaganieC# + .NET MAUIJava + Android
    typ datyDateTime (DateTime.Now)LocalDateTime (LocalDateTime.now())
    format datyToString("dd.MM.yyyy HH:mm:ss")DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss")
    widok listyCollectionView z ItemTemplateListView z ArrayAdapter
    wygląd wierszaszablon XAML z {Binding}simple_list_item_1 + toString()
    odświeżenie listysamo - ObservableCollectionręcznie - notifyDataSetChanged()
    klasa w aplikacjipola zamienione na właściwościbez zmian (+ toString())

    W MAUI wiersz listy opisujesz w XAML i możesz go dowolnie ułożyć (tytuł pogrubiony, treść szara); w Androidzie systemowy wiersz pokazuje jeden napis z toString(). Za to w Androidzie klasę z konsoli przenosi się bez zmian, a w MAUI pola trzeba zamienić na właściwości.

    Wynik programu bez zmian - taki jak po kroku 16.

  19. Krok 19: Co wybrać na egzaminie

    ok. 2 min
    Polecenie z arkusza

    Za pomocą środowiska programistycznego dostępnego na stanowisku egzaminacyjnym wykonaj aplikację mobilną służącą do zapisywania notatek użytkownika.

    Klucz ocenia oba środowiska tymi samymi kryteriami, ale dla każdego ma swój warunek: w MAUI kolekcja musi być ObservableCollection, w Androidzie - ArrayAdapter z notifyDataSetChanged(). To najczęstsza pułapka tego arkusza: zwykła lista działa przy starcie, a nowa notatka nie pojawia się na ekranie.

    C# + .NET MAUI - jeden język, odświeżanie listy bez dodatkowego kodu; pierwsze budowanie projektu na Androida trwa kilka minut, więc emulator i pusty projekt warto uruchomić na początku egzaminu, a urządzeniem musi być emulator Androida, nie Windows Machine. Java + Android Studio - najczęstsze środowisko na stanowiskach, klasa z konsoli przechodzi bez zmian.

    Wynik programu bez zmian - taki jak po kroku 16.

  20. Etap 7: Oddanie pracy

    Krok 20 · po tym etapie masz 33 z 33 kryteriów (pkt)

    Krok 20: Nagranie płyty

    Kryteria:

    R.4.9 Przygotowana jest dokumentacja w postaci płyty: oba projekty są spakowane oraz zmodyfikowane pliki są umieszczone na zewnątrz archiwów

    ok. 5 min
    Polecenie z arkusza

    Nagraj płytę z rezultatami pracy. W folderze z numerem zdającego powinny się znajdować trzy foldery: dokumentacja, konsolowa i mobilna.

    Sprawdzasz zawartość przed nagraniem (R.4.9):

    • konsolowa: archiwum projektu (po dopisaniu komentarza), Notatka.cs, Program.cs, konsola.exe z konsola.dll,
    • mobilna: archiwum projektu, MainPage.xaml, MainPage.xaml.cs, Notatka.cs,
    • dokumentacja: konsola1, mobilna1, mobilna2, egzamin.txt.

    Nagrywasz, sprawdzasz odczyt płyty, opisujesz ją numerem zdającego.

    Wynik programu bez zmian - taki jak po kroku 16.

Podgląd

To jedno z możliwych rozwiązań. Egzaminator ocenia spełnienie kryteriów z klucza odpowiedzi, a nie zgodność z tym kodem - inna, poprawna droga też daje punkty.

Autor rozwiązania: . Licencja CC BY-NC 4.0 - kopiowanie i przeróbki do celów niekomercyjnych, z podaniem autora i źródła (link do tej strony) (zasady wykorzystania). Treść arkusza i klucza oceniania pochodzi z CKE.