Promocja!

C# RUSZ GŁOWĄ WYD.IV

116.10

Na stanie

SPIS TREŚCI

Wprowadzenie

  • Dla kogo przeznaczona jest ta książka? (xxx)
  • Wiemy, co sobie myślisz (xxxi)
  • Wiemy, co sobie myśli Twój mózg (xxxi)
  • Metapoznanie – myślenie o myśleniu (xxxiii)
  • Oto co zrobiliśmy (xxxiv)
  • Oto co możesz zrobić, aby zmusić swój mózg do posłuszeństwa (xxxv)
  • Przeczytaj to (xxxvi)
  • Zespół redaktorów merytorycznych xxxiii)
  • Podziękowania (xxxix)

ROZDZIAŁ 1. Zacznij pisać programy w języku C#. Utwórz coś wspaniałego… i to szybko

  • Dlaczego warto opanować C#? (2)
  • Visual Studio jest narzędziem do pisania kodu oraz poznawania języka C# (3)
  • Utwórz pierwszy projekt w Visual Studio (4)
  • Napiszmy grę! (6)
  • Proces tworzenia gry (7)
  • Utwórz projekt WPF w Visual Studio (8)
  • Użyj języka XAML do zaprojektowania okna (12)
  • Zaprojektuj okno gry (13)
  • Ustaw wielkość okna i podaj nagłówek za pomocą właściwości w XAML-u (14)
  • Dodaj wiersze i kolumny do siatki w XAML-u (16)
  • Wyrównaj wielkości wierszy i kolumn (17)
  • Dodaj kontrolki TextBlock do siatki (18)
  • Teraz możesz zacząć pisać kod gry (21)
  • Wygeneruj metodę konfigurującą grę (22)
  • Dokończ metodę SetUpGame (24)
  • Uruchom program (26)
  • Dodaj nowy projekt do systemu kontroli wersji (30)
  • Następny krok tworzenia gry to dodanie obsługi kliknięć myszą (33)
  • Spraw, aby kontrolki TextBlock reagowały na kliknięcia myszą (34)
  • Dodaj kod metody TextBlock_MouseDown (37)
  • Spraw, aby pozostałe kontrolki TextBlock wywoływały tę samą procedurę obsługi zdarzeń MouseDown (38)
  • Ukończ grę, dodając zegar (39)
  • Dodaj zegar do kodu gry (40)
  • Użyj debugera do znalezienia przyczyny wyjątku (42)
  • Dodaj resztę kodu i dokończ grę (46)
  • Aktualizowanie kodu w systemie kontroli wersji (47)

ROZDZIAŁ 2. Zanurz się w C#. Instrukcje, klasy i kod

  • Przyjrzyj się plikom aplikacji konsolowej (50)
  • W jednej przestrzeni nazw (i jednym pliku!) mogą się znajdować dwie klasy (52)
  • Instrukcje są cegiełkami do tworzenia aplikacji (55)
  • Programy używają zmiennych do pracy z danymi (56)
  • Generowanie nowej metody używającej zmiennych (58)
  • Dodaj do metody kod używający operatorów (59)
  • Używanie debugera do obserwowania zmian zmiennych (60)
  • Używanie operatorów do pracy ze zmiennymi (62)
  • Instrukcje if służą do podejmowania decyzji (63)
  • Pętle powtarzają wykonywanie operacji (64)
  • Używanie fragmentów kodu do pisania pętli (67)
  • Mechanika interfejsów użytkownika zależy od kontrolek (71)
  • Tworzenie aplikacji WPF do eksperymentowania z kontrolkami (72)
  • Dodawanie kontrolki TextBox do aplikacji (75)
  • Dodawanie kodu C# do obsługi kontrolki TextBlock (77)
  • Dodawanie procedury obsługi zdarzeń dopuszczającej tylko dane liczbowe (79)
  • Dodawanie suwaków w dolnym wierszu siatki (83)
  • Dodawanie kodu C# do obsługi pozostałych kontrolek (84)

ĆWICZENIA z Unity nr 1. Poznawaj C# z Unity

  • Unity jest rozbudowanym narzędziem do projektowania gier (88)
  • Pobieranie Unity Hub (89)
  • Używanie Unity Hub do tworzenia nowego projektu (90)
  • Przejmij kontrolę nad układem Unity (91)
  • Sceną jest środowisko 3D (92)
  • Gry Unity są tworzone za pomocą obiektów gry (GameObject) (93)
  • Używanie narzędzia przenoszenia do przesuwania obiektów gry (94)
  • Okno Inspector wyświetla komponenty obiektów gry (95)
  • Określ materiał kuli (96)
  • Obracanie kuli (99)
  • Bądź kreatywny! (102)

ROZDZIAŁ 3. Obiekty – orientuj się! Aby kod miał sens

  • Jeśli kod jest przydatny, można ponownie go wykorzystać (104)
  • Niektóre metody przyjmują parametry i zwracają wartość (105)
  • Napisz program, który wybiera karty (106)
  • Utwórz aplikację konsolową PickRandomCards (107)
  • Dokończ metodę PickSomeCards (108)
  • Gotowa klasa CardPicker (110)
  • Ania pracuje nad następną grą (113)
  • Przygotuj papierowy prototyp klasycznej gry (116)
  • Następny krok: zbuduj wersję WPF aplikacji do wybierania kart (118)
  • StackPanel to kontener rozmieszczający inne kontrolki jedna nad drugą (119)
  • Ponownie wykorzystaj klasę CardPicker w nowej aplikacji WPF (120)
  • Użyj siatki i kontrolki StackPanel do określenia układu głównego okna (121)
  • Przygotuj układ okna aplikacji desktopowej do wybierania kart (122)
  • Ania może użyć obiektów do rozwiązania problemu (126)
  • Klasa służy do tworzenia obiektów (127)
  • Gdy tworzysz nowy obiekt na podstawie klasy, jest on nazywany jej instancją (128)
  • Lepsze rozwiązanie dla Ani – wszystko dzięki obiektom (129)
  • Instancja używa pól do śledzenia stanu (133)
  • Dziękujemy za pamięć (136)
  • Co program ma na myśli (137)
  • Czasem kod jest mało czytelny (138)
  • Używaj zrozumiałych nazw klas i metod (140)
  • Zbuduj klasę reprezentującą ludzi (146)
  • Istnieje łatwiejszy sposób na inicjowanie obiektów w C# (148)
  • Użyj okna C# Interactive do uruchamiania kodu C# (154)

ROZDZIAŁ 4. Typy i referencje. Pobieranie referencji

  • Oskar potrzebuje naszej pomocy! (156)
  • Karty postaci służą do zapisywania różnych danych na kartce (157)
  • Typ zmiennej określa, jakiego rodzaju dane może ona przechowywać (158)
  • C# udostępnia kilka typów do przechowywania liczb całkowitych (159)
  • Porozmawiajmy o łańcuchach znaków (161)
  • Literał to wartość bezpośrednio zapisana w kodzie (162)
  • Zmienne są jak kubek na dane (165)
  • Także inne typy mają różne rozmiary (166)
  • 10 kilogramów danych w 5-kilogramowej torbie (167)
  • Rzutowanie umożliwia kopiowanie wartości, których C# nie potrafi automatycznie przekształcić na inny typ (168)
  • C# niektóre konwersje przeprowadza automatycznie (171)
  • Gdy wywołujesz metodę, argumenty muszą być zgodne z typami parametrów (172)
  • Pomóżmy Oskarowi w eksperymentach z punktami umiejętności (176)
  • Użyj kompilatora C# do znalezienia błędnego wiersza kodu (178)
  • Używaj zmiennych referencyjnych, aby uzyskać dostęp do obiektów (186)
  • Wiele referencji i ich efekty uboczne (190)
  • Obiekty komunikują się między sobą za pomocą referencji (198)
  • Tablice przechowują wiele wartości (200)
  • Tablice mogą zawierać zmienne referencyjne (201)
  • null oznacza referencję, która nic nie wskazuje (203)
  • Witaj w Budżetowych Kanapkach Jarka Niechluja (208)

ĆWICZENIA z Unity nr 2. Pisanie kodu C# w Unity

  • Skrypty C# odpowiadają za działanie obiektów gry (214)
  • Dodaj skrypt C# do obiektu gry (215)
  • Napisz kod C# do rotowania kuli (216)
  • Dodaj punkt przerwania i zdebuguj grę (218)
  • Użyj debugera, aby zrozumieć działanie wartości Time.deltaTime (219)
  • Dodaj walec, aby zobaczyć, gdzie znajduje się oś Y (220)
  • Dodaj do klasy pola określające kąt i szybkość rotacji (221)
  • Użyj wywołania Debug.DrawRay, aby zbadać działanie wektorów trójwymiarowych (222)
  • Uruchom grę, aby zobaczyć promień w widoku Scene (223)
  • Rotowanie bili względem punktu sceny (224)
  • Użyj Unity, aby przyjrzeć się rotacji i wektorom (225)
  • Bądź kreatywny! (226)

ROZDZIAŁ 5. Hermetyzacja. Zapewnij prywatność swoich sekretów

  • Pomóż Oskarowi w definiowaniu rzutów obrażeń (228)
  • Napisz aplikację konsolową do obliczania obrażeń (229)
  • Zaprojektuj kod XAML dla wersji WPF kalkulatora obrażeń (231)
  • Kod zaplecza kalkulatora obrażeń (232)
  • Rozmowy przy stole (a może – dyskusja nad kostkami?) (233)
  • Spróbuj wyeliminować błąd (234)
  • Użyj metody Debug.WriteLine do wyświetlania informacji diagnostycznych (235)
  • Łatwo jest przypadkowo błędnie użyć obiektów (238)
  • Hermetyzacja oznacza utworzenie niektórych danych klasy jako prywatnych (239)
  • Użyj hermetyzacji do kontrolowania dostępu do metod i pól klasy (240)
  • Ale czy pole RealName NAPRAWDĘ jest chronione? (241)
  • Prywatne pola i metody są dostępne tylko w instancjach tej samej klasy (242)
  • Po co jest hermetyzacja? Potraktuj obiekt jak czarną skrzynkę… (247)
  • Zastosuj hermetyzację, aby ulepszyć klasę SwordDamage (251)
  • Hermetyzacja zapewnia bezpieczeństwo danych (252)
  • Napisz aplikację konsolową do testowania klasy PaintballGun (253)
  • Właściwości ułatwiają hermetyzację (254)
  • Zmodyfikuj metodę Main, aby używała właściwości Balls (255)
  • Automatycznie implementowane właściwości upraszczają kod (256)
  • Użyj prywatnego settera, aby utworzyć właściwość tylko do odczytu (257)
  • Co zrobić, aby zmienić pojemność magazynka? (258)
  • Do inicjowania właściwości użyj konstruktora z parametrami (259)
  • Podaj argumenty, gdy używasz słowa kluczowego new (260)

ROZDZIAŁ 6. Dziedziczenie. Drzewo genealogiczne obiektów

  • Obliczanie obrażeń od DODATKOWYCH broni (274)
  • Użyj instrukcji switch do dopasowywania wartości (275)
  • Jeszcze jedna sprawa – czy możemy obliczyć obrażenia od sztyletu? I od buławy? (277)
  • Zastosowanie dziedziczenia pozwala napisać kod tylko raz (278)
  • Zbuduj model klas, zaczynając od klas ogólnych i przechodząc do bardziej wyspecjalizowanych (279)
  • Jak zaprojektujesz symulator zoo? (280)
  • Każda podklasa rozszerza klasę bazową (285)
  • Użyj dwukropka, aby rozszerzyć klasę bazową (290)
  • W podklasie można przesłaniać metody, aby modyfikować lub zastępować odziedziczone składowe (292)
  • Niektóre składowe są implementowane tylko w podklasie (297)
  • Użyj debugera, aby zrozumieć przesłanianie (298)
  • Zbuduj aplikację, aby lepiej poznać słowa kluczowe virtual i override (300)
  • Podklasa może ukrywać metody z klasy bazowej (302)
  • Używaj słów kluczowych override i virtual do dziedziczenia operacji (304)
  • Gdy klasa bazowa zawiera konstruktor, w podklasie trzeba go wywołać (307)
  • Pora ukończyć zadanie dla Oskara (309)
  • Zbuduj system zarządzania rojem pszczół (316)
  • Klasa Queen – jak królowa zarządza robotnicami? (318)
  • Interfejs użytkownika: dodaj kod XAML głównego okna (319)
  • Sprzężenie zwrotne wpływa na grę w zarządzanie rojem (328)
  • Na podstawie niektórych klas nigdy nie należy tworzyć obiektów (332)
  • Klasy abstrakcyjne celowo są niekompletne (334)
  • Jak wspominaliśmy, niektórych klas nie należy używać do tworzenia obiektów (336)
  • Metoda abstrakcyjna nie ma ciała (337)
  • Właściwości abstrakcyjne działają tak jak metody abstrakcyjne (338)

ĆWICZENIA z Unity nr 3. Instancje obiektów gry

  • Zbudujmy grę w Unity! (344)
  • Utwórz nowy materiał w katalogu Materials (345)
  • Wygeneruj bilę w losowym punkcie sceny (346)
  • Użyj debugera, aby zrozumieć wywołanie Random.value (347)
  • Przekształć obiekt gry w obiekt prefab (348)
  • Utwórz skrypt do sterowania grą (349)
  • Dołącz skrypt do głównej kamery (350)
  • Wciśnij Play, aby uruchomić kod (351)
  • Użyj okna Inspector do pracy z instancjami obiektów gry (352)
  • Wykorzystaj silnik fizyki, aby uniknąć pokrywania się bil (353)
  • Bądź kreatywny! (354)

ROZDZIAŁ 7. Interfejsy, rzutowanie i instrukcja „is”. Spełnianie obietnic przez klasy

  • Rój został zaatakowany! (356)
  • Można zastosować rzutowanie, aby wywołać metodę DefendHive (357)
  • Interfejs definiuje metody i właściwości, jakie klasa musi implementować (358)
  • Nabierz wprawy w używaniu interfejsów (360)
  • Nie możesz utworzyć obiektu typu interfejsu, ale możesz utworzyć referencję do interfejsu (366)
  • Referencje typów interfejsowych są zwykłymi referencjami do obiektów (369)
  • RoboPszczoła 4000 potrafi wykonywać pracę robotnic bez zużywania cennego miodu (370)
  • Właściwość Job interfejsu IWorker to prowizorka (374)
  • Do sprawdzania typu obiektu użyj instrukcji „is” (375)
  • Użyj „is” do uzyskania dostępu do metod w podklasie (376)
  • Co zrobić, jeśli inne zwierzęta też mają pływać lub polować w stadzie? (378)
  • Używaj interfejsów do pracy z klasami, które wykonują to samo zadanie (379)
  • Bezpiecznie poruszaj się po hierarchii klas za pomocą instrukcji „is” (380)
  • C# udostępnia też inne narzędzie do bezpiecznej konwersji typów: słowo kluczowe „as” (381)
  • Stosuj rzutowanie w górę i w dół, aby poruszać się po hierarchii klas (382)
  • Rzutowanie w górę przekształca obiekt typu CoffeeMaker w obiekt typu Appliance (384)
  • Rzutowanie w dół zmienia obiekt typu Appliance ponownie w obiekt typu CoffeeMaker (385)
  • Rzutowanie w górę i w dół działa także dla interfejsów (386)
  • Interfejsy mogą dziedziczyć po innych interfejsach (388)
  • Interfejsy mogą zawierać składowe statyczne (395)
  • Domyślne implementacje zawierają ciało metod interfejsów (396)
  • Dodaj metodę ScareAdults z implementacją domyślną (397)
  • Wiązanie danych powoduje automatyczną aktualizację kontrolek WPF (399)
  • Zmodyfikuj system zarządzania rojem, aby używał wiązania danych (400)
  • Polimorfizm oznacza, że jeden obiekt może przyjmować wiele różnych postaci (403)

ROZDZIAŁ 8. Wyliczenia i kolekcje. Porządkowanie danych

  • Łańcuchy znaków nie zawsze nadają się do przechowywania kategorii danych (406)
  • Wyliczenia umożliwiają pracę ze zbiorem poprawnych wartości (407)
  • Wyliczenia umożliwiają reprezentowanie liczb za pomocą nazw (408)
  • Moglibyśmy użyć tablicy do tworzenia talii kart… (411)
  • Listy umożliwiają łatwe przechowywanie kolekcji czegokolwiek (413)
  • Listy dają więcej możliwości niż tablice (414)
  • Utwórzmy aplikację do przechowywania butów (417)
  • Generyczne kolekcje mogą przechowywać wartości dowolnego typu (420)
  • Inicjalizatory kolekcji są podobne do inicjalizatorów obiektów (426)
  • Utwórzmy listę kaczek (427)
  • Listy są proste, ale SORTOWANIE bywa skomplikowane (428)
  • Interfejs IComparable pomaga liście sortować kaczki (429)
  • Użyj obiektu typu IComparer, aby poinformować listę, jak sortować elementy (430)
  • Utwórz obiekt komparatora (431)
  • Przesłonienie metody ToString umożliwia obiektowi opisywanie samego siebie (435)
  • Zaktualizuj pętle foreach, aby obiekty typów Duck i Card wyświetlały informacje o sobie w konsoli (436)
  • Możesz zrzutować w górę całą listę, używając interfejsu IEnumerable (440)
  • Użyj słownika do przechowywania kluczy i wartości (442)
  • Przegląd możliwości słowników (443)
  • Napisz program używający słownika (444)
  • Jeszcze WIĘCEJ typów kolekcji… (445)
  • Kolejka to kolekcja typu FIFO (first in, first out) (446)
  • Stos to kolekcja typu LIFO (last in, last out) (447)
  • Ćwiczenie do pobrania – dwie talie (452)

ĆWICZENIA z Unity nr 4. Interfejsy użytkownika

  • Dodaj wynik zwiększany po kliknięciu bili przez gracza (454)
  • Dodaj dwa różne tryby gry (455)
  • Dodaj tryb gry (456)
  • Dodaj interfejs użytkownika do gry (458)
  • Skonfiguruj obiekt Text wyświetlający wynik w interfejsie użytkownika (459)
  • Dodaj przycisk, który wywołuje metodę uruchamiającą grę (460)
  • Dodaj kod obsługi przycisku Zagraj ponownie i pola z wynikiem (461)
  • Dokończ kod gry (462)
  • Wykaż się kreatywnością! (466)

ROZDZIAŁ 9. LINQ i lambdy. Kontroluj swoje dane

  • Jacek jest wielkim fanem Kapitana Wspaniałego (468)
  • Użyj technologii LINQ do pisania kwerend dotyczących kolekcji (470)
  • LINQ działa dla każdego obiektu z implementacją interfejsu IEnumerable (472)
  • Składnia kwerend LINQ (475)
  • LINQ działa dla obiektów (477)
  • Użyj kwerendy LINQ do ukończenia aplikacji dla Jacka (478)
  • Słowo kluczowe var powoduje, że C# wywnioskowuje typy zmiennych (480)
  • Kwerendy LINQ są wykonywane dopiero, gdy chcesz użyć ich wyników (487)
  • Użyj kwerendy grupującej do rozdzielenia sekwencji na grupy (488)
  • Użyj kwerend złączających do scalania danych z dwóch sekwencji (491)
  • Użyj słowa kluczowego new do utworzenia typu anonimowego (492)
  • Dodaj projekt z testami jednostkowymi do aplikacji zarządzającej kolekcją komiksów Jacka (502)
  • Napisz pierwszy test jednostkowy (503)
  • Napisz test jednostkowy metody GetReviews (505)
  • Napisz testy jednostkowe uwzględniające przypadki brzegowe i nietypowe dane (506)
  • Użyj operatora => do tworzenia wyrażeń lambda (508)
  • Jazda próbna z lambdami (509)
  • Refaktoryzacja kodu dotyczącego klaunów za pomocą lambd (510)
  • Użyj operatora ?: do podejmowania decyzji w lambdach (513)
  • Wyrażenia lambda i LINQ (514)
  • Kwerendy LINQ można zapisywać jako łańcuch metod LINQ (515)
  • Użyj operatora => do tworzenia wyrażeń switch (517)
  • Omówienie klasy Enumerable (521)
  • Ręczne tworzenie sekwencji umożliwiającej wyliczanie (522)
  • Użyj instrukcji yield return do tworzenia własnych sekwencji (523)
  • Użyj instrukcji yield return, aby zrefaktoryzować klasę ManualSportSequence (524)
  • Ćwiczenie do pobrania: Go Fish (527)

ROZDZIAŁ 10. Odczyt i zapis plików. Zachowaj dla mnie ostatni bajt

  • W .NET do odczytu i zapisu danych używane są strumienie (530)
  • Różne strumienie wczytują i zapisują różne dane (531)
  • Klasa FileStream wczytuje i zapisuje bajty w plikach (532)
  • Zapis tekstu w pliku w trzech prostych krokach (533)
  • Kanciarz realizuje następny diaboliczny plan (534)
  • Użyj klasy StreamReader do odczytu pliku (537)
  • Dane mogą przechodzić przez więcej niż jeden strumień (538)
  • Używanie statycznych klas File i Directory do pracy z plikami i katalogami (542)
  • IDisposable gwarantuje, że obiekty zostaną poprawnie zamknięte (545)
  • Użyj klasy MemoryStream do strumieniowania danych do pamięci (547)
  • Co dzieje się z obiektem w czasie serializacji? (553)
  • Czym dokładnie JEST stan obiektu? Co trzeba zapisać? (554)
  • Użyj klasy JsonSerialization do serializacji obiektów (556)
  • Format JSON obejmuje tylko dane, a nie specyficzne typy języka C# (559)
  • Następny krok – zanurzenie się w dane (561)
  • Łańcuchy znaków w C# są kodowane w formacie Unicode (563)
  • Visual Studio bardzo dobrze współdziała z Unicode (565)
  • Platforma .NET używa formatu Unicode do przechowywania znaków i tekstu (566)
  • C# może wykorzystać tablice bajtów do przenoszenia danych (568)
  • Użyj klasy BinaryWriter do zapisu danych binarnych (569)
  • Użyj klasy BinaryReader do wczytania danych (570)
  • Przeglądarka danych szesnastkowych pozwala zobaczyć bajty z pliku (572)
  • Użyj metody Stream.Read do wczytania bajtów ze strumienia (574)
  • Zmodyfikuj przeglądarkę danych szesnastkowych, aby używała argumentów z wiersza poleceń (575)
  • Ćwiczenie do pobrania – zabawa w chowanego (576)

ĆWICZENIA z Unity nr 5. Ray casting

  • Utwórz nowy projekt w Unity i zacznij przygotowywać scenę (578)
  • Przygotuj kamerę (579)
  • Utwórz obiekt gry reprezentujący gracza (580)
  • Wprowadzenie do systemu nawigowania w Unity (581)
  • Przygotowanie siatki nawigacyjnej (582)
  • Spraw, aby postać automatycznie poruszała się po obszarze gry (583)

11. KAPITAN WSPANIAŁY. ŚMIERĆ OBIEKTU

  • Życie i śmierć obiektu (590)
  • Używaj (ostrożnie) klasy GC do wymuszania odśmiecania pamięci (591)
  • Finalizator obiektu – Twoja ostatnia szansa, by coś ZROBIĆ (592)
  • Kiedy DOKŁADNIE uruchamiany jest finalizator? (593)
  • Finalizatory nie mogą zależeć od innych obiektów (595)
  • Struktura wygląda jak obiekt… (599)
  • Wartości są kopiowane; referencje są przypisywane (600)
  • Struktury są typami bezpośrednimi; klasy są typami referencyjnymi (601)
  • Stos a sterta – więcej o pamięci (603)
  • Używaj parametrów out, aby zwrócić z metody więcej niż jedną wartość (606)
  • Przekazywanie przez referencję z użyciem modyfikatora ref (607)
  • Używaj parametrów opcjonalnych do podawania wartości domyślnych (608)
  • Referencja null nie wskazuje żadnego obiektu (609)
  • Typy referencyjne niedopuszczające null pomagają unikać wyjątków NRE (610)
  • Operator ?? pomaga radzić sobie z null (611)
  • Typy bezpośrednie dopuszczające null mogą równać się null i być bezpiecznie obsługiwane (612)
  • Kapitan Wspaniały – ale nie do końca (613)
  • Metody rozszerzające dodają nowe operacje do ISTNIEJĄCYCH klas (617)
  • Rozszerzanie typu podstawowego – string (619)

ROZDZIAŁ 12. Obsługa wyjątków. Gaszenie pożarów staje się nudne

  • Przeglądarka danych szesnastkowych wczytuje nazwę pliku z wiersza poleceń (624)
  • Gdy program zgłasza wyjątek, CLR generuje obiekt wyjątku (628)
  • Wszystkie obiekty wyjątków dziedziczą po klasie System.Exception (629)
  • Istnieją pliki, które nie umożliwiają wykonania zrzutu szesnastkowego (632)
  • Co się dzieje, gdy wywoływana metoda jest ryzykowna? (633)
  • Obsługa wyjątków za pomocą bloków try-catch (634)
  • Użyj debugera do prześledzenia przepływu sterowania w bloku try-catch (635)
  • Jeśli masz kod, który trzeba ZAWSZE uruchamiać, użyj bloku finally (636)
  • Ogólny blok catch obsługuje wyjątki typu System.Exception (637)
  • Używaj wyjątku odpowiedniego do sytuacji (642)
  • Filtry wyjątków pomagają tworzyć precyzyjne bloki do ich obsługi (646)
  • Najgorszy blok catch W HISTORII – ogólny blok catch z komentarzami (648)
  • Tymczasowe rozwiązania są akceptowalne (tymczasowo) (649)

ĆWICZENIA z Unity nr 6. Nawigowanie po scenie

  • Zacznijmy od miejsca, w którym zakończyliśmy poprzednie ćwiczenia z Unity (652)
  • Dodaj platformę do sceny (653)
  • Użyj opcji wstępnego obliczania, aby umożliwić chodzenie po platformie (654)
  • Dodaj schody i rampę do siatki nawigacyjnej (655)
  • Rozwiąż problem z wysokością w siatce nawigacyjnej (657)
  • Dodaj komponent NavMesh Obstacle (658)
  • Dodaj skrypt do przesuwania przeszkody w górę i w dół (659)
  • Wykaż się kreatywnością! (660)

DODATEK A. Projekty ASP.NET Core Blazor. Przewodnik ucznia po Visual Studio for Mac

  • Dlaczego powinieneś opanować C#? (664)
  • Utwórz pierwszy projekt w Visual Studio (666)
  • Napiszmy grę! (670)
  • Utwórz projekt WebAssembly platformy Blazor w Visual Studio (672)
  • Uruchom aplikację sieciową Blazor w przeglądarce (674)
  • Teraz jesteś gotowy, by zacząć pisać kod aplikacji (676)
  • Dokończ tworzenie listy emoji i wyświetl ją w aplikacji (680)
  • Rozmieść zwierzęta w losowej kolejności (682)
  • Uruchamianie gry w debugerze (684)
  • Dodaj nowy projekt do systemu kontroli wersji (688)
  • Dodaj kod C# do obsługi kliknięć myszą (689)
  • Dodaj procedury obsługi kliknięć do przycisków (690)
  • Przetestuj kod obsługi zdarzeń (692)
  • Użyj debugera do rozwiązania problemu (693)
  • Namierz błąd, który powoduje problem (696)
  • Dodaj kod do resetowania gry po jej ukończeniu (698)
  • Dodaj zegar do kodu gry (702)
  • Uporządkuj menu nawigacyjne (704)
  • Kontrolki wpływają na mechanikę interfejsów użytkownika (706)
  • Utwórz nowy projekt WebAssembly platformy Blazor (707)
  • Utwórz stronę z suwakiem (708)
  • Dodaj do aplikacji pole na dane tekstowe (710)
  • Dodaj do aplikacji okna wyboru koloru i daty (713)
  • Następne zadanie – zbuduj bazującą na platformie Blazor wersję aplikacji do wybierania kart (714)
  • Układ strony jest określany za pomocą wierszy i kolumn (716)
  • Wiązanie danych umożliwia modyfikowanie zmiennej za pomocą suwaka (717)
  • Witaj w Budżetowych Kanapkach Jarka Niechluja! (720)

DODATEK B. Kata z programowania. Podręcznik dla zaawansowanych i/lub niecierpliwych

  • Skorowidz (729)
Autor

ISBN

978-83-246-7900-8

Liczba stron

Rok wydania

Wydawca

Opinie

Na razie nie ma opinii o produkcie.

Napisz pierwszą opinię o „C# RUSZ GŁOWĄ WYD.IV”

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *