Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00125 004795 19012628 na godz. na dobę w sumie
C#. Zacznij programować! - książka
C#. Zacznij programować! - książka
Autor: Liczba stron: 496
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-6060-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook (-30%), audiobook).

Pierwsze kroki w programowaniu bywają frustrujące. Wszystko wydaje się jasne i proste, ale tylko do pierwszych prób skompilowania kodu. Półki księgarń uginają się pod ciężarem podręczników programowania w różnych językach, jednak większość nie ułatwia nauki podstaw, które są absolutnie niezbędne każdemu koderowi. Spośród licznych języków programowania C# jest wart szczególnej uwagi. To dojrzały język, wyjątkowo wszechstronny i prosty w stosowaniu, dzięki czemu jest ulubionym narzędziem profesjonalistów. Ponadto z uwagi na inne właściwości stanowi idealny wybór dla początkujących koderów, gdyż ułatwia kształtowanie dobrych nawyków.

To książka dla każdego, kto chce osiągnąć programistyczne oświecenie! Jest napisana w innowacyjny sposób, przyjaznym i zrozumiałym językiem, aby każdy adept programowania zdobył wiedzę i umiejętności potrzebne do pisania dobrego, użytecznego kodu. Dzięki niej nauczysz się myśleć jak zawodowy programista. Poza przydatnymi informacjami znajdziesz tu szereg praktycznych ćwiczeń i przykładów kodu. Nie zabrakło również bardzo istotnych wskazówek dotyczących potencjalnych problemów i technik ich rozwiązywania. Tam, gdzie to potrzebne, dokładnie opisano, które elementy mogą zawieść i na co należy zwrócić uwagę. Podręcznik został przygotowany tak, aby programowanie było przyjemne, satysfakcjonujące i wyzwalało pełnię kreatywności!

Dzięki tej książce:

C#. Bierz to, co najlepsze!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Begin to Code with C# Tłumaczenie: Lech Lachowski ISBN: 978-83-283-6060-0 Authorized translation from the English language edition, entitled BEGIN TO CODE WITH C#, 1st Edition by MILES, ROB, published by Pearson Education, Inc, publishing as Microsoft Press, Copyright © 2017 by Rob Miles. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. POLISH language edition published by Helion SA, Copyright © 2020. Microsoft and the trademarks listed at http://www.microsoft.com on the “Trademarks” webpage are trademarks of the Microsoft group of companies. All other marks are the property of their respective owners. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Helion SA ul. Kościuszki 1c, 44-100 Gliwice tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/czaczp.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/czaczp Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Dla Mary Poleć książkęKup książkę Spis treści w skrócie Część I Podstawy programowania Rozdział 1. Zaczynamy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Rozdział 2. Co to jest programowanie? . . . . . . . . . . . . . . . . . . . . . . . . . . .18 Rozdział 3. Pisanie programów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Rozdział 4. Praca z danymi w programie . . . . . . . . . . . . . . . . . . . . . . . . 68 Rozdział 5. Podejmowanie decyzji w programie . . . . . . . . . . . . . . . . 100 Rozdział 6. Powtarzanie akcji za pomocą pętli . . . . . . . . . . . . . . . . . . 134 Rozdział 7. Korzystanie z tablic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Część II Programowanie zaawansowane Rozdział 8. Używanie metod do upraszczania programów . . . . . . . 212 Rozdział 9. Tworzenie strukturalnych typów danych . . . . . . . . . . . . . 246 Rozdział 10. Klasy i referencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 Rozdział 11. Tworzenie rozwiązań z wykorzystaniem obiektów . . . . 336 Część III Tworzenie gier Rozdział 12. Czym jest gra? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 Rozdział 13. Tworzenie rozgrywki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Rozdział 14. Gry i hierarchie obiektów . . . . . . . . . . . . . . . . . . . . . . . . . . 416 Rozdział 15. Gry i komponenty oprogramowania . . . . . . . . . . . . . . . . 446 iv Poleć książkęKup książkę Część IV Tworzenie aplikacji (dodatek na WWW) Rozdział 16. Tworzenie interfejsu użytkownika z wykorzystaniem obiektów (dodatek na WWW) . . . . . 476 Rozdział 17. Aplikacje i obiekty (dodatek na WWW) . . . . . . . . . . . . . . 510 Rozdział 18. Zaawansowane zagadnienia aplikacji (dodatek na WWW) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532 v Poleć książkęKup książkę Spis treści Wprowadzenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xvi Część I Podstawy programowania 1. 2. Zaczynamy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Przygotowywanie miejsca do pracy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Pobieranie narzędzi i wersji demonstracyjnych . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Korzystanie z narzędzi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Projekty i rozwiązania Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Uruchamianie programu za pomocą Visual Studio . . . . . . . . . . . . . . . 7 Zatrzymywanie programu uruchomionego w Visual Studio . . . . . . 10 Aplikacja MyProgram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Co to jest programowanie? . . . . . . . . . . . . . . . . . . . . . . . . . 18 Jakie cechy charakteryzują programistę? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Programowanie i planowanie imprez . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Programowanie i problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 vi Poleć książkęKup książkę Programiści i ludzie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Komputery jako procesory danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Maszyny, komputery i my . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Jak działają programy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Programy jako procesory danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Dane i informacje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 Pisanie programów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Struktura programu C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 Identyfikacja zasobów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 Rozpoczynanie definicji klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Deklarowanie metody StartProgram . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Ustawianie tytułu i wyświetlanie wiadomości . . . . . . . . . . . . . . . . . . . 47 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 SpeakString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 Tworzenie nowych plików programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Delay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 SetTextColor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 SetTitleColor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 SetBackgroundColor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Tworzenie własnych kolorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 Praca z danymi w programie . . . . . . . . . . . . . . . . . . . . . . . . 68 Zaczynamy pracę ze zmiennymi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 Zmienne i pamięć komputera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 Deklarowanie zmiennej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 3. 4. vii Poleć książkęKup książkę Proste instrukcje przypisania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Używanie zmiennej w programie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 Przypisywanie wartości w deklaracji . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 Dodawanie do siebie łańcuchów znaków . . . . . . . . . . . . . . . . . . . . . . . 77 Praca z liczbami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Liczby całkowite i liczby rzeczywiste . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Wykonywanie obliczeń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Praca z różnymi typami danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Konwertowanie liczb na tekst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Liczby całkowite i liczby rzeczywiste w programach . . . . . . . . . . . . . . . . . . . . . 89 Typy zmiennych i wyrażenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Precyzja i dokładność . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 Konwertowanie typów za pomocą rzutowania . . . . . . . . . . . . . . . . . . 92 Używanie rzutowania na argumentach w wyrażeniu . . . . . . . . . . . . 93 Typy i błędy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Snapy pogodowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 ThrowDice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 5. Podejmowanie decyzji w programie . . . . . . . . . . . . . . . . 100 Boolowski typ danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Deklaracja zmiennej boolowskiej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Wyrażenia boolowskie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Używanie konstrukcji if oraz operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Operatory relacyjne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Operatory równości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 Porównywanie łańcuchów znaków . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Tworzenie bloków instrukcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110 Zmienne lokalne w blokach kodu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 viii Poleć książkęKup książkę 6. Tworzenie złożonych warunków przy użyciu operatorów logicznych . . . . .113 Praca z logiką . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116 Dodawanie komentarzy, aby program był bardziej czytelny . . . . . . . . . . . . .117 Park rozrywki i programy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .119 Odczytywanie liczb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 Budowanie logiki przy użyciu warunków if . . . . . . . . . . . . . . . . . . . . 124 Kończenie programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 Praca z zasobami programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Zarządzanie zasobami w Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . 127 Odtwarzanie dźwięków z zasobów . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 Wyświetlanie obrazu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 Powtarzanie akcji za pomocą pętli . . . . . . . . . . . . . . . . . . 134 Użycie pętli do napisania programu wyboru pizzy . . . . . . . . . . . . . . . . . . . . . 136 Liczenie wyborów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 Wyświetlanie podsumowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Pobieranie wyborów użytkowników . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Dodawanie pętli while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Walidacja danych wejściowych za pomocą pętli while . . . . . . . . . . . . . . . . . . 149 Korzystanie z programu Visual Studio do śledzenia wykonywania programów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .151 Odliczanie w pętli w programie do nauki tabliczki mnożenia . . . . . . . . . . . 157 Używanie konstrukcji pętli for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 Wychodzenie z pętli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Wracanie na początek pętli za pomocą słowa kluczowego continue . . . . 165 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 Głosowe wprowadzanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 Tajne wprowadzanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 ix Poleć książkęKup książkę 7. Korzystanie z tablic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Poczęstuj się lodami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Przechowywanie danych w pojedynczych zmiennych . . . . . . . . . . 175 Tworzenie tablicy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 Korzystanie z indeksu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Praca z tablicami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Wyświetlanie zawartości tablicy za pomocą pętli for . . . . . . . . . . . 184 Wyświetlanie menu użytkownika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 Sortowanie tablicy przy użyciu metody sortowania bąbelkowego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187 Znajdowanie najwyższych i najniższych wartości sprzedaży . . . . 194 Obliczanie całkowitej i średniej sprzedaży . . . . . . . . . . . . . . . . . . . . . 196 Dokończenie programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 Wiele wymiarów w tablicach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 Użycie zagnieżdżonych pętli for do pracy z tablicami dwuwymiarowymi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 Tworzenie testowych wersji programów . . . . . . . . . . . . . . . . . . . . . . . 203 Znajdowanie długości wymiaru tablicy . . . . . . . . . . . . . . . . . . . . . . . . 204 Używanie tablic jako tabel wyszukiwania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Część II Programowanie zaawansowane 8. Używanie metod do upraszczania programów . . . . . . . 212 Z czego składa się metoda? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 Dodanie metody do klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 Przekazywanie informacji do metod za pomocą parametrów . . . 217 Zwracanie wartości z wywołań metod . . . . . . . . . . . . . . . . . . . . . . . . . 222 x Poleć książkęKup książkę 9. Tworzenie niewielkiej aplikacji do kontaktów . . . . . . . . . . . . . . . . . . . . . . . . . . 224 Wczytywanie danych kontaktowych . . . . . . . . . . . . . . . . . . . . . . . . . . 227 Przechowywanie informacji kontaktowych . . . . . . . . . . . . . . . . . . . . 228 Korzystanie z lokalnej pamięci systemu Windows . . . . . . . . . . . . . . 229 Używanie parametrów referencyjnych do dostarczania wyników z wywołania metody . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 Wyświetlanie danych kontaktowych . . . . . . . . . . . . . . . . . . . . . . . . . . 237 Dodawanie do metod komentarzy IntelliSense . . . . . . . . . . . . . . . . . . . . . . . . 241 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 Tworzenie strukturalnych typów danych . . . . . . . . . . . . . 246 Zapisywanie nut przy użyciu struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 Tworzenie i deklarowanie struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 Tworzenie tablic wartości struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 Struktury i metody . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 Konstruowanie wartości struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256 Tworzenie rejestratora muzyki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Tworzenie predefiniowanych tablic . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Obiekty i obowiązki: niech wartość SongNote odgrywa się sama . . . . . . . 263 Ochrona wartości przechowywanych w strukturze . . . . . . . . . . . . . . . . . . . . . 264 Tworzenie programu do rysowania za pomocą biblioteki Snaps . . . . . . . . 267 Rysowanie kropek na ekranie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 Używanie Snapa DrawDot do rysowania kropki na ekranie . . . . . 269 Struktura SnapsCoordinate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 Używanie Snapa GetDraggedCoordinate do wykrywania pozycji rysowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 Używanie Snapa SetDrawingColor do ustawiania koloru rysowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Używanie Snapa ClearGraphics do czyszczenia ekranu . . . . . . . . . 276 Struktura SnapsColor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 xi Poleć książkęKup książkę Tworzenie typów wyliczeniowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Podejmowanie decyzji za pomocą konstrukcji switch . . . . . . . . . . . . . . . . . . 280 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 GetTappedCoordinate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 DrawLine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 GetScreenSize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 PickImage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 10. Klasy i referencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 Tworzenie programu Rejestr czasu pracy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 Tworzenie struktury do przechowywania informacji kontaktowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 Używanie referencji this podczas pracy z obiektami . . . . . . . . . . . . 292 Zarządzanie wieloma kontaktami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 Tworzenie danych testowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 Projektowanie interfejsu użytkownika programu Rejestr czasu pracy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 Strukturyzacja programu Rejestr czasu pracy . . . . . . . . . . . . . . . . . . 298 Tworzenie nowego kontaktu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 Znajdowanie danych klienta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 Dodawanie minut do kontaktu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 Wyświetlanie podsumowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 Struktury i klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306 Sortowanie i struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306 Sortowanie i referencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 Typy referencyjne i typy zawierające wartości . . . . . . . . . . . . . . . . . . 308 Referencje i przypisania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311 Klasy i konstruktory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316 Tablice referencji do klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 xii Poleć książkęKup książkę Od tablic do list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 Przechodzenie przez listy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Listy i wartość indeksu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322 Listy struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322 Przechowywanie danych przy użyciu formatu JSON . . . . . . . . . . . . . . . . . . . 323 Biblioteka JSON firmy Newtonsoft . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Zapisywanie i pobieranie list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326 Pobieranie danych przy użyciu formatu XML . . . . . . . . . . . . . . . . . . . . . . . . . . 329 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334 11. Tworzenie rozwiązań z wykorzystaniem obiektów . . . . 336 Tworzenie obiektów zapewniających integralność . . . . . . . . . . . . . . . . . . . . . 338 Ochrona danych przechowywanych w obiekcie . . . . . . . . . . . . . . . . 338 Zapewnianie metod Get i Set dla danych prywatnych . . . . . . . . . . 341 Zapewnianie metod odzwierciedlających użycie obiektu . . . . . . . 343 Używanie właściwości do zarządzania dostępem do danych . . . . . . . . . . . . 346 Używanie właściwości do egzekwowania reguł biznesowych . . . 349 Zarządzanie procesem konstruowania obiektu . . . . . . . . . . . . . . . . . . . . . . . . 351 Przechwytywanie i obsługa wyjątków . . . . . . . . . . . . . . . . . . . . . . . . . 353 Tworzenie aplikacji przyjaznych dla użytkownika . . . . . . . . . . . . . . 355 Zapisywanie rysunków w plikach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 SaveGraphicsImageToFileAsPNG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 SaveGraphicsImageToLocalStoreAsPNG . . . . . . . . . . . . . . . . . . . . . . . 358 LoadGraphicsPNGImageFromLocalStore . . . . . . . . . . . . . . . . . . . . . . 358 Struktura DateTime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 Pobieranie bieżącej daty i godziny . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 Sposób wyświetlania daty i czasu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 Użycie daty i czasu do tworzenia nazwy pliku . . . . . . . . . . . . . . . . . 361 Tworzenie klasy Drawing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 xiii Poleć książkęKup książkę Tworzenie listy rysunków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 Tworzenie metod dla obrazkowego dziennika . . . . . . . . . . . . . . . . . 365 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 Część III Tworzenie gier 12. Czym jest gra? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 Tworzenie gry wideo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Gry i silniki gier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Gry i duszki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 13. Tworzenie rozgrywki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Tworzenie paletki kontrolowanej przez gracza . . . . . . . . . . . . . . . . . . . . . . . . . 396 Dodawanie dźwięku do gier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401 Wyświetlanie tekstu w grze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 Tworzenie kompletnej gry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .408 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414 14. Gry i hierarchie obiektów . . . . . . . . . . . . . . . . . . . . . . . . . . 416 Gry i obiekty: Space Rockets in Space . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418 Konstruowanie poruszającego się duszka gwiazdy . . . . . . . . . . . . . 419 Umożliwienie nadpisywania metod . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Tworzenie pola poruszających się gwiazd . . . . . . . . . . . . . . . . . . . . . 428 xiv Poleć książkęKup książkę Tworzenie statku kosmicznego na bazie obiektu MovingSprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430 Dodawanie kosmitów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432 Projektowanie hierarchii klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .440 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .443 15. Gry i komponenty oprogramowania . . . . . . . . . . . . . . . .446 Gry i obiekty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .448 Tworzenie współpracujących ze sobą obiektów . . . . . . . . . . . . . . . .448 Obiekty i stan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456 Interfejsy i komponenty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471 Część IV Tworzenie aplikacji (dodatek na WWW) 16. Tworzenie interfejsu użytkownika z wykorzystaniem obiektów . . . . . . . . . . . . . . . . . . . . . . . 476 17. Aplikacje i obiekty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510 18. Zaawansowane zagadnienia aplikacji . . . . . . . . . . . . . . . 532 xv Poleć książkęKup książkę 3. Pisanie programów Poleć książkęKup książkę Czego nauczysz się w tym rozdziale? Ponieważ dowiedziałeś się już co nieco o komputerach, programach i programistach, możesz zacząć myśleć o pisaniu kodu programu. W tym rozdziale przeanalizujesz dokładnie kilka programów C#, aby zrozumieć, jak działają. Nazywam te programy „aplikacjami Snaps” (czyli Snapami), ponieważ używają biblioteki Snaps, będącej prostym zbiorem zasobów programistycznych, któ- re pomagają robić różne rzeczy „w mgnieniu oka” (ang. in a snap). Analizując, w jaki sposób te programy wykorzystują różne Snapy — dyskretne elementy funkcjonalno- ści programistycznej lub inaczej mówiąc, zachowania dostarczane przez bibliotekę — poznasz podstawy programowania w języku C#. W międzyczasie będziesz uczyć się używania programu Visual Studio do tworzenia elementów kodu w rozwiązaniu BeginToCodeWithCSharp i zarządzania nimi, a także dowiesz się, co zrobić, gdy kom- pilator będzie narzekał, iż „według niego” dany program nie ma sensu. Po lekturze tego rozdziału będziesz w stanie tworzyć programy zapewniające proste rozwiązania niektórych rzeczywistych problemów. Struktura programu C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50 Tworzenie nowych plików programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52 Dodatkowe Snapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61 Tworzenie własnych kolorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63 Czego się nauczyłeś? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .66 43 Poleć książkęKup książkę Struktura programu C# Przyjrzyjmy się bliżej kilku aplikacjom Snaps, aby zrozumieć ich elementy i organizację tych elementów. Powitanie, które wyświetla się podczas uruchamiania rozwiązania BeginToCode­ WithCSharp, nie jest skomplikowane, ale to dobre miejsce do rozpoczęcia naszej analizy. Zba- daliśmy pokrótce kod, który tworzy to doświadczenie, kiedy analizowaliśmy MyProgram.cs w rozdziale 2. Spójrz teraz na plik o nazwie Ch03_01_WelcomeProgram.cs. (Na wypadek, gdybyś zapomniałeś: użyj narzędzia Solution Explorer do nawigacji przez foldery rozdziałów rozwiązania i znalezienia tego pliku, a następnie wybierz plik, aby wyświetlić jego kod w oknie edytora). Zwróć uwagę, że kod jest prawie dokładnie taki sam jak kod w pliku MyProgram.cs, więc ten program powinien dać nam to samo doświadczenie, prawda? Sprawdźmy to. Uruchom ponow- nie nasze rozwiązanie, wybierz Chapter 03 na liście folderów oraz Ch03_01_WelcomeProgram na liście aplikacji Snaps, a następnie uruchom aplikację. Tak, otrzymujemy efekt taki jak poprzed- nio, co ma sens. Teraz przeanalizujmy ten program, aby dowiedzieć się, jak działa. Jego kod jest pokazany poniżej, a każda część programu została opatrzona objaśnieniem. Zbadamy te części linia po linii w kolejnych punktach tego podrozdziału. using SnapsLibrary; Identyfi kacja zasobów. public class Ch03_01_WelcomeProgram { public void StartProgram() { SnapsEngine.SetTitleString( Rozpoczynamy kodowanie z C# ); SnapsEngine.SetTitleString( Rozpoczynamy kodowanie z C# ); SnapsEngine.SetTitleString( Rozpoczynamy kodowanie z C# ); SnapsEngine.DisplayString( Witaj w świecie aplikacji Snaps ); SnapsEngine.DisplayString( Witaj w świecie aplikacji Snaps ); SnapsEngine.DisplayString( Witaj w świecie aplikacji Snaps ); } } Ustawianie tytułu i wyświetlanie wiadomości. Rozpoczynanie defi nicji klasy. Deklarowanie metody StartProgram. Identyfikacja zasobów using SnapsLibrary; Kompilator C# opisałem w rozdziale 2. Jest to program, który konwertuje wysokopoziomowy program C# (taki jak ten, który analizujemy) na kod maszynowy, możliwy do uruchomienia wewnątrz komputera. Gdy uruchamiasz kod napisany w języku C#, kompilator wbudowany w Visual Studio konwertuje dany program na kod maszynowy, aby można go było urucho- mić na komputerze. Program C# może zawierać linie zwane dyrektywami, które przekazują instrukcje kompilatorowi. Ta pierwsza linia programu to dyrektywa using. 44 Rozdział 3. Pisanie programów Poleć książkęKup książkę Jako programista często będziesz chciał korzystać z gotowych elementów oprogramowania, podobnie jak kucharz czasami używa gotowego ciasta. Gotowe programy C# są spakowane jako biblioteki komponentów, które można dodawać do rozwiązania Visual Studio. Jak już wspomniałem, przykładem takiej biblioteki jest biblioteka Snaps, którą przygotowałem, aby ułatwić Ci rozpoczęcie nauki programowania. Dyrektywa using określa tutaj bibliotekę Snaps jako zasób, który został dodany do naszego rozwiązania, i jak zobaczysz za chwilę, ten pro- gram użyje pewnego elementu z tej biblioteki, a konkretnie klasy SnapsEngine. Ta dyrek- tywa using instruuje kompilator: „Jeśli wspominam o czymś, czego wcześniej nie widziałeś, zajrzyj do SnapsLibrary i sprawdź, czy tam tego nie ma”. To trochę tak, jakby powiedzieć do naszego kucharza: „Jeśli potrzebujesz użyć ciasta, zajrzyj do lodówki”. Pierwsze programy, które napiszemy, używają tylko elementów z biblioteki SnapsLibrary. Później będziemy tworzyć programy używające innych bibliotek. ANALIZA KODU Używanie dyrektywy using W niektórych ramkach „Analiza kodu”, takich jak ta, nie będziesz musiał analizować żadnego konkret- nego kodu, aby zastanowić się nad pytaniami związanymi z kodem. Pytanie: Czy dyrektywa using w rzeczywistości pobiera bibliotekę, której program chce użyć? Odpowiedź: Nie. Może się to wydawać dezorientujące, ale dyrektywa using mówi kompilato- rowi, gdzie szukać elementów, które można wykorzystać w programie. Zasoby dostępne dla programu są konfigurowane w projekcie Visual Studio. Możemy zmienić dyrektywę using, aby nakłonić kompilator do używania kodu z innych miejsc. To jakby powiedzieć kucharzowi: „Jeśli chcesz użyć ciasta, sprawdź przy umywalce”, żeby użył zasobu z innej lokalizacji. Pytanie: Jeśli dodam wiele dyrektyw using, czy zwiększy to rozmiar programu? Odpowiedź: Nie. Ta dyrektywa wskazuje jedynie kompilatorowi, gdzie szukać elementów programu. Nie dodaje niczego do samego programu. Rozpoczynanie definicji klasy public class Ch03_01_WelcomeProgram C# można nazwać językiem programowania obiektowego. To dlatego, że we wszechświecie C# wszystko jest obiektem. Obiekty w programie C# mogą być bardzo proste, jak pojedyncza liczba, lub złożone, jak cała gra wideo. Obiekt może zawierać inne obiekty. Wszystko, co jest zawarte w innym obiekcie, jest nazywane składową tego obiektu. Struktura programu C# 45 Poleć książkęKup książkę Projekt obiektu możemy wyrazić poprzez definicję klasy C#. Definicja klasy C# może opisywać składowe reprezentujące dane (wartości, które obiekt może przechowywać) oraz składowe reprezentujące zachowania (działania, które obiekt może wykonywać). Kiedy projektujesz obiekt, piszesz kod C#, który określa te dwie rzeczy. Ta linia programu informuje kompilator, że wyrażamy projekt klasy (class) o nazwie Ch03 _ 01 _ WelcomeProgram. Więcej o klasach i obiektach dowiesz się w dalszej części książki. ANALIZA KODU Klasy i obiekty Pytanie: Czy definicja klasy jest jedynym sposobem definiowania obiektu? Odpowiedź: Nie. Istnieją inne rodzaje obiektów C#, które zobaczysz później. Pytanie: Czy zdefiniowanie klasy faktycznie tworzy obiekt? Odpowiedź: Nie. Klasę należy traktować jako plany lub projekt obiektu, podobne do planów domku na drzewie. Posiadanie planów domku na drzewie nie daje Ci w rzeczywistości gotowego domku, a definicja klasy nie daje obiektu. Pytanie: Czy wszystkie klasy muszą zawierać dane i zachowania? Odpowiedź: Nie. Niektóre klasy zawierają tylko składowe reprezentujące dane, a inne zawie- rają tylko składowe reprezentujące zachowanie. Przykładowo biblioteka Math, której jeszcze nie poznałeś, zawiera klasy potrafiące wykonywać funkcje matematyczne. Pytanie: Kiedy ten program tak naprawdę tworzy obiekt na podstawie klasy Ch03 _ 01 _ WelcomeProgram? Odpowiedź: Dzieje się to automatycznie. Sekwencja wygląda następująco: użytkownik uruchamia aplikację BeginToCodeWithCSharp, a następnie wybiera program Ch03_01_WelcomeProgram i uru- chamia go. Aplikacja BeginToCodeWithCSharp tworzy obiekt na podstawie klasy Ch03 _ 01 _ WelomeProgram, a następnie uruchamia zachowanie StartProgram wewnątrz tego obiektu. Deklarowanie metody StartProgram public void StartProgram() Zachowania w obiekcie są wyrażane w formie metod. Metoda to opisujący jakieś zachowanie fragment kodu C#, któremu nadano nazwę. Program może uruchomić kod z metody, podając 46 Rozdział 3. Pisanie programów Poleć książkęKup książkę po prostu jej nazwę — nazywa się to wywoływaniem metody. Na początku będziesz wywo- ływał metody, które zostały już napisane (przeze mnie), ale później utworzysz własne. Pojedyncza klasa tego programu, czyli Ch03 _ 01 _ WelcomeProgram, ma tylko jedno zacho- wanie, którym jest metoda o nazwie StartProgram. Początek metody StartProgram jest oznaczony przez deklarację public void StartProgram(). (Modyfikator metody public i typ zwracany void informują nas o naturze tej metody, ale nie musimy się w tej chwili wdawać w te szczegóły). Metoda StartProgram jest wyjątkowa. Jest to punkt wejścia dla aplikacji Snaps. Innymi słowy, aby uruchomić aplikację Snaps, należy wywołać metodę StartProgram. Klasa tego programu nie zawiera żadnych składowych reprezentujących dane, ale później zaprojektujemy kilka obiektów, które będą je (dane) zawierały. ANALIZA KODU Deklarowanie metod w klasach Pytanie: Jaka jest różnica między zachowaniem a metodą? Odpowiedź: Zachowanie to akcja, którą może wykonywać obiekt. Metoda jest rzeczywistym kodem C#, który zapewnia to zachowanie. Pytanie: Czy klasa może zawierać więcej niż jedną metodę? Odpowiedź: Tak. To programista decyduje, ile zachowań powinna zapewniać klasa, i to on pisze metodę dla każdego z nich. Program demonstracyjny, któremu się przyglądamy, ma tylko jedno zachowanie: ma uruchomić demo. Później będziemy tworzyć klasy z wieloma metodami. Pytanie: Jak używa się metody StartProgram? Odpowiedź: StartProgram jest specjalną metodą pod tym względem, że definiuje punkt początkowy dla wszystkich aplikacji Snaps. Podczas pracy w środowisku Snaps dostarczonym przez bibliotekę Snaps, zawsze w celu uruchamiania programów będziemy wywoływać metodę StartProgram. Ustawianie tytułu i wyświetlanie wiadomości SnapsEngine.SetTitleString( Rozpoczynamy kodowanie z C# ); SnapsEngine.DisplayString( Witaj w świecie aplikacji Snaps ); Struktura programu C# 47 Poleć książkęKup książkę Pierwsza z tych dwóch linii kodu to pierwsza instrukcja C# w metodzie StartProgram. Instrukcje to części programu, które wykonują zadania. Instrukcja może wywoływać metodę, podejmować decyzję lub manipulować jakimiś danymi. Instrukcje są przechowywane wewnątrz metod i są wykonywane, gdy metoda jest używana. Metoda StartProgram zawiera tylko dwie instrukcje; większe programy będą ich zawierać znacznie więcej. Te dwie instrukcje w metodzie StartProgram wywołują tak naprawdę inne metody. Poszczególne instrukcje z metody są wykonywane po kolei, zaczynając od pierwszej i suk- cesywnie przechodząc do kolejnych. Istnieje kilka typów instrukcji, których można używać; poznasz je wszystkie w trakcie nauki języka C#. Znak średnika (;) wskazuje koniec każdej instrukcji. Ta pierwsza instrukcja ustawia tytuł naszego programu na Rozpoczynamy kodowanie z C#. W tym celu używa klasy SnapsEngine. Klasa SnapsEngine jest częścią biblioteki Snaps — zasobu, który zidentyfikowaliśmy w pierwszej linii tego programu — i zapewnia wiele zacho- wań, które możemy wykorzystać w naszych programach. Możesz potraktować SnapsEngine jako swoistego „lokaja”, który potrafi robić różne rzeczy dla pisanych przez Ciebie programów. Każde zachowanie SnapsEngine jest dostarczane jako metoda C#, którą nasze programy mogą wywoływać. W tym przykładzie możesz zobaczyć, jak używać metody SetTitle- String z klasy SnapsEngine. Metodzie SetTitleString trzeba przekazać łańcuch znaków, który ma być użyty jako tytuł programu, podobnie jak poleceniu „Podaj mi drinka” wydawa- nemu lokajowi towarzyszy rodzaj napoju, jakiego sobie życzymy. Łańcuch znaków w języku C# jest podawany w nawiasach po nazwie metody, którą wywołujemy. Informacje dodawane do wywołania metody są nazywane argumentem metody. Jeśli chodzi o sam łańcuch znaków, podwójne cudzysłowy ( ) w instrukcji oznaczają jego początek i koniec — łańcuch znaków rozpoczyna się zaraz po pierwszym podwójnym cudzy- słowie i kończy się bezpośrednio przed drugim. W języku C# jest to konwencją, że gdy chcesz określić tekst w postaci łańcucha znaków, umieszczasz go w cudzysłowach w taki właśnie sposób. Jeśli w łańcuchu znaków dodamy spacje — na przykład Witamy w aplikacjach Snaps — również zostaną one wyświetlone w tytule programu (chociaż użytkownik może ich nie zauważyć). Druga instrukcja działa tak samo jak pierwsza. Wywołuje metodę z klasy SnapsEngine, która wyświetla łańcuch znaków jako komunikat na ekranie aplikacji Snaps (zamiast ustawiania łańcucha znaków jako tytułu na ekranie). Kiedy zobaczyłeś nazwę metody DisplayString, spodziewałeś się zobaczyć cudzysłowy i łańcuch znaków w nawiasach po nazwie metody? Bardzo dobrze! 48 Rozdział 3. Pisanie programów Poleć książkęKup książkę ANALIZA KODU Wywoływanie metod z klas Pytanie: Gdzie zadeklarowano metodę SetTitleString? Odpowiedź: Metoda SetTitleString jest zadeklarowana w klasie SnapsEngine dokładnie w taki sam sposób, jak metoda StartProgram jest zadeklarowana w klasie Ch03 _ 01 _ Wel- comeProgram. Później dowiesz się, jak tworzyć własne metody w klasach. Pytanie: Co się stanie, jeśli nie podam metodzie SetTitleString łańcucha znaków, na którym będzie mogła pracować? Odpowiedź: Projekt metody SetTitleString określa, że gdy jest ona wywoływana, należy dostarczyć do niej łańcuch znaków. Jeśli program nie zapewni łańcucha znaków jako argumentu wywołania metody, kompilator będzie narzekał, że ten program jest nieprawidłowy. Pytanie: Dlaczego łańcuch znaków dostarczany do metody SetTitleString musi być umiesz- czony w nawiasach? Kompilator z pewnością jest w stanie określić, że łańcuch znaków, który ma zostać wyświetlony, rozpoczyna się za znakiem podwójnego cudzysłowu. Odpowiedź: Nawiasy musimy stosować po to, żeby wskazać kompilatorowi początek i koniec listy argumentów dostarczanych do metody. Do metody SetTitleString dostarczany jest tylko jeden element, ale inne metody mogą mieć ich wiele. Jeśli spojrzysz w tekst programu, odkryjesz, że metoda StartProgram została określona w taki sposób, aby akceptować „pustą” listę argumentów, która oznacza, że nie działa ona na żadnych elementach. Projektanci języka C# użyli różnych znaków, aby zdefiniować granice różnych elementów programu (ograniczyć je). Jak widzieliśmy, łańcuchy znaków są ograniczane przez podwójne cudzysłowy. Listy argumentów są ograniczone przez otwierające i zamykające nawiasy okrągłe: ( i ). Zawartość klasy i ciało metody są ograniczane przez nawiasy klamrowe: { i }. Jak można się spodziewać, kompilator jest bardzo skrupulatny w upewnianiu się, że użycie tych ograniczników „ma sens” i odrzuci każdy program, który będzie miał niedopasowane ograniczniki. Te dwie instrukcje, które właśnie przeanalizowaliśmy (ustawiające tytuł ekranu i wyświetlające wiadomość), możesz potraktować jako „ładunek” przykładowego programu. Reszta kodu otaczającego te instrukcje zapewnia strukturę dla tych akcji. Aby napisać większy program, wystarczy zreplikować tę strukturę i dodać więcej instrukcji. Skoro już wiesz, z czego składa się prosty program, możesz zacząć tworzyć własne programy, używając aplikacji Snaps jako punktu wyjścia. Możesz na przykład utworzyć program wyświetlający dwie wiadomości, zamiast tytułu i wiadomości, tak jak zrobiłem to w programie Ch03_02_MoreStatements.cs: using SnapsLibrary; Struktura programu C# 49 Poleć książkęKup książkę public class Ch03_02_MoreStatements { public void StartProgram() { SnapsEngine.DisplayString( Witaj, świecie ); SnapsEngine.DisplayString( Żegnajcie, kurczaki ); } } Pierwsza instrukcja. Druga instrukcja. W tym programie metoda SetTitleString nie jest wywoływana, a te dwie instrukcje wywo- łują metodę DisplayString, żeby program wyświetlał najpierw jedną wiadomość, a potem drugą. W swoim programie możesz umieścić bardzo dużą liczbę instrukcji. Mógłbyś napisać na przykład program wyświetlający całą przemowę gettysburską (lub jakiś inny długi tekst) po jednym łańcuchu znaków na raz, dodając po prostu więcej instrukcji. Należy jedynie pamiętać, że gdy program zostanie uruchomiony, poszczególne instrukcje będą wykonywane po kolei. Powyższy program zawsze najpierw wyświetli komunikat Witaj, świecie, a dopiero po nim Żegnajcie, kurczaki. Kiedy więc wyświetlasz łańcuch znaków za pomocą metody DisplayString, zastępuje ona łańcuch znaków, który był wyświetlany przez poprzednie wywołanie DisplayString, jeśli takie miało miejsce. Właśnie dlatego w naszym przykładzie Witaj, świecie jest zastępowane przez Żegnajcie, kurczaki. Później dowiesz się, jak wyświetlać na ekranie wiele linii tekstu. Jeśli chcesz, metody DisplayString możesz także użyć do wyświetlania bardzo długich wiadomości; tekst jest wtedy automatycznie zawijany, jeśli wychodzi poza krawędź ekranu. Gdy spróbujesz wyświetlić jakąś niezwykle długą wiadomość, przekonasz się, że będzie się ona rozciągać aż poza dolną krawędź ekranu, a użytkownik nie będzie w stanie odczytać jej w całości. Dodatkowe Snapy Co jakiś czas będę przedstawiał kolejne Snapy — zachowania dostarczane przez bibliotekę Snaps — którymi możesz się pobawić. Możesz ich używać w swoich programach w taki sam sposób, w jaki przeanalizowane przez nas programy używają DisplayString. SpeakString Możesz tworzyć programy, które wypowiadają tekst zamiast go wyświetlać. Oto przykład: 50 Rozdział 3. Pisanie programów Poleć książkęKup książkę using SnapsLibrary; class Ch03_03_Speaking { public void StartProgram() { SnapsEngine.SpeakString( Cześć. Jestem Twoim przyjaznym komputerem. ); } } Metoda SpeakString jest używana w taki sam sposób, co metoda DisplayString, ale powoduje, że komputer wypowiada podany tekst zamiast wyświetlać go na ekranie. Jest to przydatna metoda, ponieważ ułatwia tworzenie programów, które mogą rozmawiać z użytkownikiem. ANALIZA KODU Wypowiadanie i wyświetlanie tekstu Przeanalizujmy pewien kod i spróbujmy zrozumieć, dlaczego nie robi tego, co powinien. Załóżmy, że ten program napisał Twój młodszy brat. Chciał, żeby program wyświetlał wiadomość Komputer działa, a następnie mówił Komputer działa, ale narzeka, że komunikat pojawia się na ekranie dopiero, gdy komputer skończy mówić. using SnapsLibrary; class Ch03_04_DoubleOutput { public void StartProgram() { SnapsEngine.SpeakString( Komputer działa ); SnapsEngine.DisplayString( Komputer działa ); } } Pytanie: Dlaczego komunikat pojawia się na ekranie dopiero wtedy, gdy komputer skończy czytać tekst? Odpowiedź: Kiedy próbujesz ustalić, co robi program, często przydaje się przejść przez instrukcje po kolei w taki sposób, w jaki wykonałby je komputer. Komputer czyta tekst zanim komunikat zostanie wyświetlony, ponieważ ściśle przestrzega kolejności instrukcji. Metoda Display- String nie jest uruchamiana dopóki swojego działania nie zakończy metoda SpeakString. Ten problem można rozwiązać poprzez odwrócenie kolejności instrukcji. Zostało to zrobione w programie Ch03_05_DoubleOutputFixed.cs, który możesz przejrzeć w Visual Studio. Dodatkowe Snapy 51 Poleć książkęKup książkę Tworzenie nowych plików programu Programowanie jest bardzo kreatywne, a podczas lektury tej książki będziesz tworzyć własne programy. Mam nadzieję, że będziesz miał własne pomysły na programy i będziesz je budo- wał równolegle z tymi, które proponuję. Każdy nowy program, który utworzysz, będzie nową aplikacją Snaps, którą inni uczniowie będą mogli analizować lub wykorzystywać. Nową aplikację Snaps możesz utworzyć używając jako punktu wyjścia programu MyProgram.cs. Zacznij (jak zawsze) od otwarcia pliku rozwiązania BeginToCodeWithCSharp, a następnie użyj narzędzia Solution Explorer, aby znaleźć ten plik w folderze My Snaps apps w projekcie Begin­ ToCodeWithCSharp. Kliknij prawym przyciskiem myszy plik w oknie Solution Explorera, aby otwo- rzyć menu kontekstowe, a następnie wybierz Copy (kopiuj), jak pokazano na rysunku 3.1. Rysunek 3.1. Kopiowanie programu Teraz wklej tę kopię do folderu My Snaps apps, klikając folder prawym przyciskiem myszy i wybierając Paste (wklej), jak pokazano na rysunku 3.2. 52 Rozdział 3. Pisanie programów Poleć książkęKup książkę Rysunek 3.2. Wklejanie programu Na rysunku 3.3 widać tę kopię o nazwie MyProgram — Copy.cs, utworzoną w folderze My Snaps apps. Rysunek 3.3. Skopiowany program pojawił się w folderze Tworzenie nowych plików programu 53 Poleć książkęKup książkę Zmieńmy nazwę tego nowego pliku, żeby odzwierciedlała funkcjonalność nowej aplikacji Snaps, którą zamierzasz zbudować. W oknie Solution Explorer kliknij prawym przyciskiem myszy skopiowany plik (ten, który zawiera w nazwie słowo Copy), aby ponownie otworzyć menu kontekstowe, po czym wybierz polecenie Rename (zmień nazwę). (Nie pokażę tego kroku, ponieważ jestem pewien, że doskonale wiesz, co robić!). Teraz możesz wprowadzić nową nazwę swojej aplikacji, jak pokazano na rysunku 3.4. Rysunek 3.4. Wprowadzanie nowej nazwy Zmień nazwę programu na Countdown (odliczanie). Uważaj, aby nie usunąć .cs na końcu nazwy. Jeżeli usuniesz tę część nazwy pliku, program Visual Studio nie będzie wiedział, że dany plik jest programem C# i nie zadziała poprawnie podczas próby uruchomienia programu. Po zakończeniu wprowadzania nazwy naciśnij Enter. Masz teraz kopię oryginalnego programu w pliku o nazwie Countdown.cs. Wkrótce zrozumiesz, dlaczego wybrałem taką nazwę. Następną rzeczą, jaką musimy zrobić, jest zmiana nazwy klasy, która zawiera nasz program. Kliknij plik Countdown.cs w oknie Solution Explorer, aby jego kod pojawił się w oknie edytora, jak pokazano na rysunku 3.5. 54 Rozdział 3. Pisanie programów Poleć książkęKup książkę Rysunek 3.5. Otwarcie pliku Countdown.cs w edytorze programu Visual Studio Patrząc na rysunek 3.5 można zauważyć, że Visual Studio próbuje nam coś powiedzieć. Falowane czerwone linie wskazują, że Visual Studio uznaje pewne elementy kodu programu za błędne. W tym przypadku środowisko jest niezadowolone, ponieważ nasze rozwiązanie BeginToCode­ WithCSharp zawiera dwie wersje klasy MyProgram — oryginał w pliku MyProgram.cs i kolejną wersję w pliku Countdown.cs. Możemy rozwiązać ten problem przez nadanie klasie nowej nazwy. Na rysunku 3.6 widać, że zmieniłem nazwę klasy na Countdown, a ponadto zmieniłem dzia- łanie programu, modyfikując jedną instrukcję (tę, która wywołuje SetTitleString) i usu- wając drugą (wywołującą DisplayString). Teraz program ustawia po prostu swój tytuł na Countdown. Oczywiście jako tytułu możesz użyć dowolnego łańcucha znaków, ale upewnij się, że z obu stron będzie on ograniczony znakami podwójnego cudzysłowu; w przeciwnym razie program się nie skompiluje. Rysunek 3.6. Definiowanie klasy Countdown Visual Studio jest już zadowolone, ponieważ usunęliśmy duplikat klasy MyProgram. Teraz powinieneś być w stanie uruchomić program za pomocą przycisku Start Debugging (zielonej strzałki). Tworzenie nowych plików programu 55 Poleć książkęKup książkę ANALIZA KODU Nazwy plików i nazwy klas Rozwiązanie C# można rozdzielić na dużą liczbę osobnych plików programów. Warto zastanowić się, jak to działa. Pytanie: Dlaczego musimy zmienić nazwę klasy, skoro zmieniliśmy już nazwę pliku? Odpowiedź: Aby odpowiedzieć na to pytanie, musisz zrozumieć różnicę między logicznymi i fizycznymi nazwami w programie. Nazwy plików przechowujących programy możesz potrak- tować jak nazwy fizyczne, ponieważ nazwa pliku jest powiązana z rzeczywistym plikiem, który jest przechowywany na komputerze. Jednak nazwy elementów w programie nie są powiązane z fizycznym plikiem zawierającym tekst programu. Istnieją w „logicznej” przestrzeni nazw, która jest definiowana przez programistę. Kiedy kompilator C# kompiluje program, odczytuje wszystkie pliki źródłowe i tworzy listę wszyst- kich elementów zdefiniowanych w programie. To jest logiczna przestrzeń nazw programu. Każdy z elementów w tej logicznej przestrzeni nazw musi mieć unikatową nazwę. Jeśli utworzymy dwa elementy o tej samej nazwie, kompilator będzie narzekał, i właśnie to wydarzyło się wcześniej, kiedy skopiowaliśmy plik MyProgram.cs. Po wykonaniu kopii były dwie klasy o nazwie MyPro- gram. Rozwiązaliśmy ten problem, zmieniając nazwę jednego z elementów i nadając mu nową, unikatową nazwę. Pytanie: Czy nazwa pliku źródłowego programu (nazwa fizyczna) i nazwa klasy (nazwa logiczna) w tym pliku źródłowym muszą być zgodne? Odpowiedź: Nie. Często wygodnie jest dopasować te dwie nazwy, ponieważ może to ułatwić znajdowanie konkretnych elementów, ale kompilator języka C# tego nie wymusza. Pytanie: Co by się stało, gdyby program zawierał już klasę o nazwie Countdown i dodalibyśmy kolejną? Odpowiedź: Prawdopodobnie wiesz, co by się stało. Kompilator zgłosiłby błąd, ponieważ nie lubi mieć dwóch elementów o tej samej nazwie. Tak na marginesie, czy spodziewałeś się może, że aplikacja Countdown zostanie uruchomiona natychmiast po kliknięciu przycisku Start Debugging? Gdy aplikacja BeginToCodeWithCSharp jest uruchamiana po raz pierwszy, środowisko Snaps szuka klasy o nazwie MyProgram, a następnie wywołuje metodę StartProgram w tej klasie. Oznacza to, że przy każdym uruchomieniu aplikacja BeginToCodeWithCSharp uruchamia najpierw oryginalny program: MyProgram.cs. Dzięki temu możesz używać list Folder i Aplikacje Snaps, aby wybierać inne aplikacje, które chcesz uruchomić. Ten proces kopiowania, wklejania i poprawiania możesz powtarzać za każdym razem, gdy będziesz chciał utworzyć nową aplikację i dodać ją do naszego środowiska Snaps. Ponieważ jednak wiesz już, że MyProgram to aplikacja, która jest uruchamiana automatycznie, gdy 56 Rozdział 3. Pisanie programów Poleć książkęKup książkę uruchamiane jest środowisko Snaps, oto wskazówka, która może Ci to nieco ułatwić: zacznij od edycji zawartości pliku MyProgram.cs. Dzięki temu utworzony kod będzie uruchamiany bez konieczności wyszukiwania i wybierania tej nowej aplikacji w środowisku (tak jak musieli- śmy zrobić, aby uruchomić aplikację Countdown). Pamiętaj, że dopóki klasa w pliku MyProgram.cs nazywa się MyProgram, to właśnie ten program będzie uruchamiany w środowisku jako pierwszy. Gdy skończysz budować swoją nową aplikację w pliku MyProgram.cs, możesz skopiować i wkleić kod programu do nowego pliku źródłowego (nowego pliku .cs), nadać nowemu plikowi źródłowemu unikatową nazwę i zmienić nazwę nowej klasy programu, aby Visual Studio nie podkreślało kodu na czerwono i nie uniemożliwiało kompilacji programu. A na tym etapie, jeśli naprawdę będziesz chciał, aby aplikacja MyProgram działała tak, jak dotychczas (czyli ustawiała ten sam tytuł i wyświetlała tę samą wiadomość, które widzieliśmy w poprzednich rozdziałach), wiesz, jak wrócić do tego stanu. Czy oczywiste jest już, dlaczego nazwałem ten plik źródłowy MyProgram.cs? Możesz go swobodnie wykorzystywać do budowania wielu programów! ZRÓB TO SAM Budowanie spikera odliczającego To „Niech się dzieje” jest dość doniosłe. Stanowi bardzo ważny kamień milowy na Twojej drodze do oświecenia programistycznego. Do tej pory modyfikowałeś lub naprawiałeś istniejące programy, co jest świetnym sposobem na rozpoczęcie nauki programowania, ale w pewnym momencie będziesz musiał utworzyć własny program od podstaw. Ten czas właśnie nadszedł. Jeśli się nad tym zastano- wić, nawet Bill Gates musiał od czegoś zacząć. Jestem jednak pewien, że jego pierwszy program nie był w stanie rozmawiać ze swoimi użytkownikami. Zmuszanie komputerów do mówienia było bardzo trudne w tamtych czasach, kiedy Bill Gates uczył się pisać kod, ale zapewne czuł tę samą ekscytację, którą Ty za chwilę poczujesz. Po zbudowaniu tej aplikacji będziesz miał na koncie swój pierwszy program. Możesz uczynić go bardziej osobistym, korzystając z dowolnych komunikatów, a w następnym podrozdziale odkryjesz kolejne Snapy, których możesz użyć, aby uczynić swój program jeszcze bardziej interesującym. Powinieneś już mieć „pustą” aplikację o nazwie Countdown. W tej chwili nie robi ona prawie nic — w stanie, w jakim ją ostatnio widziałeś, ustawia jedynie tytułowy łańcuch znaków — ale teraz napi- szesz własne instrukcje, aby tchnąć w nią życie. Aby utworzyć swój program, możesz użyć metod SpeakString, DisplayString i SetTitleString, dostarczonych przez klasę SnapsEngine. Musisz jedynie napisać program, który odlicza od 10 do 0. Wskazówka: Twój program będzie zawie- rać co najmniej 10 instrukcji. Rozbuduj tę podstawową wersję programu w taki sposób, aby podczas odliczania komputer wyświetlał jednocześnie liczby na ekranie. To powinno podwoić liczbę instrukcji w Twoim programie. Tworzenie nowych plików programu 57 Poleć książkęKup książkę CO MOGŁO PÓJŚĆ NIE TAK? Błędy kompilacji Zanim program będzie mógł zostać uruchomiony, musi najpierw zostać sprawdzony przez kompilator. Możesz potraktować ten proces trochę jak kontrole techniczne samolotów wykonywane przed lotem. Najpierw kapitan musi zrobić obchód samolotu, policzyć skrzydła, sprawdzić, czy we wszystkich opo- nach jest powietrze i upewnić się, że samolotem można bezpiecznie lecieć. Analogicznie kompilator przeprowadza wstępne sprawdzanie programu zanim będzie mógł go uruchomić. Jeśli program nie przestrzega reguł języka C#, kompilator wygeneruje błędy, które musisz naprawić Ty, jako programista. Niestety, kompilator jest dużo bardziej drobiazgowy w kwestii błędów niż ludzie. Mogę na przykład podejść do kogoś i zapytać: „Co Ty robić?”. Otrzymam odpowiedź, chociaż pytanie, które zadałem, jest sformułowane nieprawidłowo po polsku. Jeśli jednak spróbuję skompilować poniższy program, otrzymam błędy: using SnapsLibrary; public class BadBrackets { public void StartProgram() ( SnapsEngine.SpeakString( Witaj, świecie ); SnapsEngine.SpeakString( Żegnajcie, kurczaki ); ) } Ten kod wygląda bardzo podobnie do znanego nam programu, ale istnieją dwa drobne błędy w tekście. Zła wiadomość jest taka, że generują one 11 bardzo mylących komunikatów o błędzie, jak pokazano na rysunku. Najtrudniejsze w tym stanie rzeczy jest to, że żaden z tych komunikatów tak w rzeczywistości nie mówi Ci, co zrobiłeś źle (a niektóre z nich wyglądają naprawdę strasznie). Kompilator to bardzo sprytny pro- gram, ale nie jest wystarczająco mądry, żeby powiedzieć: „Użyłeś nawiasów okrągłych tam, gdzie 58 Rozdział 3. Pisanie programów Poleć książkęKup książkę powinieneś był użyć nawiasów klamrowych”. Zaktualizuj ten kod, aby instrukcje były poprzedzone otwierającym nawiasem klamrowym ({) i zakończone zamykającym nawiasem klamrowym (}), a pro- gram zostanie uruchomiony. Kiedy oznaczasz początek i koniec określonych części programu, zawsze musisz używać nawiasów klamrowych. Nawiasy okrągłe są używane do czegoś innego. Z PUNKTU WIDZENIA PROGRAMISTY Dobry programista musi być w stanie radzić sobie ze szczegółami Ludzie niesamowicie dobrze radzą sobie z hałasem. Potrafimy wyłowić nasze imię z dobiegającej nas z oddali rozmowy i rozpoznać swoją matkę w morzu twarzy. Programy komputerowe muszą bardzo ciężko pracować, aby wydobyć znaczenie z danych. Jeden drobny, niepoprawny szczegół w programie może zdezorientować kompilator. Oznacza to, że aby zostać świetnym programistą, trzeba nauczyć się bardzo szczegółowo badać różne rzeczy, w niektórych przypadkach znak po znaku, żeby odkryć, co jest z nimi nie tak. Najlepszym sposobem radzenia sobie z takimi błędami jest oczywiście wystrzeganie się ich. Ponieważ jednak jesteśmy ludźmi, jest to niemożliwe. Oto moje wskazówki dotyczące radzenia sobie z błędami kompilacji: 1. Zacznij od programu, który kompiluje się lub pomyślnie uruchamia. (Pamiętaj, że kompilatory pobierają kod wysokiego poziomu i generują kod maszynowy, który umożliwia komputerowi wykonanie żądanych przez nas działań. Dlatego mówimy, że program, który uruchamia się pomyślnie bez błędów, kompiluje się). Visual Studio udostępnia kreatory oprogramowania umożliwiające tworzenie programów, które nie robią zbyt wiele, ale się kompilują. 2. Często kompiluj (w programie Visual Studio za pomocą przycisku Start Debugging). Jeśli liczba zmian wykonanych od czasu ostatniej udanej kompilacji jest niewielka, możesz wyizolować możliwość wystąpienia błędu do kilku miejsc w kodzie. 3. Szukaj trzech klasycznych błędów kompilacji: a. Czegoś brakuje — nie umieszczono na przykład średnika na końcu instrukcji. b. Użyto niewłaściwego znaku — użyto na przykład znaku [ zamiast {. c. Zastosowano niepoprawną pisownię — napisano na przykład „startProgram” zamiast „Start- Program”. W świecie języka C# ma znaczenie, czy używasz wielkich, czy małych liter. 4. Nie oczekuj, że błąd występuje tam, gdzie wykrył go kompilator. Niektóre błędy (na przykład brakujący nawias klamrowy) mogą zostać wykryte wiele linii dalej od miejsca, w którym faktycz- nie zostały popełnione. 5. Użyj do pomocy mechanizmu zaznaczania tekstu kolorami. Słowa będące częścią języka C# są wyświetlane na niebiesko. Łańcuchy znaków są zaznaczane na czerwono. Jeśli jakieś słowo nie jest z
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C#. Zacznij programować!
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: