Niniejsze laboratorium skupia się na aspekcie trwałości danych. Poznasz mechanizmy pozwalające na zapisywanie stanu aplikacji do plików tekstowych i binarnych, nauczysz się bezpiecznego zarządzania zasobami systemowymi za pomocą instrukcji `using` oraz zgłębisz techniki optymalizacji I/O niezbędne w systemach dużej skali.
Spis treści
- Archiwizacja sprzedaży dziennej - Praca z File i Path.Combine
- Rejestrator wydajności masowej - Optymalizacja strumieniowa StreamWriter
- Menedżer konfiguracji salonu - Techniki odczytu danych tekstowych
- Cyfrowa czarna skrzynka - Serializacja niskopoziomowa BinaryWriter
- Generator krzywych telemetrycznych - Integracja klasy Math z systemem plików
- Inteligentny procesor ścieżek - Automatyzacja zarządzania strukturą dokumentów
- System bezpiecznego dostępu - Obsługa wyjątków i stanów krytycznych I/O
- Uniwersalny generator raportów - Architektura metod statycznych w I/O
- Hierarchia plików Auto-Premium - Logika biznesowa w przestrzeniach nazw
- Zintegrowany audytor systemowy - Kompleksowe przetwarzanie end-to-end
Poznanie podstawowych metod narzędziowych klasy `File` oraz nauka bezpiecznego konstruowania ścieżek systemowych w sposób niezależny od platformy.
Sieć luksusowych salonów Auto-Premium potrzebuje niezawodnego mechanizmu do szybkiego zapisu raportów sprzedaży na koniec dnia. Każdy salon generuje listę sprzedanych pojazdów, która musi trafić do dedykowanego folderu archiwalnego na dysku lokalnym terminala. Jako inżynier oprogramowania musisz przygotować moduł, który automatycznie sprawdzi istnienie katalogu "Archiwum" i w razie jego braku - utworzy go bez ingerencji operatora. Plik z listą aut powinien mieć czytelną nazwę i zawierać dane w formacie tekstowym, gotowym do późniejszego importu. Kluczowym aspektem jest zapewnienie stałej struktury plików, niezależnie od tego, czy system działa pod kontrolą Windows czy Linux. Wykorzystasz do tego zaawansowane metody manipulacji ścieżkami, które eliminują błędy wynikające z ręcznego sklejania ciągów znaków. System ma być prosty w obsłudze, ale technicznie bezbłędny, stanowiąc fundament dla późniejszych analiz księgowych. Twoim zadaniem jest zapewnienie, że żadna transakcja nie zostanie pominięta w dziennym raporcie. Raporty te są kluczowe dla monitorowania płynności finansowej salonu i planowania dostaw nowych modeli z fabryk. To Twoje pierwsze wyzwanie w zakresie persystencji danych w ekosystemie luksusowej marki.
W rozwiązaniu wykorzystujemy przestrzeń nazw `System.IO`, która jest sercem operacji wejścia/wyjścia w .NET. Metoda `Directory.CreateDirectory` jest idempotentna, co oznacza, że wywołana wielokrotnie dla tego samego folderu nie spowoduje błędów, jeśli folder już istnieje. Kluczowym elementem jest użycie statycznej metody `Path.Combine`, która inteligentnie łączy fragmenty ścieżki (folder, podfolder, plik), dbając o poprawne separatory ścieżki (`\` lub `/`) charakterystyczne dla systemu operacyjnego. Do samego zapisu wykorzystujemy `File.WriteAllLines`, która jest wysokopoziomową metodą "one-shot". Automatycznie otwiera ona plik, zapisuje tablicę lub kolekcję tekstową (każdy element w nowej linii) przy użyciu kodowania UTF-8 i bezpiecznie zamyka zasób. Jest to rozwiązanie idealne dla małych i średnich zestawów danych, gdzie prostota implementacji jest priorytetem. Zauważ, że metoda ta nadpisuje istniejący plik o tej samej nazwie, co jest pożądane przy generowaniu raportów dziennych o stałej nazwie. Program demonstruje, jak minimalnym nakładem kodu można zbudować solidny fundament do pracy z systemem plików. Operacje te są wykonywane synchronicznie, blokując wątek do czasu zakończenia zapisu na nośnik fizyczny. Pamiętaj, że dostęp do plików wymaga odpowiednich uprawnień w systemie operacyjnym, o co dbają niższe warstwy runtime'u .NET.
using System.IO;
namespace AutoPremium.Files
{
class SalesArchiver
{
static void Main()
{
// 1. Definicja danych do zapisu
string[] sprzedaneAuta = { "Lamborghini Revuelto", "Ferrari Purosangue", "Porsche 911 GT3" };
// 2. Przygotowanie struktury katalogów
string folderArchiwum = "Archiwum";
Directory.CreateDirectory(folderArchiwum);
// 3. Bezpieczne łączenie ścieżki za pomocą Path.Combine
string sciezkaPliku = Path.Combine(folderArchiwum, "raport_dzienny.txt");
Console.WriteLine("Inicjalizacja zapisu raportu...");
// 4. Szybki zapis całości do pliku (kodowanie UTF-8)
File.WriteAllLines(sciezkaPliku, sprzedaneAuta);
Console.WriteLine($"Raport został zapisany pomyślnie w lokalizacji: {sciezkaPliku}");
}
}
}
Raport został zapisany pomyślnie w lokalizacji: Archiwum\raport_dzienny.txt
(Plik zawiera 3 linie z modelami pojazdów)
Zrozumienie mechanizmu buforowanego zapisu dużych zbiorów danych za pomocą klasy `StreamWriter` oraz nauka automatycznego zarządzania zasobami za pomocą instrukcji `using`.
W trakcie ekstremalnych testów torowych nowego supersamochodu koncepcyjnego Auto-Premium Genesis, zintegrowane systemy pokładowe generują tysiące odczytów na sekundę z sensorów silnika i aerodynamiki. Standardowe metody zapisu całego zbioru danych naraz są w tym przypadku nieakceptowalne, ponieważ mogłyby doprowadzić do przepełnienia pamięci RAM lub niekontrolowanego zawieszenia terminala diagnostycznego w krytycznym momencie testu. Twoim zadaniem jako programisty systemowego jest zaimplementowanie wysoce wydajnego modułu rejestrującego telemetrię bezpośrednio do strumienia plikowego. Program ma symulować generowanie serii 10 000 odczytów (np. prędkości obrotowej silnika RPM) i zapisywać je linia po linii, wykorzystując mechanizm buforowania, który zapewnia minimalne obciążenie zasobów. Każdy wpis musi być precyzyjnie oznaczony numerem próbki, co umożliwi późniejszą synchronizację danych z nagraniami wideo z kamer pokładowych. Salon Auto-Premium kładzie ogromny nacisk na rzetelność danych z testów obciążeniowych, dlatego Twój kod musi być napisany zgodnie z najlepszymi praktykami profesjonalnego programowania, dbając o poprawne zwolnienie uchwytów do plików w każdych warunkach. System ten będzie stanowić serce większego ekosystemu analitycznego "Auto-Premium Data Insights", wspierając inżynierów w optymalizacji osiągów bolidu przed jego oficjalną premierą na targach w Genewie. Każda sekunda pracy jednostki napędowej musi zostać uwieczniona w archiwum cyfrowym marki, aby zapewnić najwyższą jakość i bezpieczeństwo przyszłym nabywcom. To zadanie uczy Cię profesjonalnego podejścia do inżynierii danych w świecie luksusowej motoryzacji klasy high-end.
W tym zadaniu fundamentem jest wykorzystanie klasy `StreamWriter`, która stanowi nakładkę na strumień plikowy i pozwala na wydajny zapis tekstu poprzez mechanizm buforowania danych. Zamiast otwierać plik dla każdej linii z osobna, `StreamWriter` gromadzi porcję danych w pamięci wewnętrznej i przesyła ją na dysk w optymalnych paczkach, co drastycznie zwiększa szybkość operacji I/O. Kluczowym elementem składni jest instrukcja `using`, która definiuje zakres (scope), w którym obiekt strumienia jest aktywny. Po wyjściu z bloku `using` (nawet w przypadku wystąpienia błędu), platforma .NET automatycznie wywołuje metodę `Dispose()`, co gwarantuje natychmiastowe zamknięcie pliku i zwolnienie zasobów systemowych – jest to tzw. "bezpieczne zarządzanie zasobami". Wewnątrz pętli `for` generujemy 10000 iteracji, gdzie każda linia jest tworzona za pomocą metody `WriteLineAsync` lub `WriteLine` (tutaj standardowa wersja synchroniczna dla prostoty). Zauważ, że konstruktor `new StreamWriter(sciezka)` domyślnie nadpisuje plik, ale można go przełączyć w tryb dopisywania (append), podając drugi parametr jako `true`. Praca ze strumieniami jest nieodzowna przy logowaniu zdarzeń, przetwarzaniu plików XML/JSON o dużej objętości czy komunikacji sieciowej. Zrozumienie, że plik jest zasobem unikalnym i blokowanym przez system operacyjny, jest kluczowe dla uniknięcia błędów typu `IOException`. Program ten stanowi doskonały przykład, jak zachować wysoką wydajność systemu przy generowaniu masowych raportów technicznych.
using System.IO;
namespace AutoPremium.Logging
{
class MassTelemetryLogger
{
static void Main()
{
string logPath = "telemetry_log.txt";
Random rnd = new Random();
Console.WriteLine("[START] Rejestracja masowej telemetrii...");
// Użycie instrukcji USING gwarantuje poprawne zamknięcie strumienia
using (StreamWriter sw = new StreamWriter(logPath))
{
sw.WriteLine("--- LOG TELEMETRYCZNY AUTO-PREMIUM ---");
sw.WriteLine($"Data testu: {DateTime.Now}");
for (int i = 1; i <= 10000; i++)
{
int rpm = rnd.Next(800, 9500);
// Zapisujemy dane do bufora strumienia
sw.WriteLine($"Próbka #{i:D5} | Silnik: {rpm} RPM");
}
}
Console.WriteLine("[STOP] Zapisano 10 000 odczytów do pliku.");
}
}
}
[STOP] Zapisano 10 000 odczytów do pliku.
(Plik 'telemetry_log.txt' został utworzony w folderze programu)
Opanowanie metod odczytu plików tekstowych przy użyciu klasy `File` oraz strumieniowego przetwarzania linii za pomocą `StreamReader`.
Prawidłowe funkcjonowanie salonu Auto-Premium zależy od setek parametrów konfiguracyjnych, takich jak godziny otwarcia, limity rabatowe czy adresy serwerów autoryzujących transakcje leasingowe. Zamiast "wpisywać na sztywno" te dane w kodzie źródłowym, nowoczesne systemy informatyczne salonów wykorzystują pliki konfiguracyjne, które mogą być łatwo edytowane przez administratorów technicznych bez konieczności ponownego kompilowania całej aplikacji. Twoim zadaniem jest stworzenie inteligentnego modułu konfiguracyjnego, który bezpiecznie wczyta dane z pliku `salon_config.txt` do pamięci operacyjnej systemu. Program musi wykazać się inteligencją: najpierw powinien sprawdzić, czy plik fizycznie znajduje się na dysku, aby zapobiec nagłemu zamknięciu aplikacji z błędem krytycznym przed przyjściem pierwszego klienta. Następnie, przy użyciu strumienia odczytu, moduł ma linia po linii przeanalizować zawartość i wyłuskać kluczowe informacje dla kierownika zmiany. Takie rozwiązanie gwarantuje niespotykaną elastyczność – gdy salon zmienia parametry usług lub dodaje nową linię luksusowych dodatków, wystarczy edycja pliku tekstowego w prostym edytorze. Twój kod musi odzwierciedlać dbałość o detale i profesjonalizm godny marki Premium, zapewniając bezbłędny start wszystkich terminali w salonie o każdej porze dnia. System ten stanowi fundament pod budowanie skalowalnych aplikacji biznesowych, gdzie dane są odseparowane od logiki wykonawczej. Scenariusz ten uczy Cię myślenia systemowego i odpowiedzialności za ciągłość procesów handlowych w dynamicznym środowisku salonu motoryzacyjnego.
W procesie odczytu danych kluczową rolę odgrywa statyczna metoda `File.Exists(path)`, która pozwala na bezbłędne zweryfikowanie fizycznej obecności pliku przed próbą jego otwarcia. Jest to przykład programowania defensywnego, które chroni aplikację przed nieprzewidzianymi sytuacjami (np. przypadkowym usunięciem pliku przez pracownika serwisu). Do samego odczytu możemy wykorzystać `File.ReadAllLines`, która wczytuje cały plik naraz do tablicy stringów – co jest idealne przy plikach konfiguracyjnych małej wielkości. Jednak dla większej kontroli i optymalizacji pamięciowej, warto poznać klasę `StreamReader`. Pozwala ona na liniowy odczyt pliku przy użyciu pętli `while`, gdzie warunkiem jest nieosiągnięcie końca strumienia (`EndOfStream`). Metoda `ReadLine()` zwraca pojedynczą linię jako string, co umożliwia jej natychmiastowe przetworzenie lub walidację. Zastosowanie instrukcji `using` w połączeniu ze `StreamReader` jest standardem branżowym, zapewniającym, że uchwyt do pliku zostanie zwolniony natychmiast po przeczytaniu ostatniego znaku. Zauważ, że odczyt tekstowy interpretuje bajty na dysku przy użyciu określonego kodowania (domyślnie UTF-8), co jest istotne przy poprawnym wyświetlaniu polskich znaków diakrytycznych w nazwach salonów. Program demonstruje, jak płynnie przechodzić między fizycznym plikiem a strukturami danych wewnątrz języka C#, co jest kluczową umiejętnością przy tworzeniu systemów CRM i ERP.
using System.IO;
namespace AutoPremium.Config
{
class ConfigManager
{
static void Main()
{
string path = "salon_config.txt";
// 1. Symulacja istnienia pliku (w realnym scenariuszu musi być na dysku)
if (!File.Exists(path))
{
Console.WriteLine("[BŁĄD] Plik konfiguracyjny nie został znaleziony!");
File.WriteAllText(path, "Salon: Auto-Premium HQ\nLokalizacja: Warszawa\nTerminal: 192.168.1.100");
Console.WriteLine("[INFO] Wygenerowano domyślną konfigurację.");
}
Console.WriteLine("--- WCZYTYWANIE USTAWIEŃ SYSTEMOWYCH ---");
// 2. Odczyt strumieniowy za pomocą StreamReader
using (StreamReader sr = new StreamReader(path))
{
string linia;
int numerLinii = 1;
while ((linia = sr.ReadLine()) != null)
{
Console.WriteLine($"Parametr {numerLinii}: {linia}");
numerLinii++;
}
}
Console.WriteLine("--- KONFIGURACJA ZAŁADOWANA POMYŚLNIE ---");
}
}
}
Parametr 1: Salon: Auto-Premium HQ
Parametr 2: Lokalizacja: Warszawa
Parametr 3: Terminal: 192.168.1.100
--- KONFIGURACJA ZAŁADOWANA POMYŚLNIE ---
Poznanie technik zapisu i odczytu danych w formacie binarnym przy użyciu klas `BinaryWriter` i `BinaryReader` w celu optymalizacji przestrzeni dyskowej oraz ochrony spójności danych.
Każdy prototypowy pojazd klasy Premium opracowywany przez Auto-Premium posiada system chroniony przed modyfikacją – tzw. "cyfrową czarną skrzynkę". Rejestruje ona kluczowe parametry techniczne przejazdów testowych w gęstym formacie binarnym, co stanowi ogromną oszczędność miejsca w porównaniu do standardowych plików tekstowych. Co więcej, format binarny jest trudniejszy do przypadkowego uszkodzenia lub niepożądanego odczytu przez osoby trzecie, co realnie chroni tajemnice technologiczne inżynierów marki. Twoim zadaniem jest stworzenie modułu pokładowego, który zapisze do zabezpieczonego pliku `blackbox.dat` zestaw trzech kluczowych wartości: aktualną prędkość bolidu (double), obroty silnika (int) oraz logiczny status systemów wspomagających trakcję (bool). Po zakończeniu cyklu testowego, program musi bezbłędnie "odtworzyć przebieg zdarzeń", odczytując te same dane w identycznej kolejności, w jakiej zostały zapisane na pokładzie maszyny. Taka precyzja jest kluczowa przy powypadkowej analizie zachowania pojazdu przez ekspertów oraz przy precyzyjnym strojeniu map silnika przed startem w wyścigach endurance. Salon Auto-Premium dostarcza swoim klientom technologię jutra, a Twój kod jest technologicznym fundamentem, na którym inżynierowie budują zaufanie do systemów bezpieczeństwa. Scenariusz ten wprowadza Cię w świat niskopoziomowego składowania informacji, gdzie liczy się każdy bajt i każda bitowa informacja ma swoje ściśle określone miejsce w archiwum systemowym. Budujesz tutaj profesjonalny system logowania technicznego godny marki Premium. To doskonałe ćwiczenie z dbałości o strukturę i bezpieczeństwo danych.
W tym zadaniu odchodzimy od czytelności "ludzkiej" na rzecz efektywności maszynowej. Używamy klas `BinaryWriter` i `BinaryReader`, które operują bezpośrednio na bajtach strumienia `FileStream`. W przeciwieństwie do strumieni tekstowych, te klasy zapisują zmienne w ich naturalnej, binarnej reprezentacji w pamięci (np. `double` zajmie zawsze dokładnie 8 bajtów, niezależnie od liczby cyfr po przecinku). Kluczowe jest zachowanie identycznej kolejności zapisu i odczytu – jeśli najpierw zapisaliśmy `double`, musimy najpierw wywołać `ReadDouble()`, w przeciwnym razie dane zostaną źle zinterpretowane (nastąpi przesunięcie wskaźnika pozycji w pliku). Strumień `FileStream` z parametrem `FileMode.Create` zapewnia utworzenie nowego pliku, a `using` dba o to, by po operacji plik został poprawnie zamknięty i zapisany (flush) na nośnik fizyczny. Zaletą tej metody jest niewrażliwość na ustawienia regionalne systemu (separatory dziesiętne nie istnieją w świecie binarnym), co czyni ją idealną do międzynarodowych platform diagnostycznych. Kolejność zapisu bitów (Endianness) jest zarządzana przez procesor, ale framework .NET dba o to, by dane były spójne i przenośne między różnymi architekturami sprzętowymi. Program stanowi świetny wstęp do protokołów komunikacyjnych i tworzenia własnych formatów plików. Pamiętaj, że do odczytania takiego pliku w popularnym edytorze tekstu zobaczysz "znaki specjalne" (tzw. śmieci), co jest naturalnym zachowaniem dla plików binarnych.
using System.IO;
namespace AutoPremium.BlackBox
{
class DataRecorder
{
static void Main()
{
string fileName = "blackbox.dat";
// DANE DO ZAPISU
double currentSpeed = 285.5;
int engineRPM = 6800;
bool tractionControlOn = true;
Console.WriteLine("[BOX] Zapisywanie parametrów binarnych...");
// 1. ZAPIS BINARNY
using (BinaryWriter bw = new BinaryWriter(File.Open(fileName, FileMode.Create)))
{
bw.Write(currentSpeed);
bw.Write(engineRPM);
bw.Write(tractionControlOn);
}
Console.WriteLine("[BOX] Odczytywanie danych z czarnej skrzynki:\n");
// 2. ODCZYT BINARNY (Musi być w tej samej kolejności co zapis!)
using (BinaryReader br = new BinaryReader(File.Open(fileName, FileMode.Open)))
{
double readSpeed = br.ReadDouble();
int readRPM = br.ReadInt32();
bool readTraction = br.ReadBoolean();
Console.WriteLine($"Prędkość odczytana: {readSpeed} km/h");
Console.WriteLine($"Obroty odczytane: {readRPM} RPM");
Console.WriteLine($"Kontrola trakcji: {(readTraction ? "AKTYWNA" : "BŁĄD")}");
}
}
}
}
[BOX] Odczytywanie danych z czarnej skrzynki:
Prędkość odczytana: 285,5 km/h
Obroty odczytane: 6800 RPM
Kontrola trakcji: AKTYWNA
Zaawansowane wykorzystanie metod klasy `Math` do generowania zbiorów danych pomiarowych oraz ich archiwizacja w celu późniejszej analizy i wizualizacji.
W dziale badań i rozwoju (R&D) salonu Auto-Premium inżynierowie zawieszenia projektują nowatorskie amortyzatory magnetyczne o zmiennej twardości w czasie rzeczywistym. Aby poprawnie zaprogramować sterownik, konieczne jest przeprowadzenie symulacji charakterystyki tłumienia drgań podczas pokonywania nierówności drogi przy wysokich prędkościach. Twoim zadaniem jest stworzenie modułu matematyczno-telemetrycznego, który wygeneruje i zapisze do pliku `vibration_test.csv` serię 100 punktów pomiarowych, symulujących fizyczną krzywą drgań tłumionych (modelowaną za pomocą funkcji sinus połączonej z zanikiem eksponencjalnym). Każda para danych (czas i odpowiadająca mu amplituda drgań) musi zostać zapisana jako oddzielna linia tekstu, co pozwoli na błyskawiczny import wyników do systemów analitycznych typu Matlab czy Microsoft Excel przez inżynierów mechaników. Salon Auto-Premium kładzie ogromy nacisk na komfort podróży, dlatego precyzja Twoich obliczeń bezpośrednio przełoży się na płynność pracy zawieszenia w przyszłych flagowych modelach marki. Dzięki wykorzystaniu klasy `Math`, Twój program stanie się profesjonalnym narzędziem symulacyjnym, udowadniając, że informatyka jest nierozłącznym elementem współczesnej inżynierii Premium. Każdy punkt na wykresie to kolejna cegiełka do budowy najwygodniejszych samochodów na świecie. Scenariusz ten łączy pragmatyczne programowanie z matematycznym modelowaniem zjawisk fizycznych, co jest znakiem rozpoznawczym wysokiej klasy inżyniera oprogramowania.
W tym zadaniu integrujemy świat logiki obliczeniowej z systemem plików. Wykorzystujemy klasę statyczną `Math`, która jest częścią biblioteki bazowej .NET i dostarcza stałych takich jak `Math.PI` oraz metod `Sin()`, `Exp()` czy `Pow()`. Obliczenia są wykonywane wewnątrz pętli `for` przy użyciu typu zmiennoprzecinkowego `double`. Kluczowym modelem matematycznym jest tu `f(x) = sin(x) * exp(-x/10)`, co symuluje naturalny proces tłumienia energii drgań w czasie. Tak wygenerowane współrzędne łączymy w jeden ciąg tekstowy, gdzie separatorem jest przecinek lub średnik (zależnie od standardu CSV). Do zapisu wykorzystujemy `StreamWriter`, który otwiera kanał komunikacji z plikiem tekstowym. Zwróć uwagę na formatowanie wyjścia za pomocą `:F4`, które ogranicza liczbę miejsc po przecinku do czterech – jest to standardowa precyzja w inżynierii danych pomiarowych. Pliki CSV (Comma Separated Values) są uniwersalnym standardem wymiany danych między różnymi systemami na całym świecie. Program uczy, jak przetwarzać i utrwalać wyniki skomplikowanych algorytmów numerycznych, co ma kluczowe znaczenie przy tworzeniu systemów BI (Business Intelligence) oraz dashboardów inżynierskich. Wiedza o tym, jak powstają binarne i tekstowe reprezentacje funkcji matematycznych, jest niezbędna w pracy każdego inżyniera-programisty.
using System.IO;
namespace AutoPremium.Simulation
{
class VibrationSim
{
static void Main()
{
string exportPath = "vibration_test.csv";
Console.WriteLine("=== MODUŁ SYMULACJI ZAWIESZENIA R&D ===");
// Inicjalizacja strumienia zapisu danych telemetrycznych
using (StreamWriter writer = new StreamWriter(exportPath))
{
writer.WriteLine("Czas[ms];Amplituda[mm]"); // Nagłówek pliku CSV
for (int t = 0; t < 100; t++)
{
// Obliczenie f(x) = sin(x) * e^(-x/50.0)
double radian = t * (Math.PI / 10.0);
double amplituda = Math.Sin(radian) * Math.Exp(-t / 50.0);
// Zapis sformatowanej linii do pliku CSV
writer.WriteLine("{0};{1:F4}", t, amplituda);
}
}
Console.WriteLine($"Pomyślnie wyeksportowano 100 punktów do: {exportPath}");
Console.WriteLine("Dane są gotowe do analizy w dziale inżynieryjnym.");
}
}
}
Pomyślnie wyeksportowano 100 punktów do: vibration_test.csv
Dane są gotowe do analizy w dziale inżynieryjnym.
(Plik zawiera nagłówek i dane oddzielone średnikami)
Zaawansowana manipulacja metadanymi plików oraz automatyzacja reorganizacji zasobów cyfrowych za pomocą metod klasy `System.IO.Path`.
W dziale marketingu i PR luksusowej marki Auto-Premium tysiące plików graficznych, instrukcji technicznych oraz specyfikacji pojazdów są gromadzone każdego dnia. Niestety, często trafiają one do systemu z niepoprawnymi nazwami, zawierającymi spacje lub błędne rozszerzenia, co uniemożliwia ich szybkie indeksowanie w globalnej bazie dokumentacji. Twoim zadaniem jest stworzenie inteligentnego procesora ścieżek, który przyjmie pełny adres fizyczny pliku i "rozbierze" go na czynniki pierwsze dla potrzeb centralnego rejestru. Program musi wyodrębnić samą nazwę pliku, jego aktualne rozszerzenie oraz nazwę folderu nadrzędnego, co pozwoli na kategoryzację dokumentów według salonu pochodzenia. Dodatkowo, system ma za zadanie automatycznie "wyczyścić" profil pliku, sugerując nową nazwę z ujednoliconym rozszerzeniem `.apdata` (Auto-Premium Data Assets). Salon stawia na perfekcyjną architekturę w każdym calu – od silników V12 po porządek w danych cyfrowych – dlatego Twój moduł musi być bezbłędny. Dzięki temu rozwiązaniu, nawet pracownicy niższego szczebla będą mogli błyskawicznie odnaleźć odpowiednią dokumentację dla wymagającego klienta segmentu Premium. Twoja praca bezpośrednio wpłynie na efektywność komunikacji między salonem a centralą marki, eliminując cyfrowy chaos, który mógłby opóźnić realizację luksusowych zamówień. Scenariusz ten uczy Cię sprawnego posługiwania się strukturą plików w ekosystemie .NET, co jest fundamentalne przy budowie profesjonalnych systemów archiwizacji i zarządzania treścią (CMS). To wyzwanie, w którym inżynieryjna dbałość o szczegóły spotyka się z praktyczną potrzebą uporządkowanego świata danych marki Auto-Premium.
W procesie manipulacji ścieżkami kluczową rolę odgrywa klasa statyczna `Path`, która chroni programistę przed wieloma błędami wynikającymi z różnic w systemach operacyjnych. Metoda `GetFileNameWithoutExtension` pozwala na izolację samej nazwy dokumentu, co jest niezbędne przy generowaniu metadanych w bazach SQL. Z kolei `GetExtension` wyodrębnia typ pliku wraz z kropką, umożliwiając walidację dopuszczalnych formatów (np. czy to zdjęcie JPG czy instrukcja PDF). Jedną z najciekawszych metod jest `ChangeExtension`, która nie zmienia fizycznie pliku na dysku, ale generuje nową reprezentację tekstową ścieżki z podmienionym rozszerzeniem – co idealnie nadaje się do planowania operacji zmiany nazw i przenoszenia plików w pętlach systemowych. Warto zauważyć, że metoda `GetDirectoryName` zwraca pełną ścieżkę do folderu, pozwalając na łatwe poruszanie się w hierarchii drzewa katalogów. Praca z klasą `Path` jest o wiele bezpieczniejsza niż ręczna manipulacja stringami, ponieważ .NET bierze na siebie obsługę znaków zabronionych i specyficznych separatorów. Zrozumienie, że ścieżka to logiczny adres zasobu, a nie tylko ciąg znaków, jest kluczowe dla pisania przenośnych aplikacji klasy korporacyjnej. Program pokazuje również, jak interpolacja ciągów znaków doskonale współpracuje z metadanymi systemowymi, tworząc czytelne raporty diagnostyczne. To podstawowe narzędzie w arsenale każdego inżyniera-programisty C# pracującego z systemami plików.
using System.IO;
namespace AutoPremium.DocumentProcessor
{
class PathAnalyzer
{
static void Main()
{
// Symulacja wejściowej, "brudnej" ścieżki z systemu zewnętrznego
string brudnaSciezka = @"C:\AutoPremium\Instrukcje_2026\Manual_Model_S8.pdf";
Console.WriteLine("ANALIZA METADANYCH ZASOBU CYFROWEGO");
Console.WriteLine(new string('-', 40));
// 1. Rozbicie ścieżki na składowe
string folder = Path.GetDirectoryName(brudnaSciezka);
string nazwaBezRozszerzenia = Path.GetFileNameWithoutExtension(brudnaSciezka);
string rozszerzenie = Path.GetExtension(brudnaSciezka);
// 2. Generowanie nowej propozycji ścieżki (systemowej)
string nowaSciezka = Path.ChangeExtension(brudnaSciezka, ".apdata");
// 3. Prezentacja wyników dla systemu zarządzania treścią
Console.WriteLine($"Kupiec (Folder): {folder}");
Console.WriteLine($"Dokument: {nazwaBezRozszerzenia}");
Console.WriteLine($"Typ pierwotny: {rozszerzenie}");
Console.WriteLine(new string('=', 40));
Console.WriteLine($"PROPOZYCJA NOWEJ LOKALIZACJI:");
Console.WriteLine(nowaSciezka);
}
}
}
----------------------------------------
Kupiec (Folder): C:\AutoPremium\Instrukcje_2026
Dokument: Manual_Model_S8
Typ pierwotny: .pdf
========================================
PROPOZYCJA NOWEJ LOKALIZACJI:
C:\AutoPremium\Instrukcje_2026\Manual_Model_S8.apdata
Implementacja profesjonalnej obsługi błędów za pomocą bloków `try-catch-finally` oraz analiza hierarchii wyjątków w kontekście operacji na systemach plików.
W salonie Auto-Premium bezpieczeństwo danych jest priorytetem, szczególnie w przypadku plików zawierających kody diagnostyczne silników oraz parametry autoryzacji systemów immobilizer. Próba dostępu do takich plików jest operacją o wysokim stopniu ryzyka – plik może zostać usunięty przez system czyszczący, zablokowany przez inny proces serwera lub użytkownik może nie posiadać odpowiednich uprawnień administracyjnych do ich odczytu. Twoim zadaniem jest stworzenie "pancernej" bramki dostępowej, która w sposób inteligentny spróbuje odczytać zawartość tajnego pliku `admin_secrets.txt`. Program nie może doprowadzić do nagłego zamknięcia aplikacji w przypadku błędu – zamiast tego musi elegancko przeanalizować przyczynę niepowodzenia i poinformować o tym operatora technicznym, ale czytelnym komunikatem (np. "Brak dostępu" vs "Plik nie istnieje"). Na koniec, system musi bezzwłocznie wyczyścić wszystkie zasoby pamięci, niezależnie od tego, czy odczyt zakończył się sukcesem, czy klęską. Salon Auto-Premium nie akceptuje kompromisów w kwestii stabilności – Twoja implementacja musi być symbolem niezawodności oprogramowania klasy Premium. Profesjonalne podejście do obsługi stanów wyjątkowych jest tym, co odróżnia początkującego kodera od inżyniera systemów o znaczeniu krytycznym (mission-critical). Budujesz tutaj fundamenty bezpieczeństwa cyfrowego marki. Scenariusz ten uczy Cię przewidywania najgorszych scenariuszy i sprawnego reagowania na błędy runtime'u. Zadanie to jest niezbędnym krokiem w drodze do tworzenia odpornego na awarie kodu w skomplikowanych środowiskach sieciowych.
W tym zadaniu wykorzystujemy konstrukcję `try-catch-finally`, która jest fundamentem obsługi błędów w .NET. Blok `try` zawiera kod, który może rzucić wyjątek (np. praca z plikami). Następnie stosujemy kilka bloków `catch`, uszeregowanych od najbardziej specyficznych (`FileNotFoundException`, `UnauthorizedAccessException`) do najbardziej ogólnego (`Exception`). Taka hierarchia pozwala na precyzyjne dopasowanie komunikatu błędu do faktycznego problemu. Każdy złapany wyjątek niesie ze sobą szczegółowe informacje w obiekcie `ex` (np. właściwość `Message`). Ostatnim elementem jest blok `finally`, który wykonuje się zawsze – niezależnie od tego, czy wystąpił błąd. Jest to idealne miejsce na logikę czyszczącą, zamykanie nieużywanych strumieni lub resetowanie stanów flag systemowych. Pamiętaj, że rzucanie wyjątków jest operacją kosztowną dla procesora, dlatego powinny być one używane tylko w sytuacjach naprawdę nieprzewidzianych, a nie jako element standardowej logiki sterowania (do tego służy np. `File.Exists`). Zrozumienie, jak system operacyjny raportuje błędy wejścia/wyjścia, pozwala na budowanie stabilnych interfejsów, które "prowadzą użytkownika za rękę" w sytuacjach awaryjnych. To zadanie kształtuje nawyki pisania bezpiecznego, defensywnego kodu (Defensive Programming), który przetrwa próby złośliwego lub błędnego użytkowania systemu.
using System.IO;
namespace AutoPremium.Security
{
class SecureVault
{
static void Main()
{
string secretPath = "admin_secrets.txt";
try
{
Console.WriteLine("[SYSTEM] Próba dostępu do sejfu danych...");
string dane = File.ReadAllText(secretPath);
Console.WriteLine("Zawartość sejfu: " + dane);
}
catch (FileNotFoundException ex)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("[BŁĄD] Krytyczny plik został usunięty lub brakuje go w systemie!");
Console.ResetColor();
}
catch (UnauthorizedAccessException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[ALERT SECURITY] Odmowa dostępu. Brak odpowiednich uprawnień!");
Console.ResetColor();
}
catch (Exception ex)
{
Console.WriteLine("Wykryto nieoczekiwany błąd systemowy: " + ex.Message);
}
finally
{
Console.WriteLine("\n[AUDYT] Procedura czyszczenia zasobów zakończona.");
Console.WriteLine("System pozostaje w pełnej gotowości operacyjnej.");
}
}
}
}
[BŁĄD] Krytyczny plik został usunięty lub brakuje go w systemie!
[AUDYT] Procedura czyszczenia zasobów zakończona.
System pozostaje w pełnej gotowości operacyjnej.
Izolacja logiki operacji na plikach poprzez tworzenie własnych metod statycznych oraz nauka reużywalności kodu (DRY) w projektach inżynierskich.
Zarząd sieci salonów Auto-Premium podjął decyzję o standaryzacji wszystkich raportów generowanych przez terminale informacyjne w całej Europie. Obecnie każdy programista w zespole pisze własny kod otwierania i zamykania plików, co negatywnie wpływa na architekturę systemu i utrudnia kontrolę nad formatem danych przesyłanych do systemu centralnego. Twoim zadaniem jest opracowanie "Złotego Standardu" obsługi raportów – musisz zaimplementować uniwersalną, statyczną metodę `GenerujRaport(string tresc, string nazwaPliku)`. Metoda ta ma brać na siebie pełną odpowiedzialność za bezpieczny zapis tekstu na dysku, wliczając w to automatyczne doklejanie unikalnego nagłówka z aktualną datą i godziną zakończenia pracy salonu. Dzięki takiemu rozwiązaniu, dowolny moduł aplikacji (np. moduł serwisowy, sprzedażowy czy marketingowy) będzie mógł wygenerować profesjonalny dokument jedną, zwięzłą linią kodu. To ogromny krok w stronę nowoczesnej, modułowej architektury, która jest symbolem profesjonalizmu marki Premium nie tylko w salonach wystawowych, ale i w jej DNA informatycznym. System staje się przez to czytelny, bezpieczny i łatwy w późniejszej modyfikacji, co ma kluczowe znaczenie przy dynamicznym rozwoju floty pojazdów luksusowych. Twoja praca bezpośrednio wpłynie na szybkość wdrażania nowych funkcji w systemach zarządzania Auto-Premium, zapewniając przy tym najwyższą jakość zapisu danych. Od teraz, każdy raport dla managera będzie miał identyczną, nienaganną strukturę. Scenariusz ten uczy Cię fundamentów tworzenia komponentów wielokrotnego użytku, co odróżnia dojrzałych deweloperów od nowicjuszy.
W tym zadaniu centrum uwagi stanowi słowo kluczowe `static`, które pozwala na wywołanie metody bezpośrednio z poziomu klasy, bez konieczności tworzenia obiektu (instancji). Metody statyczne są idealne dla funkcji "utils" lub pomocniczych, które operują na parametrach wejściowych i nie przechowują własnego stanu (jak zapis do pliku). Wewnątrz naszej metody wykorzystujemy `File.AppendAllText`, która w przeciwieństwie do `WriteAllText`, nie usuwa starej zawartości pliku, lecz dokleja nową na jego końcu – co jest standardem w systemach logowania i raportowania. Zastosowanie sformatowanego czasu `DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")` w nagłówku sprawia, że każda operacja jest precyzyjnie oznaczona w osi czasu. Tak przygotowany kod jest o wiele łatwiejszy do testowania i debugowania. Kolejnym aspektem jest tzw. enkapsulacja logiki – programista wywołujący metodę nie musi wiedzieć, jakich klas z przestrzeni `System.IO` używamy pod spodem, dba jedynie o przekazanie prawidłowych danych tekstowych. Program doskonale obrazuje zasadę Separation of Concerns (podziału odpowiedzialności), gdzie jedna metoda zajmuje się tylko i wyłącznie sformatowaniem i zapisem danych. Wiedza ta jest kluczowa przy budowie bibliotek klasy .NET Class Library, które napędzają największe systemy IT na świecie.
using System.IO;
namespace AutoPremium.Reporting
{
class ReportEngine
{
static void Main()
{
Console.WriteLine("Inicjalizacja systemu raportowania...");
// Jedna linia kodu do wygenerowania dokumentu!
ZapiszRaport("Sprzedano: Bentley Continental GT", "raport_sprzedazy.log");
Console.WriteLine("Procedura eksportu zakończona pomyślnie.");
}
// UNIWERSALNA METODA STATYCZNA DO GENEROWANIA PLIKÓW
static void ZapiszRaport(string tresc, string nazwaPliku)
{
string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
string gotowyLog = $"[{timestamp}] - {tresc}\n";
// Używamy AppendAllText dla dopisywania do istniejących logów dziennych
File.AppendAllText(nazwaPliku, gotowyLog);
}
}
}
Procedura eksportu zakończona pomyślnie.
(W pliku raport_sprzedazy.log dodano nową linię z aktualnym czasem)
Zastosowanie własnych przestrzeni nazw (`namespace`) do organizacji kodu oraz implementacja logicznego podziału odpowiedzialności za pliki kontraktowe.
W miarę jak systemy salonowe Auto-Premium stają się coraz bardziej rozbudowane, kluczowe staje się utrzymanie porządku w architekturze kodu źródłowego. Zespół deweloperski centrali podjął decyzję o całkowitej restrukturyzacji modułów, tak aby każda klasa i każdy plik operacyjny miały swoje precyzyjnie określone miejsce w hierarchii biznesowej firmy. Twoim zadaniem jest zaimplementowanie nowego modułu do obsługi procesów finansowych, który musi być osadzony w dedykowanej przestrzeni nazw `AutoPremium.Economy.Contracts`. W ramach tego zadania stworzysz logikę rejestrującą nowy kontrakt leasingowy w pliku cyfrowym, ale wykonasz to w sposób profesjonalny, korzystając ze struktury klasy osadzonej w odpowiednim obszarze logicznym. Dzięki takiemu podejściu wyeliminujesz ryzyko konfliktów z klasami o podobnych nazwach w przyszłości, gdy system rozrośnie się o funkcje serwisu, sprzedaży części zamiennych czy zarządzania flotą testową. Marka Premium wymaga doskonałości nie tylko w projektowaniu karoserii, ale również w elegancji i uporządkowaniu "kodu pod maską", co jest wyrazem najwyższej kultury technicznej inżyniera. Twoim celem jest pokazanie, że nawet prosta operacja zapisu trwałej informacji zyskuje zupełnie nową jakość, gdy jest częścią większej, przemyślanej całości architektonicznej. Systemy luksusowe muszą być tak samo czyste i uporządkowane, jak wnętrza ich limuzyn. To zadanie przygotowuje Cię do pracy przy projektach wielkoskalowych, gdzie przemyślana struktura nazw jest fundamentem trwałego i łatwego w utrzymaniu oprogramowania. Scenariusz ten uczy Cię myślenia w kategoriach dużych systemów korporacyjnych, gdzie każdy moduł ma swoje miejsce.
Słowo kluczowe `namespace` (przestrzeń nazw) służy w języku C# do logicznego grupowania klas, struktur i innych typów danych. Pomaga to w uniknięciu konfliktów nazewnictwa, gdy dwa różne komponenty używają klas o tej samej nazwie (np. `Contract`). Standardem w przemyśle jest stosowanie notacji typu `Firma.Dzial.Modul`. Wewnątrz takiej przestrzeni definiujemy klasę `ContractManager`, która posiada statyczną metodę do zapisu danych do plików. Gdy musimy użyć tej klasy w innej części systemu, korzystamy z dyrektywy `using` lub podajemy pełną kwalifikowaną nazwę typu. To zadanie podkreśla rolę organizacji kodu jako elementu jakości inżynieryjnej. Zapis do pliku wykonujemy za pomocą metody `File.WriteAllText`, która tworzy nowy dokument z danymi kontraktu (ID, nazwisko klienta, wartość raty). Należy zauważyć, że plik fizyczny na dysku nie wie nic o przestrzeniach nazw – są one mechanizmem wyłącznie programistycznym, widocznym dla kompilatora i programisty. Zrozumienie relacji między strukturą folderów w projekcie a strukturą przestrzeni nazw jest kluczowe dla efektywnego zarządzania dużymi repozytoriami kodu (Solution). Rozwiązanie to stanowi modelowy przykład implementacji nowej funkcjonalności zgodnie z ogólnoświatowymi standardami programowania obiektowego w .NET. Wiedza ta jest fundamentem pracy w nowoczesnych środowiskach korporacyjnych (Enterprise IT).
using System.IO;
// DEFINICJA WŁASNEJ PRZESTRZENI NAZW
namespace AutoPremium.Economy.Contracts
{
class ContractManager
{
public static void FinalizujKontrakt(string id, string klient, decimal kwota)
{
string nazwaPliku = $"kontrakt_{id}.log";
string dane = $"KONTRAKT LEASINGOWY: {id}\nKlient: {klient}\nWartość: {kwota:C}\nData: {DateTime.Now}";
File.WriteAllText(nazwaPliku, dane);
Console.WriteLine($"MODUŁ KONTRAKTÓW: Pomyślnie zarchiwizowano umowę {id}.");
}
}
}
// GŁÓWNA CZĘŚĆ PROGRAMU
class Program
{
static void Main()
{
Console.WriteLine("=== SYSTEM OPERACYJNY AUTO-PREMIUM HQ ===");
// Wywołanie metody poprzez pełną nazwę qualified namespace
AutoPremium.Economy.Contracts.ContractManager.FinalizujKontrakt("LP-2026-001", "Jan Kowalski", 450500.99m);
}
}
MODUŁ KONTRAKTÓW: Pomyślnie zarchiwizowano umowę LP-2026-001.
(Plik kontrakt_LP-2026-001.log został zapisany w folderze roboczym)
Kompleksowe połączenie wszystkich poznanych technik: operacji na plikach (`File`), strumieni tekstowych i binarnych, klasy `Path`, klasy `Math` oraz zaawansowanej obsługi wyjątków w jednym, zintegrowanym module analitycznym.
Jako główny inżynier oprogramowania (Lead Software Engineer) marki Auto-Premium, stajesz przed największym wyzwaniem w swojej dotychczasowej karierze. Twoim zadaniem jest stworzenie "Zintegrowanego Audytora Systemowego" – kompleksowego narzędzia, które przeprowadzi pełną, wielopoziomową diagnostykę środowiska pracy serwerów pokładowych naszych najdroższych pojazdów. Audytor musi w sposób sekwencyjny i bezpieczny wykonać cztery krytyczne operacje: (1) zweryfikować poprawność ścieżek dostępowych do bazy danych przy użyciu klasy `Path`, (2) spróbować wczytać parametry bezpieczeństwa z pliku konfiguracyjnego, stosując pancerną obsługę błędów `try-catch`, (3) wyliczyć zaawansowane statystyki prognozowanej wydajności akumulatorów przy użyciu klasy `Math` i pętli, oraz na koniec (4) zrzucić skumulowany raport techniczny w formacie binarnym (`BinaryWriter`) dla zarządu marki. To zadanie jest zwieńczeniem Twojego szkolenia w Auto-Premium i wymaga od Ciebie płynnego łączenia różnych, zaawansowanych obszarów języka C#. Salon Premium to miejsce, gdzie bezkompromisowa technologia spotyka się z nieskazitelnym luksusem – Twój audytor musi być tak samo szybki, stabilny i godny zaufania jak flagowe limuzyny opuszczające nasze linie montażowe. Poczuj dumę z budowania systemów, które napędzają przyszłość motoryzacji i gwarantują bezpieczną jazdę najbogatszym klientom na świecie. Scenariusz ten sprawdza Twoją dojrzałość projektową i zdolność do tworzenia rozwiązań typu End-to-End, które stanowią o sile nowoczesnego oprogramowania korporacyjnego. Gratulacje – po poprawnym wykonaniu tego zadania staniesz się certyfikowanym deweloperem ekosystemu Auto-Premium. To Twój bilet do świata wysokiej klasy inżynierii danych.
W finałowej konstrukcji spajamy wszystkie elementy nauczone podczas całego laboratorium. Proces zaczyna się od walidacji logicznej ścieżki za pomocą `Path.Combine`, co zapewnia poprawność działania programu na różnych systemach operacyjnych (Windows/Linux). Następnie przechodzimy do bloku `try-catch`, w którym metoda `File.ReadAllText` próbuje pobrać klucze szyfrujące – jest to punkt krytyczny, gdzie obsługa wyjątku `Exception` chroni program przed przerwaniem. Kolejny etap to silnik obliczeniowy oparty na `Math.Pow` i `Math.Sqrt`, który przetwarza dane w locie, symulując degradację energetyczną ogniw w czasie. Zwieńczeniem procesu jest serializacja binarna wyników. Użycie `BinaryWriter` gwarantuje, że wynikowy plik `.audit` będzie zwarty i niemożliwy do sfałszowania bez specjalistycznego oprogramowania. Zauważ, że cały proces odbywa się w uporządkowanej przestrzeni nazw, co podkreśla elegancję i czytelność architektury. To zadanie uczy Cię myślenia systemowego i planowania przepływu danych (Data Flow) w aplikacjach o wysokim stopniu skomplikowania. Wiedza o tym, jak płynnie przechodzić od zapytania o ścieżkę, przez obliczenia matematyczne, aż po binarny zapis, jest znakiem rozpoznawczym eksperta C#. Program demonstruje, jak potężnym narzędziem jest .NET, gdy potrafimy świadomie korzystać z jego wbudowanych bibliotek standardowych.
using System.IO;
namespace AutoPremium.Audit
{
class SystemAuditor
{
static void Main()
{
string reportName = "final_audit.bin";
double performanceIndex = 0;
Console.WriteLine(">>> STARTUJĘ ZINTEGROWANY AUDYT SYSTEMOWY <<<");
// 1. ANALIZA ŚCIEŻKI I ŚRODOWISKA
string fullPath = Path.GetFullPath(reportName);
Console.WriteLine($"Lokacja docelowa: {fullPath}");
// 2. BEZPIECZNY ODCZYT KONFIGURACJI
try {
string config = File.ReadAllText("security.cfg");
Console.WriteLine("Polityka bezpieczeństwa: ZAŁADOWANA");
} catch {
Console.WriteLine("OSTRZEŻENIE: Brak pliku security.cfg. Używam ustawień domyślnych.");
}
// 3. FORMULACJA MATEMATYCZNA (Math)
Console.Write("Analiza matematyczna ogniw...");
for (int i = 1; i <= 100; i++) {
performanceIndex += Math.Sqrt(i) * Math.PI;
}
Console.WriteLine(" ZAKOŃCZONA.");
// 4. ARCHIWIZACJA BINARNA (Streams)
using (BinaryWriter bw = new BinaryWriter(File.Open(reportName, FileMode.Create)))
{
bw.Write(DateTime.Now.ToBinary());
bw.Write(performanceIndex);
bw.Write("AUDYT ZAKOŃCZONY POZYTYWNIE");
}
Console.WriteLine("\n[RAPORT] Sumaryczny wskaźnik wydajności: {0:F2}", performanceIndex);
Console.WriteLine("Plik binarny 'final_audit.bin' gotowy do wysłania do centrali.");
}
}
}
Lokacja docelowa: C:\AutoPremium\Bin\final_audit.bin
OSTRZEŻENIE: Brak pliku security.cfg. Używam ustawień domyślnych.
Analiza matematyczna ogniw... ZAKOŃCZONA.
[RAPORT] Sumaryczny wskaźnik wydajności: 2115,82
Plik binarny 'final_audit.bin' gotowy do wysłania do centrali.
