Darmowy fragment publikacji:
Tytuł oryginału: Head First C#, 3rd Edition
Tłumaczenie: Piotr Rajca
ISBN: 978-83-246-8311-6
© 2014 Helion SA
Authorized Polish translation of the English edition of Head First C#, 3rd Edition
ISBN 9781449343507 © 2013 Jennifer Greene, Andrew Stellman
This translation is published and sold by permission of O’Reilly Media, Inc., which owns
or controls all rights to publish and sell the same.
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 Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne
i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne
naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności
za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Wydawnictwo HELION
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/cshru3.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/cshru3
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ść
Spis treści (skrócony)
Wstęp
1. Zacznij pisać programy w C#. Napisz coś fajnego, i to szybko!
2. To tylko kod. Pod maską
3. Obiekty: zorientuj się! Tworzenie kodu ma sens
4. Typy i referencje. Jest 10:00. Czy wiesz, gdzie są Twoje dane?
Laboratorium C# numer 1. Dzień na wyścigach
5. Hermetyzacja. Co ma być ukryte... niech będzie ukryte
6. Dziedziczenie. Drzewo genealogiczne Twoich obiektów
7. Interfejsy i klasy abstrakcyjne. Klasy, które dotrzymują swoich obietnic
8. Typy wyliczeniowe i kolekcje. Przechowywanie dużej ilości danych
9. Odczyt i zapis plików. Zachowaj te bajty dla mnie!
Laboratorium C# numer 2. Wyprawa
10. Projektowanie aplikacji dla Sklepu Windows z użyciem XAML.
Przenosząc swoje aplikacje na wyższy poziom
11. Async, await i serializacja kontraktu danych. Przepraszam, że przerywam
12. Obsługa wyjątków. Gaszenie pożarów nie jest już popularne
13. Kapitan Wspaniały. Śmierć obiektu
14. Przeszukiwanie danych i tworzenie aplikacji przy użyciu LINQ.
Przejmij kontrolę nad danymi
15. Zdarzenia i delegaty. Co robi Twój kod, kiedy nie patrzysz
16. Projektowanie aplikacji według wzorca MVVM. Świetne aplikacje od zewnątrz
i od środka
Laboratorium C# numer 3. Invaders
17. Projekt dodatkowy! Napisz aplikację Windows Phone
A Pozostałości. 11 najważniejszych rzeczy, które chcieliśmy umieścić w tej książce
Skorowidz
Spis treści
31
43
95
143
181
225
235
275
329
385
441
495
517
565
599
639
677
729
773
835
859
873
905
Spis treści (z prawdziwego zdarzenia)
Wstęp
W
Przygotuj się na C#. Właśnie sobie siedzisz i próbujesz się czegoś nauczyć, ale mózg wciąż powtarza Ci,
że cała ta nauka nie jest ważna. Twój umysł mówi: „Lepiej wyjdź z pokoju i zajmij się ważniejszymi sprawami,
takimi jak to, których dzikich zwierząt unikać, oraz to, że strzelanie z łuku na golasa nie jest dobrym pomysłem”.
W jaki sposób oszukać mózg, tak aby myślał, że Twoje życie naprawdę zależy od nauki C#?
Dla kogo jest ta książka?
Wiemy, o czym myślisz
Metapoznanie: myślenie o myśleniu
Zmuś swój mózg do posłuszeństwa
Czego potrzebujesz do tej książki?
Przeczytaj to
Grupa korektorów technicznych
Podziękowania
32
33
35
37
38
39
40
41
9
Kup książkęPoleć książkęSpis treści
1
Ich unikaj.
Zacznij pisać programy w C#
Napisz coś fajnego, i to szybko!
Czy chcesz tworzyć wspaniałe programy naprawdę szybko? Wraz z C# dostajesz
do ręki potężny język programowania i wartościowe narzędzie. Dzięki Visual Studio IDE
do historii przejdą sytuacje, w których musiałeś pisać jakiś nędzny kod, by ponownie zapewnić
prawidłowe działanie przycisku. I to nie wszystko. Dodatkowo będziesz mógł skupić się na
faktycznym wykonywaniu naprawdę fajnych programów, zamiast starać się zapamiętać,
który parametr metody odpowiadał za nazwę przycisku, a który za wyświetlany na nim tekst.
Brzmi zachęcająco? Przewróć zatem stronę i przystąpmy do programowania.
Dlaczego powinieneś uczyć się C#
C# oraz Visual Studio ułatwiają wiele czynności
Co robić w Visual Studio…
Co Visual Studio robi w naszym imieniu…
Obcy atakują!
Tylko Ty możesz uratować Ziemię
Oto co masz zamiar napisać
Zacznij od pustej aplikacji
Określ wymiary siatki na stronie
Dodaj kontrolki do siatki
Używaj właściwości, by zmieniać wygląd kontrolek
To kontrolki sprawiają, że gra działa
Stworzyłeś scenę, na której będzie prowadzona gra
Czym zajmiesz się teraz?
Dodaj metody, które coś zrobią
Podaj kod metody
Dokończ metodę i uruchom program
Oto co zrobiłeś do tej pory
Dodaj liczniki czasu zarządzające rozgrywką
Popraw działanie przycisku Start
Uruchom program, by zobaczyć postępy w pracy
Dodaj kod obsługujący interakcję użytkownika z kontrolkami
Dotknięcie człowiekiem wroga kończy grę
Teraz już można bawić się grą
Zadbaj, by wrogowie wyglądali jak obcy
Dodaj ekran startowy i tytuł
Opublikuj swoją aplikację
Użyj programu Remote Debugger, by uruchomić aplikację
na innym komputerze
Rozpocznij zdalne debugowanie
44
45
46
46
50
51
52
54
60
62
64
66
71
72
73
74
76
78
80
82
83
84
86
87
88
89
90
91
92
Och! Kosmici
wciągają ludzi.
Niedobrze!
?!
10
Kup książkęPoleć książkęSpis treści
2
To tylko kod
Pod maską
Jesteś programistą, nie jedynie użytkownikiem IDE. IDE może wykonać za Ciebie
wiele pracy, ale na razie jest to wszystko, co może dla Ciebie zrobić. Oczywiście istnieje wiele
powtarzalnych czynności podczas pisania aplikacji i IDE okazuje się tu bardzo pomocne.
Praca z nim to jednak dopiero początek. Możesz wycisnąć ze swoich programów znacznie
więcej — pisanie kodu C# to właśnie droga, która doprowadzi Cię do tego celu. Kiedy
osiągniesz mistrzowski poziom w kodowaniu, nie będzie żadnej rzeczy, której Twój program
nie umiałby zrobić.
Kiedy robisz to…
…IDE robi to
Skąd się biorą programy
IDE pomaga Ci kodować
Anatomia programu
W tej samej przestrzeni nazw mogą być dwie klasy
Twoje programy używają zmiennych do pracy z danymi
C# używa znanych symboli matematycznych
Użyj debuggera, by zobaczyć, jak zmieniają się wartości zmiennych
Pętle wykonują czynność wielokrotnie
Instrukcje if/else podejmują decyzje
Utwórz aplikację od samego początku
Niech przycisk coś zrobi
Ustal warunki i sprawdź, czy są prawdziwe
Tworzenie klasycznych aplikacji Windows jest łatwe
Przepisz program jako klasyczną aplikację Windows
Twój program wie, gdzie zacząć
Możesz zmienić punkt wejścia programu
Kiedy zmieniasz coś w IDE, zmieniasz także swój kod
Za każdym razem, kiedy tworzysz nowy
program, definiujesz dla niego przestrzeń nazw.
W ten sposób jego kod jest odseparowany
od innych klas platformy .NET.
Przestrzeń nazw
Klasa
Metoda 1
instrukcja
instrukcja
Metoda 2
instrukcja
instrukcja
96
97
98
100
102
107
108
110
111
113
114
115
117
118
129
130
134
136
138
11
Klasy zawierają fragmenty
kodu Twojego programu
(chociaż istnieją także bar-
dzo małe aplikacje składają-
ce się z tylko jednej klasy).
Klasa posiada jedną lub wię-
cej metod. Twoje metody
zawsze będą umieszczane
wewnątrz klas, a każda
z nich będzie się składała
z instrukcji i wyrażeń —
jak te, które do tej pory
widziałeś.
Kup książkęPoleć książkęObiekty: zorientuj się!
Tworzenie kodu ma sens
Każdy pisany przez Ciebie program rozwiązuje jakiś problem.
Rozpoczynając pisanie programu, zawsze warto zastanowić się, jaki problem ma on
rozwiązywać. Właśnie do tego przydają się obiekty. Pozwalają one tworzyć strukturę kodu tak,
by odpowiadała ona rozwiązywanemu problemowi, dzięki czemu będziesz mógł skoncentrować
się na nim samym, a nie na mechanice tworzenia kodu. Prawidłowe użycie obiektów spowoduje,
że proces pisania kodu stanie się bardziej intuicyjny, a jego późniejsza analiza i modyfikacja
— znacznie łatwiejsze.
Spis treści
3
n e w N a v i g a t o r ( )
new Navigator()
new Navigator()
ne
r
o
O
biekt N a vigat
Kiedy definiujesz klasę,
definiujesz także jej metody,
podobnie jak projekt definiuje
układ pomieszczeń w domu.
Możesz użyć jednego projektu
do zbudowania dowolnej liczby
domów. Możesz również przy
użyciu jednej klasy utworzyć
każdą liczbę obiektów.
12
r
o
O
biekt N a vigat
r
o
O
biekt N a vigat
W jaki sposób Maciek myśli o swoich problemach
W jaki sposób system nawigacyjny w samochodzie Maćka
rozwiązuje jego problemy
Klasa Navigator napisana przez Maćka
posiada metody do ustalania i modyfikacji tras
Wykorzystaj to, czego się nauczyłeś, do napisania
prostego programu używającego klas
Maciek ma pewien pomysł
Maciek może użyć obiektów do rozwiązania swojego problemu
Używasz klasy do utworzenia obiektu
Kiedy tworzysz obiekt na podstawie klasy,
to taki obiekt nazywamy instancją klasy
Lepsze rozwiązanie... uzyskane dzięki obiektom!
Instancja używa pól do przechowywania informacji
Stwórzmy kilka instancji!
Dzięki za pamięć
Co Twój program ma na myśli
Możesz używać nazw klas i metod
w celu uczynienia kodu bardziej intuicyjnym
Nadaj swojej klasie naturalną strukturę
Diagramy klas pozwalają w sensowny sposób zorganizować klasy
Utwórz klasę do pracy z kilkoma facetami
Utwórz projekt dla facetów
Utwórz formularz do interakcji z facetami
Jest jeszcze prostszy sposób inicjalizacji obiektów
144
145
146
147
149
150
151
152
153
158
159
160
161
162
164
166
170
171
172
175
Kup książkęPoleć książkęSpis treści
4
Typy i referencje
Jest 10:00. Czy wiesz, gdzie są Twoje dane?
Typ danych, baza danych, dane komandora porucznika… wszystko
to są ważne rzeczy. Bez danych Twoje programy są bezużyteczne. Potrzebujesz
informacji dostarczanych przez użytkowników. Na ich podstawie wyszukujesz lub tworzysz
nową informację i zwracasz im ją. W rzeczywistości prawie wszystko, co robisz podczas
programowania, sprowadza się do pracy z danymi w taki czy w inny sposób. W tym rozdziale
dowiesz się o różnych aspektach typów danych C#, nauczysz się pracować z danymi
w programie, a nawet odkryjesz kilka pilnie strzeżonych sekretów obiektów (psssst...
obiekty to także dane).
186
182
184
185
Typ zmiennej określa rodzaj danych, jakie zmienna może przechowywać
Zmienna jest jak kubek z danymi
10 kilogramów danych w pięciokilogramowej torebce
Nawet wtedy, gdy liczba ma prawidłowy rozmiar, nie możesz przypisać jej
do każdej zmiennej
Kiedy rzutujesz wartość, która jest zbyt duża, C# dopasowuje ją
187
automatycznie
C# przeprowadza niektóre rzutowania automatycznie
188
Kiedy wywołujesz metodę, zmienne muszą pasować do typów parametrów 189
Przetestuj kalkulator zwrotu kosztów
193
194
Połączenie = z operatorem
Także obiekty używają zmiennych
195
196
Korzystaj ze swoich obiektów za pomocą zmiennych referencyjnych
Referencje są jak etykiety do Twoich obiektów
197
Jeżeli nie ma już żadnej referencji, Twoje obiekty są usuwane z pamięci
198
199
Referencje wielokrotne i ich efekty uboczne
204
Dwie referencje oznaczają DWA sposoby na zmianę danych obiektu
Specjalny przypadek: tablice
205
206
Tablice mogą także zawierać grupę zmiennych referencyjnych
207
Witamy w barze Niechlujny Janek — najtańsze kanapki w mieście!
209
Obiekty używają referencji do komunikacji między sobą
Tam, gdzie obiektów jeszcze nie było
210
215
Napisz grę w literki
Kontrolki to też obiekty, podobne do innych
219
13
1
r
e
l u c k y
O
biekt D o g num
fido
2
r
e
O
b
iekt Do g num
l u c k y
1
r
e
O
biekt D o g num
pyk!
fido
2
r
e
O
b
iekt Do g num
Kup książkęPoleć książkęLaboratorium C# numer 1
Dzień na wyścigach
Janek, Bartek i Arek uwielbiają chodzić na tor wyścigowy, ale ciągła utrata pieniędzy powoduje u nich
frustrację. Potrzebują symulatora, aby mogli określić zwycięzcę, zanim wyłożą pieniądze na zakłady.
Jeśli dobrze wywiążesz się z zadania, będziesz miał procenty z ich wygranych.
Specyfikacja: stwórz symulator wyścigów
Końcowy produkt
226
234
Spis treści
14
14 14 14
Kup książkęPoleć książkęSpis treści
5
Hermetyzacja
Co ma być ukryte… niech będzie ukryte
Czy kiedykolwiek marzyłeś o odrobinie prywatności? Czasami Twoje obiekty
czują się tak samo. Na pewno nie lubisz sytuacji, w których ktoś, komu nie ufasz, czyta Twój
pamiętnik lub przegląda wykazy Twoich operacji bankowych. Dobre obiekty nie pozwalają
innym obiektom na oglądanie swoich pól. W tym rozdziale nauczysz się wykorzystywać
potęgę hermetyzacji. Sprawisz, że dane obiektów będą prywatne, i dodasz metody,
które umożliwią Ci zabezpieczenie dostępu do danych.
Krystyna planuje przyjęcia
Co powinien robić program szacujący?
Napiszesz program dla Krystyny
Jazda próbna Krystyny
Każda opcja powinna być obliczana osobno
Bardzo łatwo przez przypadek źle skorzystać z obiektów
Hermetyzacja oznacza, że niektóre dane w klasie są prywatne
Użyj hermetyzacji w celu kontroli dostępu do metod i pól Twojej klasy
Ale czy jego prawdziwa tożsamość jest NAPRAWDĘ chroniona?
Dostęp do prywatnych pól i metod można uzyskać tylko z wnętrza klasy
Hermetyzacja utrzymuje Twoje dane w nieskazitelnym stanie
Właściwości sprawią, że hermetyzacja będzie łatwiejsza
Utwórz aplikację do przetestowania klasy Farmer
Użyj automatycznych właściwości do ukończenia klasy
Co wtedy, gdy chcemy zmienić pole mnożnika wyżywienia?
Użyj konstruktora do inicjalizacji pól prywatnych
236
237
238
244
246
248
249
250
251
252
260
261
262
263
264
265
e nt
ciaA g
kgbA g ent
mi5A g ent
Ilość gości.
Jedzenie
(25 zł od osoby)
Opcja zdrowa?
Tak
Nie
Soki i napoje
gazowane (5 zł
od osoby + 5
rabatu na całe
przyjęcie)
Alkohol
(20 zł od osoby)
Dekoracje
fantazyjne?
Tak
Dekoracje
fantazyjne
(15 zł od osoby
+ 50 zł opłaty za
dekoracje)
Nie
Zwykła deko-
racja (7,50
zł od osoby +
30 zł opłaty za
dekoracje)
15
Kup książkęPoleć książkęSpis treści
6
Dziedziczenie
Drzewo genealogiczne Twoich obiektów
Czasami CHCIAŁBYŚ być dokładnie taki sam jak Twoi rodzice.
Czy kiedykolwiek natknąłeś się na obiekt, który robiłby prawie wszystko, czego byś
sobie od niego życzył? Czy kiedykolwiek znalazłeś się w takiej sytuacji, że gdybyś zmienił
dosłownie kilka rzeczy, obiekt byłby doskonały? Cóż, to tylko jeden z wielu powodów,
które sprawiają, że dziedziczenie zalicza się do najważniejszych koncepcji i technik
w języku C#. Kiedy skończysz czytać ten rozdział, będziesz wiedział, jak rozszerzać obiekty,
by móc wykorzystywać ich zachowania i jednocześnie dysponować elastycznością,
która pozwoli Ci te zachowania modyfikować. Unikniesz wielokrotnego pisania kodu,
przedstawisz prawdziwy świat znacznie dokładniej, a w efekcie otrzymasz kod łatwiejszy
do zarządzania.
Krystyna organizuje także przyjęcia urodzinowe
Potrzebujemy klasy BirthdayParty
Stwórz program Planista przyjęć w wersji 2.0
Jeszcze jedna rzecz… Czy możesz dodać opłatę 100 zł za przyjęcia
dla ponad 12 osób?
Kiedy klasy używają dziedziczenia, kod musi być napisany tylko raz
Zbuduj model klasy, rozpoczynając od rzeczy ogólnych
i przechodząc do bardziej konkretnych
W jaki sposób zaprojektowałbyś symulator zoo?
Użyj dziedziczenia w celu uniknięcia powielania kodu w klasach potomnych
Różne zwierzęta wydają różne dźwięki
Pomyśl, w jaki sposób pogrupować zwierzęta
Stwórz hierarchię klas
Każda klasa pochodna rozszerza klasę bazową
Aby dziedziczyć po klasie bazowej, użyj dwukropka
Wiemy, że dziedziczenie dodaje pola, właściwości i metody klasy bazowej
do klasy potomnej…
Klasa pochodna może przesłaniać odziedziczone metody
w celu ich modyfikacji lub zmiany
W każdym miejscu, gdzie możesz skorzystać z klasy bazowej,
możesz zamiast niej użyć jednej z jej klas pochodnych
Klasa pochodna może ukrywać metody klasy bazowej
Używaj override i virtual, by dziedziczyć zachowania
Klasa potomna może uzyskać dostęp do klasy bazowej,
używając słowa kluczowego base
Jeśli Twoja klasa bazowa posiada konstruktor, klasa pochodna też musi go mieć
Teraz jesteś już gotowy do dokończenia zadania Krystyny
Stwórz system zarządzania ulem
Użyj dziedziczenia, aby rozszerzyć system zarządzania pszczołami
276
277
278
285
286
287
288
289
290
291
292
293
294
297
298
299
306
308
310
311
312
317
324
16
Kup książkęPoleć książkęSpis treści
7
Interfejsy i klasy abstrakcyjne
Klasy, które dotrzymują swoich obietnic
Czyny potrafią powiedzieć więcej niż słowa. Czasami potrzebujesz pogrupować
swoje obiekty na podstawie tego, co robią, zamiast tego, po jakiej klasie dziedziczą. To jest
moment, w którym należy powiedzieć o interfejsach. Pozwalają one na pracę z każdą
klasą, która jest w stanie wykonać daną czynność. Jednak wraz z wielkimi możliwościami
przychodzi wielka odpowiedzialność i każda klasa, która implementuje interfejs, musi
wypełnić wszystkie swoje obowiązki… albo kompilator połamie Ci nogi, zrozumiałeś?
Dziedziczenie
Abstrakcja
Hermetyzacja
Polimorfizm
Salon
Jadalnia
Kuchnia
Podwórko
przed domem
Podwórko
za domem
Ogród
Wróćmy do pszczelej korporacji
Możemy użyć dziedziczenia do utworzenia klas dla różnych typów pszczół
Interfejs daje klasie do zrozumienia, że musi ona zaimplementować
określone metody i właściwości
Użyj słowa kluczowego interface do zdefiniowania interfejsu
Teraz możesz utworzyć instancję NectarStinger, która będzie wykonywała
dwa rodzaje zadań
Klasy implementujące interfejsy muszą zawierać WSZYSTKIE ich metody
Poćwicz trochę z interfejsami
Nie możesz utworzyć instancji interfejsu, ale możesz uzyskać jego referencję
Referencje interfejsów działają tak samo jak referencje obiektów
Za pomocą „is” możesz sprawdzić, czy klasa implementuje określony interfejs
Interfejsy mogą dziedziczyć po innych interfejsach
RoboBee 4000 może wykonywać zadania pszczół bez potrzeby
spożywania cennego miodu
Ekspres do kawy także jest urządzeniem
Rzutowanie w górę działa w odniesieniu do obiektów i interfejsów
Rzutowanie w dół pozwala zamienić urządzenie
z powrotem w ekspres do kawy
Rzutowanie w górę i w dół działa także w odniesieniu do interfejsów
Jest coś więcej niż tylko public i private
Modyfikatory dostępu zmieniają widoczność
Obiekty niektórych klas nigdy nie powinny być tworzone
Klasa abstrakcyjna jest jak skrzyżowanie klasy i interfejsu
Jak wspominaliśmy, obiekty niektórych klas nigdy nie powinny być tworzone
Metoda abstrakcyjna nie ma ciała
Piekielny diament śmierci
Polimorfizm oznacza, że jeden obiekt może przyjmować wiele różnych postaci
330
331
332
333
334
335
336
338
339
340
341
342
344
345
346
347
351
352
355
356
358
359
364
367
17
Kup książkęPoleć książkęSpis treści
8
Typy wyliczeniowe i kolekcje
Przechowywanie dużej ilości danych
Z deszczu pod rynnę. W rzeczywistym świecie nie musisz się zwykle zajmować danymi
w małych ilościach i w niewielkich fragmentach. Nie, Twoje dane przychodzą do Ciebie
w grupach, stosach, pękach, kopach. Potrzebujesz jakiegoś potężnego narzędzia do ich
zorganizowania. Nadszedł czas, aby przedstawić kolekcje. Pozwalają one przechowywać
i sortować dane, a także zarządzać tymi z nich, które Twój program musi przeanalizować.
Dzięki temu możesz myśleć o pisaniu programów do pracy z danymi, a samo ich
przechowywanie zostawić kolekcjom.
Łańcuchy znaków nie zawsze sprawdzają się
przy kategoryzowaniu danych
Typy wyliczeniowe pozwalają Ci wyliczyć prawidłowe wartości
Typy wyliczeniowe pozwalają na reprezentowanie liczb za pomocą nazw
Z tablicami ciężko się pracuje
Listy ułatwiają przechowywanie kolekcji… czegokolwiek
Listy są bardziej elastyczne niż tablice
Listy kurczą się i rosną dynamicznie
Typy generyczne mogą przechowywać każdy typ
Inicjalizatory kolekcji działają tak samo jak inicjalizatory obiektu
Stwórzmy listę kaczek
Listy są proste, ale SORTOWANIE może być skomplikowane
IComparable T pomoże Ci posortować listę kaczek
Użyj interfejsu IComparer, aby powiedzieć liście, jak ma sortować
Utwórz instancję obiektu porównującego
IComparer może wykonywać złożone porównania
Przesłonienie metody ToString() pozwala obiektom przedstawiać się
Zmień pętle foreach tak, by obiekty Duck i Card same się opisywały
Pisząc pętlę foreach, używasz IEnumerable T
Używając IEnumerable, możesz rzutować całą listę w górę
Możesz tworzyć własne przeciążone metody
Użyj słownika do przechowywania kluczy i wartości
Wybrane funkcjonalności słownika
Napisz program korzystający ze słownika
I jeszcze WIĘCEJ typów kolekcji...
Kolejka działa według reguły: pierwszy przyszedł, pierwszy wyszedł
Stos działa według reguły: ostatni przyszedł, pierwszy wyszedł
386
387
388
392
393
394
397
398
402
403
404
405
406
407
408
411
412
413
414
415
421
422
423
435
436
437
pyk!
18
Kup książkęPoleć książkęSpis treści
9
Odczyt i zapis plików
Zachowaj te bajty dla mnie!
Czasem opłaca się być trwałym. Do tej pory wszystkie programy były krótkotrwałe.
Uruchamiały się, działały przez chwilę i były zamykane. Czasami nie jest to wystarczające,
zwłaszcza jeżeli zajmujesz się ważnymi danymi. Musisz mieć możliwość zapisania swojej
pracy. W tym rozdziale pokażemy sposób zapisywania danych do pliku, a następnie
wczytywania tych informacji z powrotem do programu. Dowiesz się co nieco o klasach
strumieni .NET i zetkniesz się z tajemnicami systemów szesnastkowego i dwójkowego.
C# używa strumieni do zapisu i odczytu danych
Różne strumienie zapisują i odczytują różne rzeczy
FileStream odczytuje dane z pliku i zapisuje je w nim
W jaki sposób zapisać tekst do pliku w trzech prostych krokach
Kanciarz wymyślił nowy diabelski plan
Zapis i odczyt wymaga dwóch obiektów
Dane mogą przechodzić przez więcej niż jeden strumień
Użyj wbudowanych obiektów do wyświetlenia
standardowych okien dialogowych
Okna dialogowe są kolejnymi kontrolkami .NET
Okna dialogowe także są obiektami
Używaj wbudowanych klas File oraz Directory do pracy z plikami i katalogami
Używaj okien dialogowych do otwierania i zapisywania plików
(wszystko za pomocą kilku linijek kodu)
Dzięki IDisposable obiekty usuwane są prawidłowo
Unikaj błędów systemu plików, korzystając z instrukcji using
Zapisywanie danych do plików wymaga wielu decyzji
Użyj instrukcji switch do wybrania właściwej opcji
Dodaj przeciążony konstruktor Deck(), który wczytuje karty z pliku
Kiedy obiekt jest serializowany, serializowane są także wszystkie obiekty
z nim powiązane…
Serializacja pozwala Ci zapisywać lub odczytywać całe grafy obiektów naraz
.NET automatycznie konwertuje tekst do postaci Unicode
C# może użyć tablicy bajtów do przesyłania danych
Do zapisywania danych binarnych używaj klasy BinaryWriter
Pliki utworzone dzięki serializacji można także zapisywać i odczytywać ręcznie
Sprawdź, gdzie pliki się różnią, i użyj tej informacji do ich zmiany
Praca z plikami binarnymi może być skomplikowana
Użyj strumieni plików do utworzenia widoku w postaci szesnastkowej
StreamReader i StreamWriter będą do tego odpowiednie
442
443
444
445
446
449
450
453
454
455
456
459
461
462
468
469
471
475
476
481
482
483
485
486
487
488
489
19
m
O
biekt Fi l e Strea
6 9 117 114 101 107 97 33
m
O
biekt Fi l e Strea
Kup książkęPoleć książkęLaboratorium C# numer 2
Wyprawa
Twoim zadaniem jest stworzenie gry przygodowej, w której potężny wojownik wyrusza na
wyprawę i dzielnie walczy, poziom za poziomem, ze śmiertelnie niebezpiecznymi wrogami.
Stworzysz system turowy. Oznacza to, że najpierw gracz wykonuje jeden ruch, a następnie
ruch wykonuje przeciwnik. Gracz może przesunąć się lub zaatakować; potem możliwość
ruchu i ataku dostaje każdy z wrogów. Gra toczy się do czasu, aż gracz pokona wszystkich
przeciwników na wszystkich siedmiu poziomach lub zginie.
Specyfikacja: utwórz grę przygodową
Zabawa dopiero się zaczyna!
496
516
Spis treści
20
Kup książkęPoleć książkęSpis treści
10
Projektowanie aplikacji dla Sklepu Windows z użyciem XAML
Przenosząc swoje aplikacje na wyższy poziom
Jesteś już gotów, by wkroczyć do zupełnie nowego świata tworzenia aplikacji.
Korzystanie z technologii WinForms do tworzenia klasycznych aplikacji dla systemu Windows
jest doskonałym sposobem nauki ważnych rozwiązań języka C#, niemniej jednak możesz
pójść znacznie dalej. W tym rozdziale dowiesz się, jak używać języka XAML do projektowania
aplikacji przeznaczonych dla Sklepu Windows, nauczysz się tworzyć aplikacje działające na
dowolnych urządzeniach, integrować dane ze stronami przy użyciu wiązania danych
i używać Visual Studio do ujawniania tajemnic stron XAML poprzez badanie obiektów
tworzonych na podstawie kodu XAML.
Siatka składa się z kwadratów o wielkości
.
20 pikseli, nazywanych jednostkami .
Każda jednostka jest podzielona na
podjednostki o wielkości 5 pikseli.
POWIAZANIE
ItemsSource= {Binding}
POWIĄZANIE
POWIAZANIE
Observa bleColle
ItemsSource= {Binding}
Obiekt ListBox
Obiekt ListBox
Damian używa Windows 8
Technologia Windows Forms korzysta z grafu obiektów
stworzonego przez IDE
Użyj IDE do przejrzenia grafu obiektów
Aplikacje dla Sklepu Windows używają XAML do tworzenia obiektów
interfejsu użytkownika
Przeprojektuj formularz Idź na ryby!, zmieniając go w aplikację
dla Sklepu Windows
Określanie postaci strony rozpoczyna się od dodania kontrolek
Wiersze i kolumny mogą zmieniać wielkość, dostosowując się
do rozmiarów strony
Skorzystaj z systemu siatki, by określić układ stron aplikacji
Wiązanie danych kojarzy strony XAML z klasami
Kontrolki XAML mogą zawierać tekst… i nie tylko
Użyj wiązania danych, by usprawnić aplikację Niechlujnego Janka
Korzystaj z zasobów statycznych, by deklarować obiekty
w kodzie XAML
Wyświetlaj obiekty, używając szablonów danych
Interfejs INotifyPropertyChanged pozwala powiązanym obiektom
przesyłać aktualizacje
Zmodyfikuj klasę MenuMaker, by informowała Cię, gdy zmieni się
właściwość GeneratedDate
518
524
527
528
530
532
534
536
542
544
546
552
554
556
557
n
o
i
n
o
i
t
c
t
c
Observa bleColle
21
Kup książkęPoleć książkęSpis treści
11
Async, await i serializacja kontraktu danych
Przepraszam, że przerywam
Nikt nie lubi być zmuszanym do oczekiwania… zwłaszcza użytkownicy.
Komputery są doskonałe w wykonywaniu wielu rzeczy jednocześnie, nie ma zatem żadnego
powodu, aby Twoje aplikacje nie mogły tego robić. W tym rozdziale dowiesz się, jak sprawić,
by dzięki zastosowaniu metod asynchronicznych Twoje aplikacje reagowały błyskawicznie.
Nauczysz się także korzystać z wbudowanych narzędzi do wybierania plików, wyświetlać
okienka z komunikatami oraz asynchronicznie zapisywać i odczytywać dane z plików
bez „zawieszania” aplikacji. Połączysz te wszystkie możliwości z serializacją kontraktu danych
i opanujesz tworzenie bardzo nowoczesnych aplikacji.
Damian ma problemy z plikami
Aplikacje dla Sklepu Windows używają await, by błyskawicznie reagować
Używaj klasy FileIO do odczytywania i zapisywania plików
Napisz nieco mniej prosty edytor tekstów
Kontrakt danych jest abstrakcyjną definicją danych obiektu
Do odnajdywania i otwierania plików używaj metod asynchronicznych
Klasa KnownFolders ułatwia dostęp do najczęściej używanych folderów
W kodzie XML jest serializowany cały graf obiektów
Prześlij kilka obiektów Guy do lokalnego folderu aplikacji
Wypróbujmy działanie aplikacji
Używaj klasy Task, by wywoływać jedną metodę asynchroniczną w innej
Napisz dla Damiana nową aplikację do zarządzania wymówkami
Odrębna strona, wymówka i ExcuseManager
Utwórz stronę główną aplikacji Menedżera wymówek
Dodaj pasek aplikacji do strony głównej
Napisz klasę ExcuseManager
Dodaj kod obsługujący stronę
566
568
570
572
577
578
580
581
582
586
587
588
589
590
591
592
594
22
Kup książkęPoleć książkęSpis treści
12
Obsługa wyjątków
Gaszenie pożarów nie jest już popularne
Programiści nie mają być strażakami. Pracowałeś jak wół, przebrnąłeś przez
dokumentacje techniczne i kilka zajmujących książek Rusz głową!, wspiąłeś się na szczyt
swoich możliwości: jesteś mistrzem programowania. W dalszym ciągu musisz jednak
odrywać się od pracy, ponieważ program wyłącza się lub nie zachowuje się tak, jak
powinien. Nic nie wybija Cię z rytmu tak, jak obowiązek naprawienia dziwnego błędu...
Z obsługą wyjątków możesz jednak napisać kod, który poradzi sobie z pojawiającymi się
problemami. Jest nawet lepiej, możesz bowiem zareagować na ich pojawienie się i sprawić,
że wszystko będzie dalej działało.
Hej, ten prOgram
jest naprawdę stabilny!
tera z p r o g ram jest naprawdę odporny
public class Data {
public void
Process(Input i) {
try {
if (i.IsBad()) {
explode();
} catch {
HandleIt();
}
}
}
Twoja klasa, teraz już
z obsługą wyjątków
Oj, Oj! — cóż tO
się stałO?
użytkownik
O
biekt
int[] anArray = {3, 4, 1, 11};
int aValue = anArray[15];
O
biekt Ex c
e ption
Damian potrzebuje swoich wymówek, aby być mobilnym
Kiedy program zgłasza wyjątek, .NET tworzy obiekt Exception
Kod Damiana zrobił coś nieoczekiwanego
Wszystkie obiekty wyjątków dziedziczą po Exception
Debugger pozwala Ci wyśledzić wyjątki w kodzie i zapobiec im
Użyj debuggera wbudowanego w IDE, aby znaleźć problem
w programie do zarządzania wymówkami
Oj, oj! — w kodzie dalej są błędy...
Obsłuż wyjątki za pomocą try i catch
Co się stanie, jeżeli wywoływana metoda będzie niebezpieczna?
Użyj debuggera do prześledzenia przepływu w blokach try/catch
Jeśli posiadasz kod, który ZAWSZE musi zostać wykonany,
zastosuj finally
Użyj obiektu Exception w celu uzyskania informacji o problemie
Użyj więcej niż jednego bloku catch do wyłapania
różnych typów wyjątków
Jedna klasa zgłasza wyjątek, inna klasa go przechwytuje
Łatwy sposób na uniknięcie licznych problemów: using umożliwia Ci
stosowanie try i finally za darmo
Unikanie wyjątków: zaimplementuj IDisposable, aby przeprowadzić
własne procedury sprzątania
Najgorszy z możliwych bloków catch: komentarze
Kilka prostych wskazówek dotyczących obsługi wyjątków
600
604
606
608
609
610
613
615
616
618
620
625
626
627
631
632
634
636
23
Kup książkęPoleć książkęSpis treści
13 Kapitan Wspaniały
Śmierć obiektu
648
650
651
655
655
656
Twoją ostatnią szansą na ZROBIENIE czegoś… jest użycie finalizatora 646
Kiedy DOKŁADNIE wywoływany jest finalizator?
647
Dispose() działa z using, a finalizatory działają z mechanizmem
oczyszczania pamięci
Finalizatory nie mogą polegać na stabilności
Spraw, aby obiekt serializował się w Dispose()
Struktura jest podobna do obiektu…
…ale nie jest obiektem
Wartości są kopiowane, referencje są przypisywane
Struktury traktowane są jak typy wartościowe,
obiekty jak typy referencyjne
Stos i sterta: więcej na temat pamięci
Używaj parametrów wyjściowych, by zwracać z metody
więcej niż jedną wartość
Przekazuj referencje, używając modyfikatora ref
Używaj parametrów opcjonalnych, by określać wartości domyślne
Jeśli musisz używać wartości pustych, stosuj typy, które je akceptują
Typy akceptujące wartości puste poprawiają odporność programów
„Kapitan” Wspaniały… nie tak bardzo
Metody rozszerzające zwiększają funkcjonalność ISTNIEJĄCYCH klas
Rozszerzanie podstawowego typu: string
662
663
664
665
666
669
670
672
657
659
Obiektowie
24
Kup książkęPoleć książkęSpis treści
14
Przeszukiwanie danych i tworzenie aplikacji przy użyciu LINQ
Przejmij kontrolę nad danymi
To świat przepełniony danymi... Lepiej, żebyś wiedział, jak w nim żyć.
Czasy, gdy mogłeś programować kilka dni, a nawet kilka tygodni, bez konieczności pracy
z ogromem danych, minęły już bezpowrotnie. Nadeszła epoka, w której wszystko opiera
się na nich. W tym miejscu do akcji wkracza LINQ. To nie tylko sposób na pobieranie
danych w prosty, intuicyjny sposób. Pozwala on także grupować i łączyć dane pochodzące
z różnych źródeł. A kiedy już podzielisz dane na fragmenty, którymi można łatwo zarządzać,
Twoje aplikacje dla Sklepu Windows będą korzystać z kontrolek do nawigowania,
pozwalających poruszać się po danych, przeglądać je, a nawet powiększać i wyświetlać
szczegółowe informacje na ich temat.
Janek jest superfanem Kapitana Wspaniałego…
…ale jego kolekcja zajmuje każde wolne miejsce
Dzięki LINQ możesz pobrać dane z różnych źródeł
Kolekcje .NET są przystosowane do działania z LINQ
LINQ ułatwia wykonywanie zapytań
LINQ jest prosty, ale Twoje zapytania wcale takie być nie muszą
Janek chętnie skorzystałby z pomocy
Zacznij pisać aplikację dla Janka
Używaj słowa kluczowego new, by tworzyć typy anonimowe
LINQ ma wiele zastosowań
Dodaj nowe zapytania do aplikacji Janka
LINQ może połączyć Twoje wyniki w grupy
Połącz wartości Janka w grupy
Użyj join do połączenia dwóch kolekcji w jedną sekwencję
Janek zaoszczędził mnóstwo szmalu
Użyj semantycznego powiększenia, aby przejść do danych
Dodaj zoom semantyczny do aplikacji Janka
Zrobiłeś na Janku wielkie wrażenie
Szablon Split App ułatwia tworzenie aplikacji służących
do przeglądania danych
678
679
680
681
682
683
686
688
691
694
696
701
702
705
706
712
714
719
720
25
Kup książkęPoleć książkęSpis treści
15
Zdarzenia i delegaty
Co robi Twój kod, kiedy nie patrzysz
Twoje obiekty zaczynają myśleć o sobie. Nie możesz zawsze kontrolować tego,
co one robią. Czasami różne rzeczy... zdarzają się. Kiedy to następuje, chciałbyś, aby Twoje
obiekty były wystarczająco sprytne i odpowiednio reagowały. To miejsce, w którym do akcji
wkraczają zdarzenia. Jeden obiekt udostępnia zdarzenie, inny je obsługuje i wszystko pracuje
razem, aby całość działała sprawnie. Jest to wspaniałe, o ile nie chcesz, by Twój obiekt mógł
kontrolować, kto będzie mógł nasłuchiwać jego zdarzeń. Wtedy bardzo pomocne okazują się
funkcje zwrotne.
Czy kiedykolwiek marzyłeś o tym, aby Twoje obiekty
potrafiły samodzielnie myśleć?
Ale skąd obiekt WIE, że ma odpowiedzieć?
Kiedy wystąpi ZDARZENIE... obiekty nasłuchują
Jeden obiekt wywołuje zdarzenie, inne nasłuchują...
Potem inne obiekty obsługują zdarzenie
Łącząc punkty
IDE automatycznie tworzy za Ciebie procedury obsługi zdarzeń
Ogólny typ EventHandler pozwala definiować własne typy zdarzeń
Formularze używają wielu różnych zdarzeń
Jedno zdarzenie, wiele procedur obsługi
Aplikacje dla Sklepu Windows używają zdarzeń
do zarządzania cyklem życia procesu
Dodaj zarządzanie cyklem życia procesu do aplikacji Janka
Kontrolki XAML korzystają ze zdarzeń trasowanych
Utwórz aplikację do badania zdarzeń trasowanych
Połączenie nadawców zdarzenia z jego odbiorcami
Delegat ZASTĘPUJE właściwą metodę
Delegat w akcji
Każdy obiekt może subskrybować publiczne zdarzenie...
Użyj funkcji zwrotnej, by wiedzieć, kto nasłuchuje
Funkcje zwrotne są jedynie sposobem używania delegatów
Możesz używać funkcji zwrotnych w oknach dialogowych
MessageDialog
Użyj delegatów, by skorzystać z panelu Ustawienia
730
730
731
732
733
734
738
744
745
746
748
749
752
753
758
759
760
763
764
766
768
770
~Zdarzenie BallInPlay
B
allEvent A r gs
Obie
k
t
P
itcher
26
O
b
i
e
k
t Umpire
Obiek t Fan
Kup książkęPoleć książkęSpis treści
16
Projektowanie aplikacji według wzorca MVVM
Świetne aplikacje od zewnątrz i od środka
Twoje aplikacje muszą być nie tylko wspaniałe wizualnie. Kiedy mówimy
o projekcie, co Ci przychodzi do głowy? Przykład jakiejś wspaniałej architektury budowlanej?
Doskonale rozplanowana strona WWW? Produkt zarówno estetyczny, jak i dobrze
zaprojektowany? Dokładnie te same zasady odnoszą się do aplikacji. W tym rozdziale poznasz
wzorzec Model-View-ViewModel (MVVM, model-widok-widok modelu) i dowiesz się,
jak używać go do tworzenia dobrze zaprojektowanych aplikacji o luźnych powiązaniach. Przy
okazji poznasz animacje, szablony kontrolek używane do projektowania wyglądu aplikacji,
nauczysz się stosować konwertery, by ułatwiać korzystanie z techniki wiązania danych,
a w końcu zobaczysz, jak połączyć te wszystkie elementy, by stworzyć solidne podstawy
do tworzenia dowolnych aplikacji w języku C#.
M O D E L
w i d o k U
776
777
774
775
Liga „Koszykówka. Rusz głową” potrzebuje swojej aplikacji
Jednak czy wszyscy uzgodnią, jak napisać tę aplikację?
Czy projektujesz pod kątem wiązania danych,
czy łatwości pracy z danymi?
Wzorzec MVVM pozwala projektować, uwzględniając
zarówno wiązanie, jak i dane
Użyj wzorca MVVM, by rozpocząć tworzenie aplikacji
778
dla ligi koszykówki
781
Kontrolki użytkownika pozwalają tworzyć swoje własne kontrolki
789
Sędziowie potrzebują stopera
790
Wzorzec MVVM oznacza myślenie o stanie aplikacji
791
Zacznij tworzenie modelu aplikacji stopera
792
Zdarzenia ostrzegają resztę aplikacji o zmianie stanu
793
Utwórz widok prostej aplikacji stopera
794
Dodaj model widoku aplikacji stopera
798
Konwertery automatycznie konwertują wartości na potrzeby powiązań
800
Konwertery mogą operować na wielu różnych typach danych
Stan wizualny sprawia, że kontrolki odpowiadają na zmiany
806
Używaj DoubleAnimation, by animować wartości zmiennoprzecinkowe 807
808
Używaj animacji obiektów do animowania wartości obiektów
809
Stwórz stoper wskazówkowy, używając tego samego modelu widoku
814
Kontrolki interfejsu użytkownika można także tworzyć w kodzie C#
C# pozwala także na tworzenie „prawdziwych” animacji
816
817
Użyj kontrolki użytkownika, by wyświetlać rysunki tworzące animację
818
Niech Twoje pszczoły latają po stronie
821
Użyj ItemsPanelTemplate, by powiązać pszczoły z kontrolką Canvas
Gratulujemy! (Choć jeszcze nie skończyłeś…)
834
27
Kup książkęPoleć książkęLaboratorium C# numer 3
Invaders
Dzięki temu laboratorium oddasz hołd jednej z najbardziej popularnych, czczonych
i powielanych ikon w historii gier komputerowych. Nie potrzebuje ona żadnego wprowadzenia.
Czas utworzyć grę Invaders.
Dziadek wszystkich gier
Można zrobić znacznie więcej...
836
857
Spis treści
28
Kup książkęPoleć książkęSpis treści
17
Projekt dodatkowy!
Napisz aplikację Windows Phone
Klasy, obiekty, XAML, hermetyzacja, dziedziczenie, polimorfizm, LINQ, MVVM… dysponujesz już
wszystkimi narzędziami niezbędnymi do pisania wspaniałych aplikacji dla Sklepu Windows oraz
tradycyjnych aplikacji okienkowych. Czy jednak wiesz, że tych samych narzędzi możesz użyć
do pisania aplikacji dla Windows Phone? Tak, to prawda! W tym dodatkowym projekcie
poznasz proces tworzenia gry dla systemu Windows Phone. Jeśli nie posiadasz odpowiedniego
urządzenia, to i tak nie masz się czym przejmować — będziesz mógł w nią grać na emulatorze
Windows Phone. A zatem zaczynajmy!
Atak pszczół!
Zanim zaczniesz...
860
861
29
Kup książkęPoleć książkęSpis treści
A
Pozostałości
11 najważniejszych rzeczy, które chcieliśmy
umieścić w tej książce
Zabawa dopiero się zaczyna! Pokazaliśmy Ci mnóstwo wspaniałych narzędzi do tworzenia
naprawdę potężnych programów w C#. Nie było jednak możliwe, abyśmy w tej książce zmieścili
każde narzędzie, technologię i technikę — nie ma ona po prostu tylu stron. Musieliśmy
podjąć naprawdę przemyślaną decyzję, co umieścić, a co pominąć. Oto kilka tematów, których nie
mogliśmy przedstawić. Pomimo tego, że nie zajęliśmy się nimi, w dalszym ciągu myślimy, że są one
ważne i przydatne. Należałoby więc chociaż o nich wspomnieć. Tak też zrobiliśmy.
znacznie więcej
interfejsu użytkownika
1. Na temat aplikacji dla Sklepu Windows można dowiedzieć się
2. Podstawy
3. Przestrzenie nazw i złożenia
4. Użyj BackgroundWorker, by poprawić działanie
5. Klasa Type oraz metoda GetType()
6. Równość, IEquatable oraz Equals()
7. Stosowanie yield return do tworzenia obiektów
8. Refaktoryzacja
9. Anonimowe typy i metody oraz wyrażenia lambda
10. Zastosowanie LINQ to XML
11. Windows Presentation Foundation
Czy wiesz, że C# i .NET Framework potrafią…
umożliwiających iterację
874
876
882
886
889
890
893
896
898
900
902
903
905
S
Skorowidz
30
Kup książkęPoleć książkę10. Projektowanie aplikacji dla Sklepu Windows z użyciem XAML
Przenieś swoje aplikacje
na wyższy poziom
MAM NADZIEJĘ,
ŻE PAMIĘTAŁEM,
BY PRAWIDŁOWO SKOJARZYĆ
SWóJ TYŁEK
Z WŁAŚCIWOŚCIĄ
SIODŁO.
Jesteś już gotów, by wkroczyć do zupełnie nowego świata tworzenia aplikacji.
Korzystanie z technologii WinForms do tworzenia klasycznych aplikacji dla systemu Windows jest
doskonałym sposobem nauki ważnych rozwiązań języka C#, niemniej jednak możesz pójść znacznie
dalej. W tym rozdziale dowiesz się, jak używać języka XAML do projektowania aplikacji przeznaczonych
dla Sklepu Windows, nauczysz się tworzyć aplikacje działające na dowolnych urządzeniach,
integrować dane ze stronami przy użyciu wiązania danych i używać Visual Studio do ujawniania
tajemnic stron XAML poprzez badanie obiektów tworzonych na podstawie kodu XAML.
to jest nowy rozdział� 517
Kup książkęPoleć książkęW końcu nowoczesny wygląd
Damian używa Windows 8
Staromodne aplikacje Damiana dla systemu Windows wyglądają archaicznie! Damian
ma już dosyć ciągłego klikania malutkich pól wyboru. A chciałby, żeby jego program do
zarządzania wymówkami był aplikacją z prawdziwego zdarzenia. Czy możemy mu w tym
pomóc?
CO TO NIBY JEST, JAKIŚ
ZAMIERZCHŁY ROK 2003?
LUDZIE, ZAJMIJMY SIĘ TYM
PROGRAMEM!
Program do zarządzania wymówkami
Damiana działa, jednak przestarzały
klasyczny program dla systemu
Windows nie jest żadną konkurencją
dla prawdziwej, fantastycznej aplikacji,
w stu procentach przeznaczonej dla
Sklepu Windows.
518
Rozdział 10.
Kup książkęPoleć książkęProjektowanie aplikacji dla Sklepu Windows z użyciem XAML
Zrób to!
Chcesz szybko wtłoczyć te pomysły
do swojej głowy? Zatem zrób
opisane poniżej rzeczy, zanim
zaczniesz czytać ten rozdział!
Za kulisami
Aplikacje przeznaczone dla Sklepu Windows są bardziej skomplikowane niż programy WinForms. Dlatego też
programy WinForms są naprawdę efektywnym narzędziem do nauki, jednak nie radzą sobie równie dobrze,
gdy chodzi o napisanie niezwykle odlotowej aplikacji. Czasami warto cofnąć się o krok i pomyśleć o tym,
jak się uczymy, gdyż to pomoże nam robić to bardziej efektywnie. A zatem spróbujmy to zrobić teraz.
Stworzyłeś już sobie doskonałe podstawy, zdobywając podstawową wiedzę o języku C#, obiektach, kolekcjach
i innych narzędziach .NET. Teraz jednak wrócimy do tworzenia aplikacji dla Sklepu Windows przy wykorzystaniu
języka XAML. Na kilku następnych stronach spróbujemy skorzystać z możliwości IDE do badania obiektów, które
tworzą i którymi zarządzają programy WinForms. Kiedy później użyjesz IDE do badania obiektów tworzonych
w aplikacjach dla Sklepu Windows pisanych przy użyciu języka XAML, staraj się wychwytywać różnice
— oraz, co jest równie ważne, podobieństwa pomiędzy nimi.
Wykonaj poniższe czynności, zanim zaczniesz dalszą lekturę tego rozdziału
Cały rozdział 1. i znaczną część rozdziału 2. przeznaczyliśmy na przedstawienie tworzenia aplikacji przeznaczonych
dla Sklepu Windows przy wykorzystaniu języka XAML oraz platformy .NET Framework for Windows Store.
Teraz wykorzystamy wiedzę zdobytą w tamtych dwóch rozdziałach. Jeśli chcesz w możliwie jak największym stopniu
skorzystać z lektury tego rozdziału, sugerujemy, żebyś wykonał kilka przedstawionych poniżej czynności.
Dla niektórych przesiadka z WinForms na stosowanie języka XAML jest całkowicie bezproblemowa,
innych natomiast może drażnić. Te czynności przygotowawcze pomogą Ci szybciej przyswoić sobie
najważniejsze idee.
Wróć do rozdziału 1. i ponownie, od samego początku stwórz aplikację Ratuj ludzi. Tym razem upewnij się,
że wpisałeś ręcznie cały kod.
I nie zapomnij przeanalizować kodu aplikacji! Wciąż znajdują się w nim fragmenty, którymi jeszcze nie
zajmowaliśmy się szczegółowo, choć powinieneś już rozpoznawać je na tyle dobrze, byś mógł rozpocząć
tworzenie mentalnych podstaw.
Spróbuj dobrze zrozumieć tajniki działania gry. Nie staraj się jednak robić tego za wszelką cenę. Jak już
wspominaliśmy — wciąż pozostało sporo zagadnień, którymi w tej książce jeszcze nie zajmowaliśmy się.
Zwróć szczególną uwagę na zmiany wprowadzane w szablonie Basic Page oraz na sposób, w jaki
zastąpiliśmy nim domyślną stronę MainPage.xaml — w tym rozdziale będziesz bowiem to robił kilka razy.
Jeszcze raz wykonaj projekt XAML z rozdziału 2. Nie zapomnij zrobić także ćwiczenia. Teraz powinieneś
I jeszcze
jedno…
być gotowy!
W tej książce nie przedstawiliśmy wszystkich możliwości aplikacji WinForms. W rzeczywistości korzystają one
z silnika graficznego określanego jako GDI+, potrafiącego generować zaskakująco dobry interfejs graficzny
i materiały do druku oraz doskonale obsługiwać interakcję z użytkownikiem (choć wymaga ona znacznie
większego nakładu pracy niż w przypadku korzystania z języka XAML). Jednym z najważniejszych sposobów nauki
podstawowych zasad programowania jest przeanalizowanie tej samej rzeczy wykonanej na dwa różne sposoby.
jesteś tutaj� 519
Kup książkęPoleć książkęPotrafisz je znaleźć?
Detektywistyczne
poszukiwania!
Od czasu pierwszego projektu, Ratuj ludzi, przedstawionego w rozdziale 1., poznałeś już całkiem
sporo ważnych pojęć związanych z językiem C# i nabyłeś dużo praktyki w posługiwaniu się nimi.
Teraz nadszedł czas, by założyć kapelusz, wziąć lupę i przetestować swoje detektywistyczne
umiejętności. Sprawdź, czy będziesz w stanie odszukać wszystkie elementy C# w kodzie
aplikacji Ratuj ludzi. Aby ułatwić Ci początki poszukiwań, podaliśmy jedną z odpowiedzi.
Czy jesteś w stanie znaleźć pozostałe?
(Na niektóre z pytań jest więcej niż jedna prawidłowa odpowiedź).
Zastosowanie łańcucha znaków jako klucza podczas pobierania
obiektu z kolekcji Dictionary.
..............................................................................................................................
..............................................................................................................................
..............................................................................................................................
Zastosowanie inicjalizatora.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
Dodanie do tej samej kolekcji obiektów dwóch różnych typów.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
Wywołanie metody statycznej.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
520 Rozdział 10.
Kup książkęPoleć książkęProjektowanie aplikacji dla Sklepu Windows z użyciem XAML
Zastosowanie metody procedury obsługi zdarzeń.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
Użycie słowa kluczowego as w celu rzutowania obiektu w dół.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
Przekazanie do metody referencji do obiektu.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
Utworzenie instancji obiektu i wywołanie jednej z jego metod.
...............................................................................................................................
W metodzie AnimateEnemy() tworzony jest obiekt klasy
StoryBoard, a następnie wywoływana jest jego metoda
Begin().
..............................................................................................................................
..............................................................................................................................
Użycie typu wyliczeniowego w celu przypisania wartości.
...............................................................................................................................
..............................................................................................................................
..............................................................................................................................
jesteś tutaj� 521
Kup książkęPoleć książkęRozwiązanie detektywistycznych poszukiwań
Detektywistyczne
poszukiwania!
Rozwiązanie
Od czasu pierwszego projektu, Ratuj ludzi, przedstawionego w rozdziale 1., poznałeś już całkiem
sporo ważnych pojęć związanych z językiem C# i nabyłeś dużo praktyki w posługiwaniu się nimi.
Teraz nadszedł czas, by założyć kapelusz, wziąć lupę i przetestować swoje detektywistyczne
umiejętności. Sprawdź, czy będziesz w stanie odszukać wszystkie elementy C# w kodzie
aplikacji Ratuj ludzi. Aby ułatwić Ci początki poszukiwań, podaliśmy jedną z odpowiedzi.
Czy jesteś w stanie znaleźć pozostałe?
(Na niektóre z pytań jest więcej niż jedna prawidłowa odpowiedź).
Poniżej zamieściliśmy te, które
nam udało się znaleźć; Ty
mogłeś znaleźć zupełnie inne!
Zastosowanie łańcucha znaków jako klucza podczas pobierania
..............................................................................................................................
obiektu z kolekcji Dictionary.
W drugim wierszu metody AddEnemy() używany jest łańcuch
znaków „EnemyTemplate”, przy użyciu którego ze słownika
Resources pobierany jest obiekt ControlTemplate.
..............................................................................................................................
..............................................................................................................................
Zastosowanie inicjalizatora.
..............................................................................................................................
W metodzie AnimateEnemy() podczas inicjalizacji obiektu
DoubleAnimation określane są wartości trzech właściwości:
From, To oraz Duration.
..............................................................................................................................
..............................................................................................................................
Dodanie do tej samej kolekcji obiektów dwóch różnych typów.
...............................................................................................................................
W metodzie StartGame() do kolekcji playArea.Children
dodawany jest obiekt StackPanel (człowiek) oraz obiekt
Rectangle (docelowy portal).
..............................................................................................................................
..............................................................................................................................
Wywołanie metody statycznej.
...............................................................................................................................
W procedurze obsługi zdarzeń target_PointerEntered()
wywoływane są dwie statyczne metody klasy Canvas:
SetLeft() oraz SetTop().
..............................................................................................................................
..............................................................................................................................
522 Rozdział 10.
Kup książkęPoleć książkęProjektowanie aplikacji dla Sklepu Windows z użyciem XAML
Zastosowanie metody procedury obsługi zdarzeń.
...............................................................................................................................
W oknie Properties została określona procedura obsługi
zdarzeń PointerPressed obiektu StackPanel reprezentującego
człowieka.
..............................................................................................................................
..............................................................................................................................
Użycie słowa kluczowego as w celu rzutowania obiektu w dół.
...............................................................................................................................
Słownik Resources zwraca obiekt typu object, object ,
a zatem wartość odwołania Resources[”EnemyTemplate”]
jest rzutowana w dół na konkretny typ ControlTemplate.
..............................................................................................................................
..............................................................................................................................
Przekazanie do metody referencji do obiektu.
...............................................................................................................................
Referencja do obiektu ContentControl jest przekazywana
jako pierwszy parametr metody AnimateEnemy().
..............................................................................................................................
..............................................................................................................................
Utworzenie instancji obiektu i wywołanie jednej z jego metod.
...............................................................................................................................
W metodzie AnimateEnemy() tworzony jest obiekt klasy
StoryBoard, a następnie wywoływana jest jego metoda
Begin().
..............................................................................................................................
..............................................................................................................................
Użycie typu wyliczeniowego w celu przypisania wartości.
W metodzie EndTheGame() jest używany typ wyliczeniowy
...............................................................................................................................
Visibility, a konkretnie właściwości startButton.Visibility
jest przypisywana wartość Visibility.Visibile.
..............................................................................................................................
..............................................................................................................................
jesteś tutaj� 523
Kup książkęPoleć książkęZa kulisami Windows Forms
Technologia Windows Forms korzysta z grafu obiektów stworzonego przez IDE
Podczas tworzenia klasycznej aplikacji przeznaczonej dla systemu Windows IDE przygotowuje formularz i generuje jego
kod, który umieszcza w pliku Form1.Designer.cs. Ale co właściwie jest umieszczane w tym pliku? Nie jest to bynajmniej
nic tajemniczego. Już wiesz, że wszystkie kontrolki umieszczane na formularzu są obiektami, wiesz także, że referencje do
obiektów można zapisywać w polach. A zatem w jakimś miejscu wygenerowanego kodu musi się znaleźć deklaracja pola
reprezentującego każdy z obiektów formularza, kod służący do utworzenia tego obiektu oraz kod do wyświetlenia go na
formularzu. Spróbujmy odszukać te wiersze kodu, byśmy mogli dokładnie sprawdzić, co się dzieje w formularzu.
1
Otwórz projekt Prosty edytor tekstów, który napisałeś w rozdziale 9., i otwórz plik Form1.Designer.cs. Przewiń
jego zawartość w dół i odszukaj deklaracje pól. Powinieneś ujrzeć po jednej deklaracji pola dla każdej kontrolki
umieszczonej na formularzu.
2
Rozwiń sekcję kodu wygenerowanego przez projektanta formularzy i odszukaj kod tworzący kontrolki:
IDE mogło
wygenerować te
wiersze kodu w nieco
innej kolejności,
niemniej jednak na
pewno znajdzie się
tu po jednym wierszu
kodu dla każdej
kontrolki umieszczonej
na formularzu.
3
Kontrolki takie jak TableLayoutPanel oraz FlowLayoutPanel, mogące zawierać inne kontrolki, dysponują właściwością
o nazwie Controls. Jest to obiekt typu ControlCollection, który pod bardzo wieloma względami przypomina obiekt
typu List Control . Każda kontrolka umieszczana na formularzu jest obiektem klasy pochodnej klasy Control,
a dodanie jej do kolekcji Controls panelu spowoduje, że zostanie ona wyświetlona wewnątrz niego. Przewiń zawartość
pliku w dół, do miejsca, w którym do panelu FlowLayoutPanel dodawane są przyciski Zapisz i Otwórz:
Panel FlowLayoutPanel został z kolei umieszczony w komórce panelu TableLayoutPanel.
Odszukaj miejsce kodu, w którym on oraz pole tekstowe są dodawane do panelu zewnętrznego:
Także sam obiekt Form jest pojemnikiem, do którego zostaje dodany obiekt panelu TableLayoutPanel:
524 Rozdział 10.
Kup książkęPoleć książkęProjektowanie aplikacji dla Sklepu Windows z użyciem XAML
Będziesz musiał otworzyć plik Form1.Designer.cs z projektu
Prostego edytora tekstów, który napisałeś w rozdziale 9.
Zaostrz ołówek
Zaostrz ołówek
Przyjrzyj się instrukcjom new oraz wywołaniom metody Controls.Add()
wygenerowanym przez IDE w formularzu Prostego edytora tekstu
i narysuj graf obiektów tworzonych podczas wykonywania tego kodu.
n
o
i
t
c
e
n trolColl
Obiekt C o
Obiek t
F
o r m
g
o
l
a
i
D
o p e n F i l e D i a l o g 1
Obiekt O penFile
flowLayoutPanel1
tableLayoutPanel1
Do narysowania grafu obiektów będziesz
potrzebował wszystkich tych elementów
i oczywiście linii, które połączą poszczególne
obiekty. Ułatwiliśmy Ci zadanie, rysując
trzy pierwsze obiekty grafu.
open
saveFileDialog1
el
n
a
P
Obiekt F l o
t
bleLayou
Obiekt T a
el
n
a
P
t
wLayou
save
textBox1
n
o
i
t
c
Obiekt T e xtBox
n
o
i
e
n trolColl
Obiekt C o
Obiekt C o
t
c
e
n trolColl
D
Obiekt S aveFile
g
o
l
a
i
D
Obiekt O penFile
g
o
l
a
i
Obiekt B u tton
Obiekt B u tton
jesteś tutaj� 525
Kup książkęPoleć książkęFormularze WinForms są świetnym narzędziem dydaktycznym
Zaostrz ołówek
Zaostrz ołówek
Rozwiązanie
Przyjrzyj się instrukcjom new oraz wywołaniom metody Controls.Add()
wygenerowanym przez IDE w formularzu Prostego edytora tekstu
i narysuj graf obiektów tworzonych podczas wykonywania tego kodu.
n
o
i
t
c
e
n trolColl
textBox1
Obiekt T e xtBox
Obiekt C o
el
tableLayoutPanel1
n
a
P
t
c
e
o
i
n Obiekt T a
n trolColl
t
bleLayou
g
o
l
a
el
n
a
wLayou
P
flowLayoutPanel1
t
Obiekt F l o
i
D
s a v e F i l e D i a l o g 1
Obiekt S aveFile
Dwa obiekty reprezentujące okna dialogowe są
polami formularza; nie zostały jednak dodane do
jego kolekcji Controls, gdyż nie są one kontrolkami
posiadającymi jakąś reprezentację wizualną.
g
o
l
Obiekt C o
i
a
D
o p e n F i l e D i a l o g 1
Obiekt O penFile
save
Obiekt B u tton
Obiekt C o
Obiek t
F
o r m
n
o
i
t
c
e
n trolColl
o p e n
Obiekt B u tton
To Ci się naprawdę przyda, kiedy będziesz
wykonywał ćwiczenia. Przyjrzyj się także
drugiej metodzie dostępnej w klasie Debug.
Podpowiedź do debugowania
Metoda System.Diagnostics.Debug.WriteLine() pozwala wyświetlać tekst
w oknie wyników w trakcie sesji debugowania. Można jej używać tak samo jak
metody Console.WriteLine() w aplikacjach Windows Forms.
526 Rozdział 10.
Dwa obiekty Button zostały
dodane do kolekcji Controls
panelu FlowLayoutPanel,
dlatego też zawiera on
referencje do każdego z nich.
Referencje do nich są także
zapisane w polach open
i save formularza.
Kup książkęPoleć książkęProjektowanie aplikacji dla Sklepu Windows z użyciem XAML
Użyj IDE do przejrzenia grafu obiektów
Wróć do projektu Prostego edytora tekstu i umieść punkt przerwania na wywołaniu metody
InitializeComponent(), w konstruktorze formularza. Następnie uruchom debugowanie
programu. Gdy zostanie ono przerwane w punkcie przerwania, naciśnij klawisz F10,
by wejść do metody, po
Pobierz darmowy fragment (pdf)