Zadania (1-10)

Zadanie 1

Przedstawić pojęcie platformy informatycznej

Platforma informatyczna to środowisko sprzętowo-programowe, na którym tworzy się i uruchamia oprogramowanie. Działa jak warstwa pośrednia między aplikacją a sprzętem i systemem operacyjnym, dostarczając wspólny, przewidywalny zestaw reguł, usług i narzędzi.

Składa się z trzech poziomów: sprzętu (procesor, architektura), systemu operacyjnego z jego API oraz warstwy programistycznej (runtime, biblioteki, kompilatory). Potocznie “platformą” nazywamy ten ostatni poziom (np. .NET, Java). Dzięki niej programista pisze kod pod platformę, a nie pod konkretny komputer, co zapewnia przenośność i zdejmuje obowiązek obsługi niskopoziomowych szczegółów (pamięć, sprzęt, wątki).

Skrót do zapamiętania: Środowisko sprzętowo-programowe (sprzęt + system + runtime/narzędzia), które daje wspólny grunt do budowy i uruchamiania aplikacji oraz odcina programistę od niskopoziomowych szczegółów.

• Trzy warstwy: sprzęt, system operacyjny (+ API), warstwa programistyczna (runtime, biblioteki, narzędzia).
• Wspólny, przewidywalny zestaw reguł i usług dla aplikacji.
• Przenośność: piszemy pod platformę, nie pod sprzęt.
• Ukrywa szczegóły niskopoziomowe za gotowymi usługami.
• Przykłady: .NET, Java/JVM, Node.js.

Zadanie 2

Przedstawić architekturę wielowarstwową

Architektura wielowarstwowa (multi-tier) to sposób projektowania aplikacji polegający na podziale jej na odrębne warstwy o jasno określonej odpowiedzialności. Każda warstwa komunikuje się tylko z sąsiednią, co zmniejsza zależności i ułatwia rozwój oraz utrzymanie systemu.

Klasyczny podział to trzy warstwy: prezentacji (interfejs użytkownika, np. strona WWW lub okno aplikacji), logiki biznesowej (reguły działania, przetwarzanie danych, walidacja) oraz dostępu do danych (komunikacja z bazą danych). Warstwa prezentacji nie odwołuje się bezpośrednio do bazy, tylko przez logikę biznesową. Główne zalety to: niezależny rozwój i testowanie warstw, łatwiejsza wymiana jednej warstwy bez ruszania pozostałych, ponowne użycie kodu oraz skalowalność (warstwy można wdrażać na osobnych serwerach).

Skrót do zapamiętania: Podział aplikacji na warstwy o oddzielnych zadaniach (prezentacja - logika - dane), gdzie warstwa rozmawia tylko z sąsiednią. Daje to luźne powiązania, łatwiejszy rozwój, wymienność i skalowalność.

• Trzy klasyczne warstwy: prezentacji (UI), logiki biznesowej, dostępu do danych.
• Każda warstwa ma jedną odpowiedzialność i komunikuje się z sąsiednią.
• Prezentacja nie sięga bezpośrednio do bazy, tylko przez logikę.
• Zalety: separacja odpowiedzialności, wymienność warstw, ponowne użycie, skalowalność, łatwiejsze testy.
• Rozróżnienie: warstwa logiczna (tier - podział fizyczny na serwery) vs warstwa programowa (layer - podział logiczny w kodzie).

Zadanie 3

Cele i przeznaczenie platformy .NET

.NET to platforma do tworzenia i uruchamiania różnych typów aplikacji: desktopowych, webowych, mobilnych, usług i rozwiązań chmurowych. Jej głównym celem jest dostarczenie jednolitego, bezpiecznego środowiska, w którym kod jest zarządzany (managed code) przez środowisko uruchomieniowe.

Kluczowe cele to: niezależność od języka programowania (C#, F#, VB.NET działają na wspólnym runtime dzięki CTS/CLS), automatyczne zarządzanie pamięcią przez Garbage Collector, bezpieczeństwo wykonania kodu, przenośność, interoperacyjność z istniejącym kodem oraz udostępnienie bogatej biblioteki klas gotowych do użycia.

Skrót do zapamiętania: Jednolita, bezpieczna platforma do budowy wielu typów aplikacji, wielojęzykowa, z zarządzaniem pamięcią (GC) i bogatą biblioteką klas.

• Przeznaczenie: aplikacje desktop, web, mobile, usługi, chmura.
• Wielojęzykowość (C#, F#, VB.NET) na wspólnym runtime.
• Automatyczne zarządzanie pamięcią (GC), bezpieczeństwo, przenośność.
• Bogata biblioteka klas (BCL) i interoperacyjność.

Zadanie 4

Wymienić i krótko scharakteryzować składowe platformy .NET

Platforma .NET składa się z kilku współpracujących elementów. Sercem jest środowisko uruchomieniowe i biblioteka klas, a resztę tworzą mechanizmy zapewniające zgodność między językami.

• CLR (Common Language Runtime) - środowisko uruchomieniowe, swego rodzaju maszyna wirtualna; zarządza wykonaniem kodu, kompilacją JIT, pamięcią (GC), bezpieczeństwem i wyjątkami.
• BCL/FCL (Base/Framework Class Library) - obszerna biblioteka gotowych klas (kolekcje, IO, sieć, bazy danych itd.).
• CTS (Common Type System) - wspólny system typów; definiuje, jak wyglądają i zachowują się typy we wszystkich językach.
• CLS (Common Language Specification) - zbiór reguł zapewniających interoperacyjność między językami.
• CIL/MSIL - wspólny język pośredni, do którego kompilują się wszystkie języki .NET.

Skrót do zapamiętania: CLR (runtime), BCL (biblioteka klas), CTS (wspólne typy), CLS (reguły zgodności języków), CIL (kod pośredni).

• CLR - wykonuje kod, GC, JIT, bezpieczeństwo.
• BCL - gotowe klasy.
• CTS - wspólne definicje typów.
• CLS - reguły interoperacyjności języków.
• CIL/MSIL - pośredni kod, do którego kompiluje się każdy język.

Zadanie 5

Proces kompilacji w platformie .NET

Kompilacja w .NET jest dwuetapowa. W pierwszym etapie kompilator danego języka (np. C#) tłumaczy kod źródłowy nie na kod maszynowy, lecz na pośredni język CIL (MSIL) wraz z metadanymi. Wynik pakowany jest w podzespół, czyli plik .exe lub .dll.

W drugim etapie, dopiero przy uruchomieniu programu, środowisko CLR korzysta z kompilatora JIT (Just-In-Time), który tłumaczy kod CIL na natywny kod maszynowy konkretnej platformy i procesora. JIT kompiluje metody na bieżąco, w miarę ich pierwszego wywołania. Dzięki temu ten sam podzespół CIL może działać na różnych systemach, o ile jest tam zainstalowane środowisko .NET.

Skrót do zapamiętania: Dwuetapowo: kompilator języka tworzy kod pośredni CIL w podzespole, a przy uruchomieniu JIT (w CLR) tłumaczy CIL na kod maszynowy danej maszyny.

• Etap 1: kod źródłowy -> kompilator języka -> CIL (MSIL) + metadane -> podzespół (.exe/.dll).
• Etap 2: uruchomienie -> JIT w CLR -> natywny kod maszynowy.
• JIT kompiluje metody na żądanie (przy pierwszym wywołaniu).
• Pośredni kod zapewnia przenośność między platformami.

Zadanie 6

Rola i budowa podzespołu

Podzespół (assembly) to podstawowa jednostka wdrożenia, wersjonowania, bezpieczeństwa i ponownego użycia kodu w .NET. Fizycznie jest to plik .exe (uruchamialny) lub .dll (biblioteka).

W skład podzespołu wchodzą: manifest (metadane opisujące sam podzespół: nazwa, wersja, kultura, lista plików, odwołania do innych podzespołów), metadane typów (opis klas, metod, pól), kod pośredni CIL oraz zasoby (np. obrazy, teksty). Podzespół może być prywatny (dostępny tylko dla jednej aplikacji) lub współdzielony, umieszczony w GAC i opatrzony silną nazwą (strong name) zapewniającą unikalność i bezpieczeństwo.

Skrót do zapamiętania: Podzespół to .exe/.dll, podstawowa jednostka wdrożenia i wersjonowania. Zawiera manifest, metadane typów, kod CIL i zasoby.

• Plik .exe lub .dll, jednostka wdrożenia, wersjonowania, bezpieczeństwa.
• Budowa: manifest + metadane typów + kod CIL + zasoby.
• Manifest = “metryczka” podzespołu (nazwa, wersja, kultura, zależności).
• Prywatny (dla jednej aplikacji) lub współdzielony (GAC, silna nazwa).

Zadanie 7

Pojęcie i rola maszyny wirtualnej

Maszyna wirtualna to warstwa programowa udająca komputer, na której wykonywany jest kod pośredni zamiast bezpośredniego uruchamiania na sprzęcie. W platformie .NET rolę maszyny wirtualnej pełni CLR, a kodem wykonywanym jest CIL.

Jej rola to przede wszystkim izolacja kodu od konkretnego sprzętu i systemu operacyjnego, co daje przenośność: ten sam kod pośredni może działać wszędzie tam, gdzie dostępna jest dana maszyna wirtualna. Dodatkowo maszyna wirtualna zarządza pamięcią, bezpieczeństwem i wykonaniem kodu, zdejmując te obowiązki z programisty.

Skrót do zapamiętania: Warstwa udająca komputer, która wykonuje kod pośredni (w .NET to CLR wykonujący CIL). Daje przenośność oraz zarządza pamięcią, bezpieczeństwem i wykonaniem.

• Wykonuje kod pośredni zamiast natywnego.
• W .NET maszyną wirtualną jest CLR (kod = CIL).
• Izoluje kod od sprzętu i OS -> przenośność.
• Zarządza pamięcią (GC), bezpieczeństwem, wykonaniem.

Zadanie 8

Przeznaczenie i rola środowiska wykonawczego oraz wspólnego systemu typów

Środowisko wykonawcze (CLR) to silnik uruchamiający kod zarządzany w .NET. Odpowiada za kompilację JIT kodu CIL na kod maszynowy, automatyczne zarządzanie pamięcią (Garbage Collector), obsługę wyjątków, bezpieczeństwo oraz zarządzanie wątkami. Programista nie musi zajmować się tymi zadaniami ręcznie.

Wspólny system typów (CTS) definiuje wszystkie typy danych i ich zachowanie w sposób jednolity dla wszystkich języków platformy. Dzięki temu typ zdefiniowany w jednym języku (np. C#) jest poprawnie rozumiany w innym (np. F#). CTS dzieli typy na wartościowe i referencyjne oraz zapewnia, że każdy typ pochodzi od System.Object.

Skrót do zapamiętania: CLR uruchamia kod zarządzany (JIT, GC, wyjątki, bezpieczeństwo), a CTS to wspólny zbiór reguł dla typów wszystkich języków, zapewniający ich zgodność.

• CLR: JIT, zarządzanie pamięcią (GC), obsługa wyjątków, bezpieczeństwo, wątki.
• CTS: jednolite typy dla wszystkich języków .NET -> zgodność między językami.
• CTS dzieli typy na wartościowe i referencyjne; wszystko dziedziczy z System.Object.
• Razem dają wielojęzykowość i zarządzane wykonanie kodu.

Zadanie 9

Omówić podział typów dostępnych w języku C#

W C# wszystkie typy dzielą się na dwie główne grupy zależnie od sposobu przechowywania i przekazywania danych. Wszystkie ostatecznie dziedziczą z System.Object.

Typy wartościowe (value types) przechowują dane bezpośrednio, zwykle na stosie, i są kopiowane przez wartość (przypisanie tworzy niezależną kopię). Należą do nich typy proste (int, double, bool, char), struktury (struct) oraz wyliczenia (enum).

Typy referencyjne (reference types) przechowują na stercie obiekt, a zmienna trzyma jedynie referencję do niego. Przypisanie kopiuje referencję, nie obiekt. Należą do nich klasy (class), interfejsy, tablice, delegaty oraz typy string i object.

Skrót do zapamiętania: Dwie grupy: wartościowe (stos, kopia przez wartość: typy proste, struct, enum) i referencyjne (sterta, kopia referencji: class, interfejs, tablica, delegat, string). Wszystko dziedziczy z System.Object.

• Wartościowe: typy proste, struct, enum; przechowywane na stosie; kopiowane przez wartość.
• Referencyjne: class, interfejs, tablica, delegat, string, object; na stercie; kopiowana referencja.
• Wspólny przodek: System.Object.
• Dodatkowo typy wskaźnikowe w kontekście unsafe.

Zadanie 10

Wyjątki w języku C#

Wyjątek to obiekt reprezentujący błąd powstały w trakcie wykonania programu. W C# wszystkie wyjątki dziedziczą z klasy System.Exception, która niesie m.in. komunikat (Message) i ślad stosu (StackTrace). Mechanizm wyjątków pozwala oddzielić kod normalny od obsługi błędów.

Obsługa opiera się na blokach try-catch-finally. W bloku try umieszcza się kod mogący zgłosić błąd, w catch obsługuje się konkretne typy wyjątków, a blok finally wykonuje się zawsze (niezależnie od tego, czy wyjątek wystąpił) i służy do sprzątania, np. zamknięcia plików. Wyjątek zgłasza się słowem kluczowym throw, można też tworzyć własne klasy wyjątków dziedziczące z Exception.

// blok try zawiera kod, który może zgłosić wyjątek
try
{
    // próba zamiany tekstu na liczbę
    // dla "abc" nie powiedzie się i zostanie zgłoszony FormatException
    int x = int.Parse("abc");
}
// pierwszy catch łapie konkretny, najbardziej szczegółowy typ wyjątku
catch (FormatException ex)
{
    // ex.Message zawiera opis błędu
    Console.WriteLine("Błędny format: " + ex.Message);
}
// drugi catch jest ogólniejszy i łapie wszystkie pozostałe wyjątki
// kolejność ma znaczenie: od szczegółowego do ogólnego
catch (Exception ex)
{
    Console.WriteLine("Inny błąd: " + ex.Message);
}
// blok finally wykonuje się zawsze, niezależnie od tego czy był wyjątek
// służy do sprzątania, np. zamknięcia pliku czy połączenia
finally
{
    Console.WriteLine("Wykonuje się zawsze (sprzatanie)");
}

Skrót do zapamiętania: Wyjątek to obiekt błędu (dziedziczy z System.Exception), obsługiwany przez try-catch-finally; throw zgłasza wyjątek, finally wykonuje się zawsze.

• Wyjątek = obiekt dziedziczący z System.Exception (Message, StackTrace).
• try - kod chroniony, catch - obsługa danego typu, finally - zawsze (sprzątanie).
• throw zgłasza wyjątek; można rzucić ponownie (rethrow).
• Można definiować własne wyjątki dziedzicząc z Exception.
• catch od najbardziej szczegółowego do ogólnego.