Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00116 007552 11068915 na godz. na dobę w sumie
C# 2005. Warsztat programisty - książka
C# 2005. Warsztat programisty - książka
Autor: , Liczba stron: 392
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1065-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Wyjątkowy podręcznik języka C#

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.

Poznaj nowoczesne metody tworzenia aplikacji.

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

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)

Gdzie kupić całą publikację:

C# 2005. Warsztat programisty
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


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