Wyjątkowy podręcznik języka C#
Elementy języka i podstawowe koncepcje programistyczne
Techniki tworzenia najwyższej klasy aplikacji dla platformy .NET
Metody poprawy bezpieczeństwa i wydajności aplikacji
Język C#, pomimo stosunkowo krótkiej obecności na rynku, zyskał ogromną popularność i jest wykorzystywany przez wielu programistów. Trudno się temu dziwić -- ten łączący w sobie najlepsze cechy Javy i C++ obiektowy język programowania jest niezwykle uniwersalny. Można wykorzystać go w niemal każdym projekcie -- programów dla systemu Windows, dynamicznych witryn internetowych w technologii ASP.NET oraz aplikacji mobilnych dla platformy PocketPC. Prosta składnia, rozbudowane mechanizmy obsługi wyjątków i dostęp do ogromnej biblioteki klas .NET sprawiają, że C# jest doskonałym narzędziem.
Książka 'C# 2005. Warsztat programisty' to połączenie kursu i podręcznika programowania w tym języku. Czytając ją, opanujesz zarówno podstawy C#, jak i zaawansowane zagadnienia związane z tworzeniem bezpiecznych i wydajnych aplikacji. Poznasz typy danych, zasady stosowania zmiennych oraz składnię instrukcji i wyrażeń. Przeczytasz o programowaniu obiektowym, typach generycznych, obsłudze wyjątków i technikach programowania w C#. Znajdziesz tu również omówienie gramatyki języka C#, konwencji nazewniczych i zasad umieszczania komentarzy w dokumentacji XML.
Narzędzia programistyczne
Struktura języka C#
Typy danych
Wyrażenia i instrukcje
Przestrzenie nazw
Klasy i obiekty
Typy wyliczeniowe
Obsługa wyjątków
Typy generyczne
Poznaj nowoczesne metody tworzenia aplikacji.
Darmowy fragment publikacji:
C# 2005. Warsztat
programisty
Autor: Adrian Kingsley-Hughes, Kathie Kingsley-Hughes
T‡umaczenie:Wojciech Demski
ISBN: 978-83-246-1065-5
Tytu‡ orygina‡u: C# 2005 Programmers Reference
Format: B5, stron: 392
oprawa twarda
Wyj„tkowy podrŒcznik jŒzyka C#
(cid:149) Elementy jŒzyka i podstawowe koncepcje programistyczne
(cid:149) Techniki tworzenia najwy¿szej klasy aplikacji dla platformy .NET
(cid:149) Metody poprawy bezpieczeæstwa i wydajno(cid:156)ci aplikacji
JŒzyk C#, pomimo stosunkowo kr(cid:243)tkiej obecno(cid:156)ci na rynku, zyska‡ ogromn„
popularno(cid:156)(cid:230) i jest wykorzystywany przez wielu programist(cid:243)w. Trudno siŒ temu dziwi(cid:230)
(cid:150) ten ‡„cz„cy w sobie najlepsze cechy Javy i C++ obiektowy jŒzyk programowania
jest niezwykle uniwersalny. Mo¿na wykorzysta(cid:230) go w niemal ka¿dym projekcie
(cid:150) program(cid:243)w dla systemu Windows, dynamicznych witryn internetowych w technologii
ASP.NET oraz aplikacji mobilnych dla platformy PocketPC. Prosta sk‡adnia,
rozbudowane mechanizmy obs‡ugi wyj„tk(cid:243)w i dostŒp do ogromnej biblioteki klas .NET
sprawiaj„, ¿e C# jest doskona‡ym narzŒdziem.
Ksi„¿ka (cid:132)C# 2005. Warsztat programisty(cid:148) to po‡„czenie kursu i podrŒcznika
programowania w tym jŒzyku. Czytaj„c j„, opanujesz zar(cid:243)wno podstawy C#, jak
i zaawansowane zagadnienia zwi„zane z tworzeniem bezpiecznych i wydajnych
aplikacji. Poznasz typy danych, zasady stosowania zmiennych oraz sk‡adniŒ instrukcji
i wyra¿eæ. Przeczytasz o programowaniu obiektowym, typach generycznych, obs‡udze
wyj„tk(cid:243)w i technikach programowania w C#. Znajdziesz tu r(cid:243)wnie¿ om(cid:243)wienie
gramatyki jŒzyka C#, konwencji nazewniczych i zasad umieszczania komentarzy
w dokumentacji XML.
(cid:149) NarzŒdzia programistyczne
(cid:149) Struktura jŒzyka C#
(cid:149) Typy danych
(cid:149) Wyra¿enia i instrukcje
(cid:149) Przestrzenie nazw
(cid:149) Klasy i obiekty
(cid:149) Typy wyliczeniowe
(cid:149) Obs‡uga wyj„tk(cid:243)w
(cid:149) Typy generyczne
Poznaj nowoczesne metody tworzenia aplikacji
Wydawnictwo Helion
ul. Ko(cid:156)ciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Spis treści
O autorach .................................................................................................................................................. 15
Wprowadzenie ........................................................................................................................................... 17
Rozdział 1. Czym jest C#? ..........................................................................................................................23
Nazwa ......................................................................................................................... 23
Ogólny rzut oka na C# .................................................................................................. 23
Historia .................................................................................................................. 24
C# i CLR ................................................................................................................ 24
Wzmianka o .NET .................................................................................................... 25
Standardy ............................................................................................................... 25
Inne implementacje ................................................................................................. 25
Przykładowy kod C# ...................................................................................................... 26
Korzyści z nauki programowania w C# ............................................................................ 28
Podsumowanie ............................................................................................................ 28
Rozdział 2. Początki pracy z C# ...............................................................................................................29
Początki pracy z C# są tańsze, niż mogłoby się wydawać! ................................................ 29
Tanie opcje ............................................................................................................. 29
Jak pisać kod C#, stosując bezpłatne narzędzia ........................................................ 32
Tanie narzędzie, które ułatwia życie! .............................................................................. 35
Alternatywne edytory tekstowe i narzędzia C# ................................................................. 37
Narzędzia komercyjne: Visual Studio i Visual C# ............................................................. 37
Podsumowanie ............................................................................................................ 38
Rozdział 3. Ogólny rzut oka na C# ...........................................................................................................39
C# .............................................................................................................................. 39
Podstawy C# ................................................................................................................ 39
Czytanie źródłowego kodu C# ................................................................................... 40
Typy ............................................................................................................................ 41
Typy wartości .......................................................................................................... 41
Typy referencyjne .................................................................................................... 41
Typy predefiniowane ................................................................................................ 42
Przeciążanie ........................................................................................................... 44
Przekształcenia ....................................................................................................... 44
Typy tablicowe ........................................................................................................ 45
Zmienne i parametry ..................................................................................................... 45
Wyrażenia .................................................................................................................... 47
Instrukcje .................................................................................................................... 48
6
C# 2005. Warsztat programisty
Klasy ........................................................................................................................... 49
Stałe ...................................................................................................................... 50
Pola ....................................................................................................................... 50
Metody ................................................................................................................... 50
Właściwości ............................................................................................................ 51
Zdarzenia ............................................................................................................... 51
Operatory ............................................................................................................... 51
Indeksatory ............................................................................................................ 51
Konstruktory instancji .............................................................................................. 51
Destruktory ............................................................................................................ 52
Konstruktory statyczne ............................................................................................ 52
Dziedziczenie .......................................................................................................... 52
Klasy statyczne ....................................................................................................... 52
Struktury ..................................................................................................................... 53
Interfejsy ..................................................................................................................... 53
Delegacje .................................................................................................................... 53
Typy wyliczeniowe ......................................................................................................... 54
Typy generyczne ........................................................................................................... 54
Iteratory ...................................................................................................................... 54
Typy dopuszczające wartość pustą ................................................................................. 55
Podsumowanie ............................................................................................................ 55
Rozdział 4. Struktura języka C# ..............................................................................................................57
Programy C# ................................................................................................................ 57
Gramatyka ................................................................................................................... 59
Dwuznaczności gramatyczne .................................................................................... 59
Analiza leksykalna ................................................................................................... 61
Podsumowanie ............................................................................................................ 77
Rozdział 5. Koncepcje języka C# .............................................................................................................79
Uruchamianie aplikacji .................................................................................................. 79
Zamykanie aplikacji ...................................................................................................... 80
Deklaracje w C# ........................................................................................................... 80
Składowe .................................................................................................................... 83
Składowe przestrzeni nazw ...................................................................................... 83
Składowe struktur ................................................................................................... 83
Składowe wyliczeniowe ............................................................................................ 83
Składowe klas ........................................................................................................ 83
Składowe interfejsów .............................................................................................. 84
Składowe tablic ...................................................................................................... 85
Składowe delegacji ................................................................................................. 85
Dostęp do składowych .................................................................................................. 85
Deklarowana dostępność ......................................................................................... 85
Sygnatury .................................................................................................................... 86
Sygnatury indeksatorów ........................................................................................... 86
Sygnatury konstruktorów instancji ............................................................................ 86
Sygnatury metod ..................................................................................................... 86
Sygnatury operatorów .............................................................................................. 87
Sygnatury i przeciążanie .......................................................................................... 87
Zasięg ......................................................................................................................... 88
Nazwy przestrzeni nazw i typów ..................................................................................... 89
Spis treści
7
Zarządzanie pamięcią w C# ........................................................................................... 89
Podsumowanie ............................................................................................................ 90
Rozdział 6. Typy ......................................................................................................................................... 91
Trzy typy typów ............................................................................................................. 91
Różnice pomiędzy typami wartościowymi i referencyjnymi ........................................... 91
System typów w C# ...................................................................................................... 92
Typy wartościowe ......................................................................................................... 92
System.ValueType ................................................................................................... 94
Konstruktory domyślne ............................................................................................ 94
Typy strukturalne .................................................................................................... 94
Typy proste ............................................................................................................. 95
Typy całkowitoliczbowe ............................................................................................ 96
Określanie typów .................................................................................................... 97
Typy zmiennoprzecinkowe ........................................................................................ 98
Typy dziesiętne ....................................................................................................... 98
Typ bool ................................................................................................................. 99
Typy wyliczeniowe ................................................................................................... 99
Typy referencyjne ......................................................................................................... 99
Typy klas .............................................................................................................. 100
Typ object ............................................................................................................ 101
Typ string ............................................................................................................. 101
Typy tablicowe ...................................................................................................... 101
Typy delegacji ....................................................................................................... 101
Typ null ................................................................................................................ 101
Pakowanie i odpakowywanie .................................................................................. 101
Typy nullable ......................................................................................................... 102
Podsumowanie .......................................................................................................... 103
Rozdział 7. Zmienne ................................................................................................................................. 105
Czym są zmienne? ..................................................................................................... 105
Nie wszystkie zmienne tworzy się w ten sam sposób ............................................... 105
Kategorie zmiennych .................................................................................................. 106
Zmienne statyczne ................................................................................................ 107
Elementy tablicy .................................................................................................... 107
Zmienne instancji .................................................................................................. 108
Parametry wartości ............................................................................................... 109
Parametry referencyjne .......................................................................................... 109
Parametry wyjściowe ............................................................................................. 110
Zmienne lokalne ................................................................................................... 111
Wartości domyślne ..................................................................................................... 111
Przypisania niewątpliwe .............................................................................................. 111
Zmienne zainicjalizowane ....................................................................................... 112
Zmienne niezainicjalizowane .................................................................................. 112
Podsumowanie .......................................................................................................... 121
Rozdział 8. Przekształcenia ................................................................................................................... 123
Przekształcenia niejawne ............................................................................................ 123
Przekształcenia tożsamościowe ............................................................................. 124
Niejawne przekształcenia liczbowe ......................................................................... 124
Niejawne przekształcenia wyliczeniowe ................................................................... 125
Niejawne przekształcenia referencyjne .................................................................... 125
8
C# 2005. Warsztat programisty
Przekształcenia typu opakowywanie ........................................................................ 126
Niejawne przekształcenia parametrów typów ........................................................... 127
Niejawne przekształcenia wyrażeń stałych ............................................................... 127
Niejawne przekształcenia definiowane przez użytkownika ......................................... 127
Przekształcenia jawne ................................................................................................. 128
Jawne przekształcenia liczbowe .............................................................................. 128
Jawne przekształcenia wyliczeniowe ....................................................................... 130
Jawne przekształcenia referencyjne ........................................................................ 131
Przekształcenia typu odpakowywanie ...................................................................... 132
Jawne przekształcenia parametrów typu .................................................................. 132
Jawne przekształcenia definiowane przez użytkownika .............................................. 132
Przekształcenia standardowe ...................................................................................... 132
Standardowe przekształcenia niejawne ................................................................... 133
Standardowe przekształcenia jawne ........................................................................ 133
Przekształcenia definiowane przez użytkownika ....................................................... 133
Przekształcenia metod anonimowych ........................................................................... 134
Przekształcenia grup metod ........................................................................................ 134
Przekształcenia typu null ............................................................................................. 135
Przekształcenia dopuszczające wartość pustą ......................................................... 135
Podsumowanie .......................................................................................................... 136
Rozdział 9. Wyrażenia ............................................................................................................................. 137
Klasyfikacja wyrażeń ................................................................................................... 137
Wyniki wyrażeń ..................................................................................................... 138
Wartości wyrażeń ....................................................................................................... 138
Wyrażenia i operatory ................................................................................................. 138
Trzy rodzaje operatorów ......................................................................................... 139
Priorytet i łączność operatorów ............................................................................... 139
Przeciążanie operatorów ........................................................................................ 141
Operatory rozszerzone ........................................................................................... 144
Wyszukiwanie składowej ............................................................................................. 146
Typy bazowe ......................................................................................................... 147
Składowe funkcyjne .................................................................................................... 147
Wyrażenia podstawowe ............................................................................................... 151
Literały ................................................................................................................. 152
Nazwy proste ........................................................................................................ 152
Wyrażenia nawiasowe ............................................................................................ 152
Dostęp do składowej ............................................................................................. 152
Wyrażenia wywołania ............................................................................................. 153
Dostęp do elementu .............................................................................................. 154
Wyrażenie wartości domyślnej ................................................................................ 157
Metody anonimowe ............................................................................................... 157
Wyrażenia jednoargumentowe ..................................................................................... 158
Wyrażenia rzutowania ................................................................................................. 158
Operatory arytmetyczne .............................................................................................. 158
Operatory przesunięcia ............................................................................................... 159
Operatory relacyjne ..................................................................................................... 159
Operatory logiczne ...................................................................................................... 160
Logiczne operatory warunkowe .................................................................................... 161
Operator null coalescing ............................................................................................. 161
Operatory przypisania ................................................................................................. 162
Spis treści
9
Wyrażenie .................................................................................................................. 163
Wyrażenia stałe .......................................................................................................... 163
Wyrażenia boolowskie ................................................................................................. 165
Podsumowanie .......................................................................................................... 166
Rozdział 10. Instrukcje ............................................................................................................................ 167
Czym są instrukcje? ................................................................................................... 167
Instrukcje C# ............................................................................................................. 169
Punkt końcowy i osiągalność .................................................................................. 170
Punkt końcowy ...................................................................................................... 170
Osiągalność ......................................................................................................... 170
Bloki kodu ................................................................................................................. 172
Listy instrukcji ...................................................................................................... 172
Instrukcje puste ......................................................................................................... 173
Instrukcje etykietowane .............................................................................................. 173
Instrukcje deklaracyjne ............................................................................................... 174
Deklaracje zmiennych lokalnych ............................................................................. 174
Deklaracje stałych lokalnych .................................................................................. 175
Instrukcje wyrażeniowe ............................................................................................... 176
Instrukcje wyboru .................................................................................................. 176
Instrukcje iteracyjne .............................................................................................. 182
Instrukcje skoku ................................................................................................... 184
Instrukcja using .................................................................................................... 187
Instrukcja yield ..................................................................................................... 188
Podsumowanie .......................................................................................................... 189
Rozdział 11. Przestrzenie nazw ...............................................................................................................191
Czym są przestrzenie nazw? ........................................................................................ 191
Organizowanie klas ............................................................................................... 191
Kontrolowanie zasięgu ........................................................................................... 192
Jednostki kompilacji ................................................................................................... 192
Deklaracje przestrzeni nazw ........................................................................................ 193
Dyrektywy użycia synonimu zewnętrznego ..................................................................... 194
Dyrektywy użycia ........................................................................................................ 195
Składowe przestrzeni nazw .................................................................................... 196
Deklaracje typów ................................................................................................... 196
Kwalifikowane składowe synonimów ....................................................................... 197
Podsumowanie .......................................................................................................... 199
Rozdział 12. Klasy .................................................................................................................................... 201
Czym są klasy? .......................................................................................................... 201
Deklaracje klas .......................................................................................................... 201
Modyfikatory klas .................................................................................................. 202
Wskazanie klasy bazowej ....................................................................................... 203
Klasy bazowe ........................................................................................................ 203
Implementacje interfejsów ..................................................................................... 203
Ciało klasy ........................................................................................................... 204
Deklaracje częściowe ............................................................................................ 204
Składowe klasy .......................................................................................................... 204
Dziedziczenie ........................................................................................................ 206
Modyfikator new ................................................................................................... 206
Modyfikatory dostępu ............................................................................................ 206
10
C# 2005. Warsztat programisty
Składowe statyczne i instancji ................................................................................ 206
Stałe .................................................................................................................... 207
Pola .......................................................................................................................... 208
Pola statyczne i instancji ....................................................................................... 209
Pola readonly ........................................................................................................ 209
Metody ...................................................................................................................... 210
Parametry metody ................................................................................................. 211
Metody statyczne i instancji ................................................................................... 212
Metody wirtualne .................................................................................................. 212
Metody przesłaniające ........................................................................................... 213
Metody ostateczne ................................................................................................ 213
Metody abstrakcyjne ............................................................................................. 213
Ciało metody ........................................................................................................ 213
Właściwości ............................................................................................................... 214
Właściwości statyczne i instancji ............................................................................ 215
Akcesory .............................................................................................................. 215
Akcesory wirtualne, ostateczne, przesłaniające i abstrakcyjne .................................. 216
Zdarzenia .................................................................................................................. 216
Zdarzenia jako pola ............................................................................................... 217
Zdarzenia statyczne i instancji ................................................................................ 217
Akcesory wirtualne, ostateczne, przesłaniające i abstrakcyjne .................................. 218
Indeksatory ................................................................................................................ 218
Operatory .................................................................................................................. 220
Operatory jednoargumentowe ................................................................................. 221
Operatory dwuargumentowe ................................................................................... 222
Operatory przekształcenia ...................................................................................... 222
Konstruktory instancji ................................................................................................. 222
Konstruktory statyczne ............................................................................................... 223
Destruktory ................................................................................................................ 224
Podsumowanie .......................................................................................................... 224
Rozdział 13. Struktury ........................................................................................................................... 225
Czym są struktury? ..................................................................................................... 225
Deklaracje struktur ..................................................................................................... 226
Modyfikatory struktury ........................................................................................... 227
Interfejsy struktury ................................................................................................ 227
Ciało struktury ...................................................................................................... 227
Składowe struktury ................................................................................................ 228
Różnice między klasą a strukturą ................................................................................. 228
Semantyka wartości .............................................................................................. 229
Dziedziczenie ........................................................................................................ 229
Przypisania ........................................................................................................... 230
Wartości domyślne ................................................................................................ 230
Opakowywanie i rozpakowywanie ............................................................................ 230
this ...................................................................................................................... 231
Inicjalizatory pól .................................................................................................... 231
Konstruktory ......................................................................................................... 231
Destruktory .......................................................................................................... 231
Konstruktory statyczne .......................................................................................... 232
Kiedy korzystać ze struktur .......................................................................................... 232
Podsumowanie .......................................................................................................... 232
Spis treści
11
Rozdział 14. Tablice ................................................................................................................................. 233
Czym jest tablica? ...................................................................................................... 233
Typy tablicowe ........................................................................................................... 235
Typ System.Array .................................................................................................. 236
Tworzenie tablic ......................................................................................................... 236
Dostęp do elementów tablicy ................................................................................. 237
Składowe tablic .................................................................................................... 237
Kowariancja tablic ................................................................................................. 237
Inicjalizatory tablic ................................................................................................. 238
Podsumowanie .......................................................................................................... 240
Rozdział 15. Interfejsy ............................................................................................................................. 241
Czym jest interfejs? .................................................................................................... 241
Definiowanie interfejsu ............................................................................................... 242
Deklaracje interfejsów ................................................................................................ 242
Modyfikatory ......................................................................................................... 243
Jawne interfejsy bazowe ........................................................................................ 243
Ciało interfejsu ..................................................................................................... 244
Składowe interfejsu ............................................................................................... 244
Metody interfejsu .................................................................................................. 244
Właściwości interfejsu ........................................................................................... 244
Zdarzenia interfejsu ............................................................................................... 245
Podsumowanie .......................................................................................................... 245
Rozdział 16. Typy wyliczeniowe ............................................................................................................. 247
Deklaracje typów wyliczeniowych ................................................................................. 248
Modyfikatory typów wyliczeniowych .............................................................................. 249
Składowe typów wyliczeniowych ................................................................................... 250
Przestroga przed referencjami cyklicznymi .................................................................... 251
System.Enum ............................................................................................................ 251
Wartości i operacje typów wyliczeniowych ................................................................ 252
Podsumowanie .......................................................................................................... 252
Rozdział 17. Delegacje ............................................................................................................................ 253
Delegacje w działaniu ................................................................................................. 253
Deklaracje delegacji ................................................................................................... 254
Modyfikatory ......................................................................................................... 254
Deklarowanie delegacji .......................................................................................... 255
Lista wywoławcza .................................................................................................. 255
Tworzenie instancji delegacji .................................................................................. 256
Podsumowanie .......................................................................................................... 257
Rozdział 18. Wyjątki ................................................................................................................................ 259
Zgłaszanie wyjątków ................................................................................................... 259
System.Exception ....................................................................................................... 260
Typowe klasy wyjątków ............................................................................................... 260
Obsługa wyjątków ....................................................................................................... 261
Co się dzieje, gdy klauzula catch nie zostaje odnaleziona? ....................................... 261
Podsumowanie .......................................................................................................... 262
12
C# 2005. Warsztat programisty
Rozdział 19. Atrybuty .............................................................................................................................. 263
Wprowadzenie do atrybutów ........................................................................................ 263
Klasy atrybutów .......................................................................................................... 264
Parametry pozycyjne i nazwane .............................................................................. 264
Użycie atrybutów ................................................................................................... 264
Typy parametrów atrybutu ...................................................................................... 265
Specyfikacja atrybutów ............................................................................................... 266
Instancje atrybutów .................................................................................................... 269
Kompilacja atrybutów ............................................................................................ 269
Odczytywanie instancji atrybutu podczas wykonywania programu ............................... 269
Atrybuty zastrzeżone ................................................................................................... 270
Atrybut Conditional ................................................................................................ 270
Podsumowanie .......................................................................................................... 272
Rozdział 20. Typy generyczne ............................................................................................................... 275
Typy generyczne w C# i szablony w C++ ....................................................................... 275
Zalety typów generycznych ..................................................................................... 276
Deklaracje klas generycznych ...................................................................................... 276
Parametry typu ..................................................................................................... 277
Różnice parametrów typu ....................................................................................... 278
Typ instancji ......................................................................................................... 279
Składowe klas generycznych .................................................................................. 279
Pola statyczne w klasach generycznych ................................................................... 280
Konstruktory statyczne w klasach generycznych ....................................................... 280
Dostęp do składowych chronionych ........................................................................ 281
Przeciążanie w klasach generycznych ...................................................................... 281
Operatory w klasach generycznych .......................................................................... 281
Deklaracje struktur generycznych ................................................................................. 282
Deklaracje interfejsów generycznych ............................................................................ 282
Jawne implementacje składowych interfejsu ................................................................. 283
Deklaracje delegacji generycznych ............................................................................... 283
Typy konstruowane ..................................................................................................... 283
Argumenty typu ..................................................................................................... 284
Typy otwarte i zamknięte ....................................................................................... 284
Składowe typów konstruowanych ............................................................................ 284
Stosowanie dyrektyw użycia synonimów .................................................................. 285
Metody generyczne ............................................................................................... 285
Gdzie nie używa się typów generycznych ....................................................................... 287
Ograniczenia .............................................................................................................. 288
Podsumowanie .......................................................................................................... 291
Rozdział 21. Iteratory ............................................................................................................................. 293
Blok iteratora ............................................................................................................. 294
Bloki iteratora i błędy czasu kompilacji ................................................................... 295
Interfejsy enumeratora .......................................................................................... 295
Interfejsy wyliczeniowe .......................................................................................... 295
Typ yield ............................................................................................................... 296
This ..................................................................................................................... 296
Obiekty enumeratora .................................................................................................. 296
Metoda MoveNext ................................................................................................. 297
Przerwanie wykonywania kodu ................................................................................ 298
Spis treści
13
Właściwość Current ............................................................................................... 298
Metoda Dispose ................................................................................................... 299
Obiekty przeliczalne .................................................................................................... 300
Metoda GetEnumerator ......................................................................................... 300
Podsumowanie .......................................................................................................... 301
Rozdział 22. Kod nienadzorowany ......................................................................................................... 303
Czym jest kod nienadzorowany? .................................................................................. 303
Zalety i wady kodu nienadzorowanego .......................................................................... 304
Zalety kodu nienadzorowanego ............................................................................... 304
Wady kodu nienadzorowanego ............................................................................... 304
Konteksty kodu nienadzorowanego .............................................................................. 305
Podstawowe informacje o wskaźnikach ........................................................................ 306
Wskaźniki void ...................................................................................................... 307
Operatory wskaźnikowe ......................................................................................... 307
Kod nienadzorowany w działaniu .................................................................................. 308
Stosowanie modyfikatora fixed ............................................................................... 309
Operator sizeof .......................................................................................................... 310
Użycie słowa kluczowego stackalloc ............................................................................. 311
Kompilowanie kodu nienadzorowanego ........................................................................ 312
Podsumowanie .......................................................................................................... 312
Dodatek A Gramatyka języka C# ........................................................................................................... 313
Dodatek B Konwencje nazewnicze ........................................................................................................ 349
Dodatek C Biblioteka standardowa ....................................................................................................... 357
Dodatek D Przenaszalność ..................................................................................................................... 371
Dodatek E Komentarze dokumentacyjne XML ...................................................................................... 375
Skorowidz ............................................................................................................................................... 379
Struktura języka C#
Aby pisać dobre programy w C#, należy w pełni zrozumieć strukturę tego języka. W roz-
dziale tym omówimy językową, czyli leksykalną strukturę programów napisanych w C#.
Oto kolejność, w jakiej będziemy przedstawiać tematy:
(cid:81) Programy C#
(cid:81) Gramatyka
(cid:81) Zakończenia wierszy
(cid:81) Komentarze
(cid:81) Białe znaki
(cid:81) Tokeny
(cid:81) Słowa kluczowe
(cid:81) Dyrektywy
Programy C#
Każdy program C# tworzony jest z jednego bądź wielu plików źródłowych. Te pliki, zwa-
ne też jednostkami kompilacji, mogą być odrębnymi plikami tekstowymi lub też plikami
zawartymi wewnątrz zintegrowanego środowiska IDE (ang. Integrated Development Envi-
ronment), jak Visual Studio.
Jednostki kompilacyjne zawierają uporządkowane sekwencje znaków Unicode (okrężne
określenie tekstu) i aby zapewnić maksymalną przenaszalność, wszystkie pliki źródłowe
powinny być zakodowane w standardzie UTF-8. Korzystając z prostego edytora tekstowe-
go (jakim jest Notatnik) lub środowiska programistycznego specyficznego dla C#, możemy
mieć pewność, że kod otrzyma poprawny format.
58
C# 2005. Warsztat programisty
Jednostka kompilacji składa się z:
(cid:81) Zera lub więcej dyrektyw using
(cid:81) Zera lub więcej atrybutów globalnych
(cid:81) Zera lub więcej deklaracji składowych przestrzeni nazw
Atrybut jest obiektem reprezentującym dane, które zamierzamy powiązać z elementem pro-
gramu, podczas gdy element, z którym wiążemy ten atrybut, nazywamy adresatem atrybutu.
Wszystkie elementy jednostki kompilacji pełnią określoną rolę:
(cid:81) Dyrektywy using. Umożliwiają użycie przestrzeni nazw (które wykorzystuje się
do logicznego rozmieszczania klas, struktur, interfejsów, wyliczeń i delegacji)
oraz typów zdefiniowanych w innych przestrzeniach nazw. To wpływa na atrybuty
i deklaracje składowych przestrzeni nazw jednostki kompilacji. Dyrektywa using
zawarta w jednej jednostce kompilacji nie ma wpływu na pozostałe jednostki.
(cid:81) Atrybuty globalne. Umożliwiają zdefiniowanie atrybutów dla całego projektu.
Asemblacje i moduły pełnią rolę fizycznych pojemników na typy (lub jako miejsce
dla kodu; nieco później powiemy o tym bardziej szczegółowo). Asemblacja może
składać się z kilku odrębnych modułów lub, w przypadku prostszych projektów,
z pojedynczego.
(cid:81) Deklaracje składowych przestrzeni nazw. Tworzą jedną deklarację przestrzeni
zwanej globalną przestrzenią nazw.
Gdy program C# jest kompilowany, wówczas wszystkie jednostki kompilacji przetwarzane
są razem, co oznacza, że są powiązane zależnościami (jeżeli program składa się z więcej niż
jednej jednostki kompilacji, to kompilator, aby być w stanie poprawnie skompilować kod
źródłowy, musi mieć dostęp do wszystkich jednostek).
Kompilacja programu C# przebiega w trzech etapach:
(cid:81) Transformacja. Ten etap polega na przekształceniu kodu na zbiór znaków
Unicode (ze standardu, w którym kod zawarty w jednostkach kompilacji został
zapisany i zakodowany).
(cid:81) Analiza leksykalna. Jest to proces przekształcania znaków Unicode w strumień
tokenów.
(cid:81) Analiza syntaktyczna. Na tym etapie, poprzedzającym konwersję na postać
wykonywalną, strumieniowi tokenów nadawany jest format Microsoft
Intermediate Language (MSIL).
W C# wyróżnia się kilka rodzajów tokenów:
(cid:81) Identyfikatory
(cid:81) Słowa kluczowe
(cid:81) Literały
(cid:81) Operatory
(cid:81) Separatory
Rozdział 4. (cid:81) Struktura języka C#
59
Białe znaki i komentarze nie są tokenami.
Kompilator powinien być w stanie przekształcić jednostki kompilacji zapisane w formacie
Unicode lub pliki źródłowe zakodowane w standardzie UTF-8 na postać sekwencji znaków
Unicode. Może się zdarzyć, że kompilator będzie zdolny skompilować jednostki kompilacji
zakodowane przy użyciu innych schematów (na przykład UTF-16 czy UTF-32), ale nie na-
leży na to liczyć.
Gramatyka
W języku C# stosuje się gramatykę dwojakiego rodzaju:
(cid:81) Gramatykę leksykalną. Określa sposób, w jaki znaki Unicode formują:
(cid:81) Zakończenia wierszy
(cid:81) Białe znaki
(cid:81) Komentarze
(cid:81) Tokeny
(cid:81) Dyrektywy preprocesora
(cid:81) Gramatykę syntaktyczną. Ten typ gramatyki określa schemat łączenia tokenów,
które powstały na podstawie reguł gramatyki leksykalnej, w programy C#.
Dwuznaczności gramatyczne
W każdym języku programowania można napotkać pewne dwuznaczności. Dla przykładu
rozważmy takie oto wyrażenie:
F(X Y, Z (5));
To proste wyrażenie można zinterpretować na dwa sposoby:
1. Jako wywołanie F z dwoma argumentami: X Y i Z (5)
2. Jako wywołanie F z jednym argumentem, którym jest wywołanie metody
generycznej X mającej dwa argumenty typu (czyli argumenty, które po prostu
są typami) oraz jeden argument zwykły.
Na szczęście istnieją pewne reguły, według których postępuje kompilator, rozstrzygając
takie niejednoznaczności. Napotykając kod, jak w powyższym przykładzie (gdzie mamy
sekwencję tokenów tworzących listę argumentów typu), kompilator zwraca uwagę przede
wszystkim na token znajdujący się bezpośrednio za znakiem zamykającym . Jeśli jest to
jeden z następujących tokenów:
(cid:81) (
(cid:81) )
60
C# 2005. Warsztat programisty
(cid:81) [
(cid:81) :
(cid:81) ;
(cid:81) ,
(cid:81) .
(cid:81) ?
(cid:81) ==
(cid:81) !=
lista argumentów typu definiuje część prostej nazwy, dostęp do składowej lub dostęp do
wskaźnika poprzedzającego i wszystkie dalsze opcje są odrzucane.
Jeśli następnym tokenem jest token, którego nie ma na powyższym wykazie, to lista argu-
mentów typu nie definiuje części nazwy, dostępu do składowej ani dostępu do wskaźnika
poprzedzającego.
Powyższa reguła nie odnosi się do parsowania listy argumentów typu w przestrzeni
nazw czy nazwach typów.
Wracając do naszego wcześniejszego, dość niejednoznacznego przykładu:
F(X Y, Z (5));
Zgodnie z regułami, które wymieniliśmy wcześniej, zapis ten zostanie zinterpretowany jako
wywołanie F z jednym argumentem, który stanowi wywołanie metody generycznej X, o dwóch
argumentach typów i jednym argumencie zwykłym.
Oto dwa następne przykłady wyrażeń, które zostaną zinterpretowane jako wywołanie F z dwo-
ma argumentami:
F(X Y, Z 5);
F((X Y, Z 5);
Omówmy inne wyrażenie:
X = F Y + Z;
Wyrażenie to z perspektywy użytych operatorów zostanie zinterpretowane jako:
(cid:81) Operator „mniejszy niż”
(cid:81) Operator „większy niż”
(cid:81) Unarny operator +
Inna forma zapisu powyższego wyrażenia wygląda tak:
X = (F Y) (+Z);
Rozdział 4. (cid:81) Struktura języka C#
61
Analiza leksykalna
Każdy plik źródłowy programu C# musi być zgodny z następującym gramatycznym wzor-
cem leksykalnym:
wejście:
wejście-sekcjaopcj
wejście-sekcja:
wejście-sekcja-część
wejście-sekcja wejście-sekcja-część
wejście-sekcja-część:
elementy wejścioweopcj nowy-wiersz
dyrektywa-pp
elementy-wejściowe
element-wejściowy
elementy-wejściowe wejście-element
wejście-element:
biały znak
komentarz
token
Leksykalną strukturę jednostki kompilacji C# tworzy pięć elementów podstawowych. Są to:
(cid:81) Zakończenia wierszy
(cid:81) Białe znaki
(cid:81) Komentarze
(cid:81) Tokeny
(cid:81) Dyrektywy preprocesora
Spośród tych elementów jedynie tokeny mają znaczenie z punktu widzenia gramatyki syn-
taktycznej dowolnego programu C# (z wyjątkiem sytuacji, gdy token występuje łącznie
z innym tokenem, tworząc z nim operator). Kiedy kompilator dokonuje leksykalnego prze-
twarzania jednostki kompilacji, to traktuje plik jako serię tokenów, które stanowią wejście
dla późniejszego przetwarzania syntaktycznego. Zakończenia wierszy, białe znaki i komen-
tarze oddzielające token y są elementami wyłącznie leksykalnymi i nie mają żadnego wpły-
wu na składnię programu C#. Podobnie dyrektywy preprocesora służą tylko do omijania
fragmentów kodu w pliku źródłowym i jeśli chodzi o składnię, także nie mają znaczenia.
Zawsze kiedy w wyniku przetwarzania leksykalnego możliwe jest uzyskanie kilku wyni-
ków, procesor leksykalny pobiera najdłuższy poprawny element leksykalny. Na przykład,
jeśli kompilator napotyka następującą sekwencję znaków:
//
przetwarza je i interpretuje jako początek wiersza komentarza, a nie dwa wystąpienia toke-
na / (w takim przypadku nie oznaczałyby one początku komentarza). Podobnie dzieje się,
kiedy napotkana zostaje sekwencja:
!=
62
C# 2005. Warsztat programisty
Jest ona interpretowana jako operator porównania. Mając to na uwadze, łatwo zauważyć,
jak proste błędy typograficzne w kodzie źródłowym mogą doprowadzić do nieprawidłowe-
go działania programu. Zazwyczaj jednak powodują one błąd kompilacji.
Zakończenia wierszy
Zakończenie wiersza służy do dzielenia sekwencji znaków w pliku źródłowym C# na osob-
ne wiersze.
Istnieje szereg różnych zakończeń wierszy:
(cid:81) Znak powrotu karetki: U+000D
(cid:81) Przesunięcie o wiersz: U+000A
(cid:81) Powrót karetki, a po nim przesunięcie o wiersz: U+000D U+000A
(cid:81) Przejście do następnego wiersza: U+2085
(cid:81) Separator wiersza: U+2028
(cid:81) Separator akapitu: U+2029
Aby zachować wysoki poziom kompatybilności z różnymi narzędziami do edycji kodu źró-
dłowego, które umieszczają znaki zakończenia pliku, i zapewnić, że pliki źródłowe C# będą
odczytywane jako sekwencja poprawnie zakończonych wierszy, są one poddawane dwóm
przekształceniom:
(cid:81) Jeśli ostatnim znakiem w źródłowym pliku C# jest Ctrl+Z (U+001A), to znak
ten zostaje usunięty.
(cid:81) Jeśli źródłowy plik C# nie jest pusty i jeśli jego ostatnim znakiem nie jest znak
powrotu karetki (U+000D), wysunięcia wiersza (U+000A), przejścia do następnego
wiersza (U+2085), separatora wiersza (U+2028) lub separatora akapitu (U+2029),
to na końcu pliku umieszczony zostaje znak powrotu karetki (U+000D).
Komentarze
C# obsługuje dwa rodzaje komentarzy w plikach źródłowych:
(cid:81) Komentarze wyodrębnione
(cid:81) Komentarze jednowierszowe
W poniższych podpunktach omówimy te rodzaje komentarzy bardziej szczegółowo.
Komentarze wyodrębnione
Komentarz wyodrębniony zawsze rozpoczyna się znakami /*, a kończy znakami */.
Komentarz taki może zajmować fragment wiersza:
Rozdział 4. (cid:81) Struktura języka C#
63
/* Program testowy Hello World
*/ class Test
{
static void Main() {
System.Console.WriteLine( Hello, World! );
}
}
Jeden wiersz:
/* Program testowy Hello World */
class Test
{
static void Main() {
System.Console.WriteLine( Hello, World! );
}
}
Lub kilka wierszy:
/*
Program testowy Hello World
*/
class Test
{
static void Main() {
System.Console.WriteLine( Hello, World! );
}
}
Komentarze wyodrębnione mogą być umieszczane w dowolnych punktach kodu, o ile tylko
zajmują wydzielony wiersz. Na przykład komentarz przedstawiony poniżej jest wpisany
poprawnie:
/*
Program testowy Hello World
*/
class Test
{
static void Main() {
System.Console.WriteLine( Hello, World! );
}
}
W tym przypadku także:
class Test
{
/*
Program testowy Hello World
*/
static void Main() {
System.Console.WriteLine( Hello, World! );
}
}
64
C# 2005. Warsztat programisty
Podobnie jak w tym:
/*
Program testowy Hello World
*/
class Test
{
static void Main() {
/*
Łańcuch znakowy wyświetlany na ekranie
*/
System.Console.WriteLine( Hello, World! );
}
}
To zaś przykład komentarza zapisanego niepoprawnie:
class Test
{
static void Main() {
System.Console. /*
Program testowy Hello World
*/
WriteLine( Hello, World! );
}
}
Komentarze jednowierszowe
Komentarze jednowierszowe to jak sama nazwa wskazuje, komentarze zawarte w jednym
wierszu. Zaczynają się od znaków // i biegną do końca wiersza:
class Test
{
static void Main() {
System.Console.WriteLine( Hello, World! ); // wyświetla Hello, World!
}
}
Wewnątrz kodu można umieścić tyle komentarzy jednowierszowych, ile jest konieczne:
// wyświetla Hello, World!
class Test
{
static void Main(){
System.Console.WriteLine( Hello, World! ); // wyświetla Hello, World!
}
}
Nie wolno jednak umieszczać komentarzy jednowierszowych wewnątrz wyrażeń. Oto przy-
kład niepoprawnego wpisania komentarza:
// wyświetla Hello, World!
class Test
{
Rozdział 4. (cid:81) Struktura języka C#
65
static void Main(){
System.Console.WriteLine // wyświetla Hello, World! ( Hello, World! );
}
}
Ten kod także jest zapisany niewłaściwie:
class Test
{
static void Main() {
System.Console.WriteLine( Hello, World! );
}
}
Zagnieżdżanie komentarzy
Nie można zagnieżdżać komentarzy. Trzeba tego unikać w imię czytelności kodu:
// /*
Pobierz darmowy fragment (pdf)