Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00542 008662 10441493 na godz. na dobę w sumie
Visual C# .NET. Encyklopedia - książka
Visual C# .NET. Encyklopedia - książka
Autor: Liczba stron: 392
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-819-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).
Książka zawiera oficjalną dokumentację języka Visual C# .NET. C# jest jednym z podstawowych języków dostępnych na platformie .NET, łączącym w sobie największe zalety Javy i C++. 'Visual C#. NET. Encyklopedia' to doskonałe uzupełnienie dokumentacji dostępnej w formie elektronicznej, niezbędne dla każdego programisty korzystającego z C#. Poza szczegółowym opisem języka, a także kompilatora C#, zawiera ona wiele przykładów gotowych do wykorzystania w konkretnych aplikacjach. Jest to książka, do której będziesz często powracał.

Omówiono:

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Visual C# .NET. Encyklopedia Autor: Microsoft Corporation T³umaczenie: Tomasz Miszkiel ISBN: 83-7197-819-7 Tytu³ orygina³u: Microsoft Visual C# .Net Language Reference Format: B5, stron: 390 Ksi¹¿ka zawiera oficjaln¹ dokumentacjê jêzyka Visual C# .NET. C# jest jednym z podstawowych jêzyków dostêpnych na platformie .NET, ³¹cz¹cym w sobie najwiêksze zalety Javy i C++. „Visual C#. NET. Encyklopedia” to doskona³e uzupe³nienie dokumentacji dostêpnej w formie elektronicznej, niezbêdne dla ka¿dego programisty korzystaj¹cego z C#. Poza szczegó³owym opisem jêzyka, a tak¿e kompilatora C#, zawiera ona wiele przyk³adów gotowych do wykorzystania w konkretnych aplikacjach. Jest to ksi¹¿ka, do której bêdziesz czêsto powraca³. Omówiono: • Typy • Modyfikatory • Polecenia • Przestrzenie nazw • Operatory • Przekszta³cenia • Dyrektywy preprocesora • Atrybuty • Tworzenie dokumentacji w XML Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Rozdział 1. Wprowadzenie do języka C# 9 Programowanie w C#...................................................e...................................................e...... 9 Ogólna struktura programu napisanego w języku C#...................................................e........... 10 Rozdział 2. Słowa kluczowe języka C# 13 Słowa kluczowe...................................................e...................................................e............ 13 Modyfikatory ...................................................e...................................................e............... 14 Modyfikatory dostępu...................................................e................................................. 15 abstract ...................................................e...................................................e.................. 25 const ...................................................e...................................................e...................... 27 event...................................................e...................................................e...................... 29 extern...................................................e...................................................e..................... 35 override...................................................e...................................................e.................. 36 readonly ...................................................e...................................................e.................38 sealed...................................................e...................................................e..................... 40 static .............................................e...................................................e............................ 40 unsafe ...................................................e...................................................e.................... 43 virtual ...................................................e...................................................e.................... 44 volatile ...................................................e...................................................e................... 46 Przekształcenia ...................................................e...................................................e............. 47 explicit ...................................................e...................................................e................... 47 implicit..................................................e...................................................e.................... 49 operator...........................................e...................................................e.......................... 50 Słowa kluczowe dostępu ...................................................e.................................................. 52 base ...................................................e...................................................e....................... 52 this...............................................e...................................................e............................. 54 Słowa kluczowe instrukcji ...................................................e................................................ 56 Instrukcje wyboru ...................................................e...................................................e... 56 Instrukcje iteracyjne ...................................................e...................................................e 62 Instrukcje skoku...................................................e...................................................e...... 74 Instrukcje obsługi wyjątków...................................................e........................................ 80 Instrukcje checked i unchecked ...................................................e................................... 87 Instrukcja fixed ...................................................e...................................................e....... 93 Instrukcja lock ...................................................e...................................................e........ 95 4 Spis treści Słowa kluczowe literałów ...................................................e................................................. 97 null ...................................................e...................................................e........................ 97 true ...................................................e...................................................e........................ 97 false ...................................................e...................................................e....................... 98 Słowa kluczowe operatorów ...................................................e............................................. 99 as.................................................e...................................................e........................... 100 is ...................................................e...................................................e......................... 101 new................................................e...................................................e.........................103 sizeof ...................................................e...................................................e...................107 typeof ...................................................e...................................................e.................. 108 true ...................................................e...................................................e...................... 110 false ...................................................e...................................................e..................... 111 stackalloc ...................................................e...................................................e............. 112 Słowa kluczowe parametrów ...................................................e.......................................... 113 params ...................................................e...................................................e................. 114 ref................................................e...................................................e........................... 115 out ...................................................e...................................................e....................... 116 Słowa kluczowe przestrzeni nazw ...................................................e................................... 117 namespace...................................................e...................................................e............ 117 using ...................................................e...................................................e....................119 Słowa kluczowe typów...................................................e...................................................e 122 Typy bezpośrednie ...................................................e...................................................e 123 Opakowywanie i rozpakowywanie...................................................e............................. 149 Typy referencyjne ...................................................e...................................................e. 152 Tabele typów...................................................e...................................................e........ 163 Rozdział 3. Język C# 171 Operatory..........................................e...................................................e............................ 171 Operatory przeciążalne ...................................................e............................................. 172 Operator [ ] ...................................................e...................................................e.......... 173 Operator () ...................................................e...................................................e........... 174 Operator ....................................................e...................................................e............. 175 Operator +...................................................e...................................................e............ 176 Operator -...................................................e...................................................e............. 177 Operator * ...................................................e...................................................e............ 178 Operator /...................................................e...................................................e............. 179 Operator ...................................................e...................................................e........... 180 Operator ...................................................e...................................................e........... 180 Operator | ...................................................e...................................................e............. 181 Operator ^ ...................................................e...................................................e............ 182 Operator !...................................................e...................................................e............. 183 Operator ~...................................................e...................................................e............ 184 Operator =...................................................e...................................................e............ 184 Operator ...................................................e...................................................e............ 185 Operator ...................................................e...................................................e............ 186 Operator ?: ...................................................e...................................................e........... 187 Operator ++...................................................e...................................................e.......... 188 Operator -- ...................................................e...................................................e........... 189 Operator ...................................................e...................................................e........ 190 Operator ||...................................................e...................................................e............. 191 Spis treści 5 Operator ...................................................e...................................................e.......... 193 Operator ...................................................e...................................................e.......... 194 Operator ==...................................................e...................................................e.......... 195 Operator !=..................................................e...................................................e............ 196 Operator =...................................................e...................................................e.......... 197 Operator =...................................................e...................................................e.......... 198 Operator +=...................................................e...................................................e.......... 199 Operator -=..................................................e...................................................e............ 200 Operator *= ...................................................e...................................................e.......... 200 Operator /=...................................................e...................................................e........... 201 Operator =...................................................e...................................................e......... 202 Operator = ...................................................e...................................................e......... 203 Operator |= ...................................................e...................................................e........... 204 Operator ^= ...................................................e...................................................e.......... 205 Operator =...................................................e...................................................e........ 206 Operator =...................................................e...................................................e........ 207 Operator - ..................................................e...................................................e............ 208 Atrybuty ...................................................e...................................................e.................... 209 Wprowadzenie do atrybutów...................................................e..................................... 209 AttributeUsage...................................................e...................................................e...... 216 Conditional...................................................e...................................................e........... 217 Obsolete ...................................................e...................................................e............... 219 Przewodnik po atrybutach...................................................e......................................... 220 Deklaracje...................................................e...................................................e.................. 226 Składniki...................................................e...................................................e.................... 229 Składniki przestrzeni nazw...................................................e........................................ 229 Składniki struktur...................................................e...................................................e.. 230 Składniki klas ...................................................e...................................................e....... 230 Inne składniki ...................................................e...................................................e....... 231 Dostęp do składników...................................................e............................................... 231 Dostępność deklarowana...................................................e........................................... 231 Dziedziny dostępności ...................................................e.............................................. 232 Dostęp chroniony do składników ...................................................e............................... 235 Ograniczenia dostępności...................................................e.......................................... 236 Dyrektywy preprocesora ...................................................e................................................ 237 #if...................................................e...................................................e........................ 238 #else ...................................................e...................................................e....................239 #elif ...................................................e...................................................e..................... 239 #endif..............................................e...................................................e........................240 #define ...................................................e...................................................e................. 240 #undef...................................................e...................................................e.................. 241 #warning ...................................................e...................................................e.............. 242 #error...................................................e...................................................e...................242 #line...................................................e...................................................e..................... 243 #region...................................................e...................................................e................. 244 #endregion...................................................e...................................................e............ 244 Tablice..............................................e...................................................e............................ 245 Tablice jednowymiarowe ...................................................e.......................................... 245 Tablice wielowymiarowe ...................................................e.......................................... 247 Tablice nieregularne ...................................................e................................................. 248 6 Spis treści Przekazywanie tablic za pomocą ref i out ...................................................e................... 250 Przewodnik po tablicach ...................................................e........................................... 252 Konstruktory i destruktory...................................................e.............................................. 257 Konstruktory klas...................................................e...................................................e.. 257 Konstruktory struktur ...................................................e............................................... 264 Destruktory ...................................................e...................................................e.......... 265 Indeksatory ...................................................e...................................................e................ 268 Deklaracja indeksatora...................................................e.............................................. 268 Porównanie indeksatorów z właściwościami ...................................................e............... 271 Indeksatory interfejsu ...................................................e............................................... 272 Przewodnik po indeksatorach ...................................................e.................................... 275 Właściwości ...................................................e...................................................e............... 278 Deklaracja właściwości...................................................e............................................. 279 Akcesory ...................................................e...................................................e.............. 281 Właściwości interfejsów ...................................................e........................................... 287 Przewodnik po właściwościach...................................................e.................................. 289 Sygnatury i przeciążanie...................................................e................................................. 295 Zasięg...................................................e...................................................e........................ 296 Ogólne reguły rządzące zasięgami ...................................................e............................. 296 Ukrywanie nazw ...................................................e...................................................e... 299 Ukrywanie przez zagnieżdżenie...................................................e................................. 299 Ukrywanie przez dziedziczenie...................................................e.................................. 300 Przekazywanie parametrów ...................................................e............................................ 302 Metoda Main...................................................e...................................................e..............307 Wartości zwracane ...................................................e...................................................e 308 Argumenty z wiersza poleceń ...................................................e.................................... 309 Przewodnik po metodach warunkowych ...................................................e.......................... 310 Przewodnik po delegacjach...................................................e............................................. 313 Przewodnik po zdarzeniach ...................................................e............................................ 319 Dokumentacja XML ...................................................e...................................................e... 326 Znaczniki w komentarzach...................................................e........................................ 326 Przetwarzanie pliku XML ...................................................e......................................... 339 Dodatek A Opcje kompilatora języka C# 343 Budowanie programu z wiersza poleceń...................................................e........................... 343 Opcje kompilatora C# — wykaz z podziałem na kategorie...................................................e. 345 Opcje kompilatora C# — wykaz alfabetyczny ...................................................e.................. 347 @ (określenie pliku odpowiedzi) ...................................................e..................................... 349 /addmodule (import metadanych) ...................................................e.................................... 350 /baseaddress (określenie adresu bazowego biblioteki DLL)...................................................e 350 /bugreport (tworzenie informacji o wystąpieniu problemu) ...................................................e 351 /checked (kontrola przepełnienia arytmetycznego) ...................................................e............ 352 /codepage (określenie strony kodowej dla plików z kodem źródłowym)................................. 353 /debug (generowanie informacji diagnostycznych)...................................................e............ 353 /define (definicja preprocesora) ...................................................e....................................... 354 /doc (przetwarzanie komentarzy dokumentacji) ...................................................e................ 355 /filealign (określenie rozmiaru sekcji) ...................................................e.............................. 356 /fullpaths (określenie pełnej ścieżki dostępu do pliku) ...................................................e....... 357 /help, /? (wyświetlenie informacji dotyczących opcji kompilatora) ........................................ 357 /incremental (umożliwienie kompilacji przyrostowej) ...................................................e....... 358 Spis treści 7 /lib (określenie lokalizacji odwołania do złożeń)...................................................e............... 359 /linkresource (odnośnik do zasobu .NET Framework)...................................................e....... 360 /main (określenie lokalizacji metody Main) ...................................................e...................... 361 /noconfig (ignorowanie pliku csc.rsp) ...................................................e.............................. 362 /nologo (usunięcie informacji o kompilatorze) ...................................................e..................... 363 /nostdlib (pominięcie biblioteki standardowej)...................................................e.................. 363 /nowarn (pominięcie określonych ostrzeżeń)...................................................e...................... 364 /optimize (włączenie lub wyłączenie optymalizacji)...................................................e.......... 364 /out (określenie nazwy pliku wyjściowego) ...................................................e...................... 365 /recurse (przeszukanie podkatalogów w celu odnalezienia plików źródłowych) ...................... 366 /reference (import metadanych)...................................................e....................................... 367 /resource (umieszczenie zasobu w pliku wyjściowym) ...................................................e...... 368 /target (określenie formatu pliku wyjściowego) ...................................................e................ 369 /unsafe (uaktywnienie trybu nienadzorowanego)...................................................e............... 372 /utf8output (wyświetlenie komunikatów kompilatora w kodzie UTF-8) ................................. 373 /warn (określenie poziomu ostrzeżeń) ...................................................e.............................. 373 /warnaserror (traktowanie ostrzeżeń na równi z błędami)...................................................e... 374 /win32icon (importowanie pliku .ico) ...................................................e.............................. 375 /win32res (importowanie pliku zasobów Win32) ...................................................e.............. 376 Skorowidz 377 RWDNKEENCUU/CKP NCUU ] RWDNKEUVCVKEXQKF/CKP ] 6YQTGPKGQDKGMVÎY  ORNQ[GG PGY ORNQ[GG ,QJP/6TCKPGTLVTC/KPGT  9[ħYKGVNGPKGY[PKMÎY  RTKPV ORNQ[GG  _ _ Wynik 0CYKUMQ,QJP/6TCKPGT #NKCULVTCKPGT 2QFCVMKđ Dodatkowe przykłady wykorzystania słowa kluczowego this znajdują się w punktach poświęconych słowom kluczowym class (strona 153) i struct (strona 142). Słowa kluczowe instrukcji Instrukcje są wykonywane w trakcie działania programu. Poza nielicznymi wyjątkami opisanymi w niniejszej książce, instrukcje są wykonywane kolejno, zgodnie z ich zapi- sem w pliku programu. Kategoria Instrukcje wyboru Instrukcje iteracyjne Instrukcje skoków Instrukcje obsługi wyjątków Instrukcje EJGEMGF i WPEJGEMGF Instrukcja HKZGF Instrukcja NQEM Słowa kluczowe C# KH, GNUG, UYKVEJ, ECUG FQ, HQT, HQTGCEJ, KP, YJKNG DTGCM, EQPVKPWG, FGHCWNV, IQVQ, TGVWTP VJTQY, VT[-ECVEJ, VT[HKPCNN[ EJGEMGF, WPEJGEMGF HKZGF NQEM Instrukcje wyboru Instrukcja wyboru sprawia, że program jest wykonywany w określonym miejscu, które zależy od wartości wyrażenia warunkowego (true lub false). W instrukcjach wyboru korzystamy z następujących słów kluczowych:    KH GNUG UYKVEJ 14 Rozdział 2. Słowa kluczowe języka C#  ECUG if-else Instrukcja if jest instrukcją kontroli przebiegu programu. Za pomocą tej instrukcji wy- konywany jest określony fragment kodu, jeżeli wyrażenie warunkowe przyjmie wartość logiczną true. KH Y[TCľGPKG KPUVTWMELC =GNUG KPUVTWMELC? gdzie: wyrażenie Wyrażenie, które może być niejawnie przekształcone w typ bool lub inny typ zawierający przeciążone operatory true i false. instrukcja1 Instrukcja wewnętrzna (lub zestaw instrukcji), która zostanie wykonana, jeśli wyrażenie ma wartość true. instrukcja2 Instrukcja wewnętrzna (lub zestaw instrukcji), która zostanie wykonana, jeśli wyrażenie ma wartość false. Uwagi Jeśli wyrażenie przyjmie wartość true, to wykonywana jest instrukcja1.Jeśli istnieje opcjonalna sekcja else, a wyrażenie przyjmuje wartość false, to wykonywana jest in- strukcja2. Po wykonaniu instrukcji warunkowej if następuje przejście do następnej in- strukcji programu. W instrukcji warunkowej if można umieścić bloki kodu, które są wykonywane w zależ- ności od wartości wyrażenia warunkowego (aby instrukcja if została wykonana, wyra- żenie warunkowe musi przyjąć wartość true lub false). W blokach można umieścić wiele instrukcji, których wykonanie zależy od wartości wyrażenia warunkowego. Wewnątrz wyrażenia warunkowego można umieścić dowolne instrukcje. Wyraże- niem może być kolejna zagnieżdżona instrukcja warunkowa if. Należy przy tym pa- miętać, że sekcja else odnosi się do ostatniej (najbardziej zagnieżdżonej) instrukcji if, na przykład: KH Z  KH [   QPUQNG9TKVG +PUVTWMELCA  GNUG  QPUQNG9TKVG +PUVTWMELCA  Słowa kluczowe instrukcji 15 Jeżeli warunek [  nie będzie spełniony (przyjmie wartość false), to na ekranie zo- stanie wyświetlony tekst +PUVTWMELCA. Aby powiązać blok +PUVTWMELCA z warunkiem Z  , trzeba skorzystać z nawiasów klamrowych: KH Z  ] KH [   QPUQNG9TKVG +PUVTWMELCA  _ GNUG  QPUQNG9TKVG +PUVTWMELCA  W tym przypadku łańcuch +PUVTWMELCA jest wyświetlany, jeśli warunek Z  przyj- muje wartość false. Przykład W niniejszym przykładzie znajduje się program, który na podstawie wprowadzonego przez użytkownika znaku z klawiatury sprawdza, czy znak ten jest literą alfabetu. Jeśli wprowadzono literę alfabetu, program sprawdza, czy jest to mała, czy wielka litera. W każdym przypadku na ekranie pojawia się odpowiedni komunikat. +PUVTWMELGAKHAGNUGEU RT[MđCFCUVQUQYCPKCKHGNUG WUKPI5[UVGO RWDNKEENCUU+H6GUV ] RWDNKEUVCVKEXQKF/CKP ]  QPUQNG9TKVG 2TQUúYRTQYCFKèPCM  EJCTE EJCT  QPUQNG4GCF  KH JCT+U.GVVGT E KH JCT+U.QYGT E  QPUQNG9TKVG.KPG 9RTQYCFQPQOCđæNKVGTú / GNUG  QPUQNG9TKVG.KPG 9RTQYCFQPQYKGNMæNKVGT/ú  GNUG  QPUQNG9TKVG.KPG 9RTQYCFQP[PCMPKGLGUVN/KVGTæCNHCDGVW  _ _ Przykładowe dane:  Przykładowy wynik: 2TQUúYRTQYCFKèPCM 9RTQYCFQP[PCMPKGLGUVNKVGTæCNHCDGVW Poniżej przedstawiono kilka innych wyników działania tego programu: Uruchomienie 2 2TQUúYRTQYCFKèPCM# 9RTQYCFQPQYKGNMæNKVGTú 16 Rozdział 2. Słowa kluczowe języka C# Uruchomienie 3 2TQUúYRTQYCFKèPCMJ 9RTQYCFQPQOCđæNKVGTú Dzięki konstrukcji else-if można rozszerzyć instrukcję warunkową o większą liczbę wa- runków, na przykład: KH 9CTWPGMA +PUVTWMELCA GNUGKH 9CTWPGMA +PUVTWMELCA GNUGKH 9CTWPGMA +PUVTWMELCA  GNUG +PUVTWMELCAP Przykład Poniższy program służy do sprawdzania, czy użytkownik wprowadził małą literę, wiel- ką literę, czy cyfrę. Inne znaki nie należą do grupy znaków alfanumerycznych. W pro- gramie wykorzystano konstrukcję else-if. +PUVTWMELGAKHAGNUGEU GNUGKH WUKPI5[UVGO RWDNKEENCUU+H6GUV ] RWDNKEUVCVKEXQKF/CKP ]  QPUQNG9TKVG 2TQUúYRTQYCFKèPCM  EJCTE EJCT  QPUQNG4GCF  KH JCT+U7RRGT E  QPUQNG9TKVG.KPG 9RTQYCFQPQYKGNMæNKVGTú / GNUGKH JCT+U.QYGT E  QPUQNG9TKVG.KPG 9RTQYCFQPQOCđæNKVGTú  GNUGKH JCT+U KIKV E  QPUQNG9TKVG.KPG 9RTQYCFQPQE[HTú  GNUG  QPUQNG9TKVG.KPG 6QPKGLGUVPCMCNHCPWOGT[/EP[  _ _ Przykładowe dane Przykładowy wynik: 2TQUúYRTQYCFKèPCM 9RTQYCFQPQYKGNMæNKVGTú Uruchomienie 2 2TQUúYRTQYCFKèPCMG 9RTQYCFQPQOCđæNKVGTú Słowa kluczowe instrukcji 17 Uruchomienie 3 2TQUúYRTQYCFKèPCM 9RTQYCFQPQE[HTú Uruchomienie 4 2TQUúYRTQYCFKèPCM 6QPKGLGUVPCMCNHCPWOGT[EP[ Zobacz także:  switch switch Instrukcja switch należy do grupy instrukcji sterujących przebiegiem programu. Za po- mocą tej instrukcji można wykonać odpowiedni blok kodu źródłowego w zależności od wartości wyrażenia sterującego. Oto składnia instrukcji switch: UYKVEJ Y[TCľGPKG ] ECUGY[TCľGPKGUVCđG KPUVTWMELC KPUVTWMELCUMQMW =FGHCWNV KPUVTWMELC KPUVTWMELCUMQMW? _ gdzie: wyrażenie Wyrażenie całkowitoliczbowe. instrukcja Wewnętrzna instrukcja (lub blok instrukcji), która jest wykonywana, gdy wyrażenie przyjmie jedną z wartości wymienionych w instrukcji switch (jest to blok zawarty w sekcji case). Gdy wyrażenie nie przyjmie żadnej wartości wymienionej w instrukcji switch, wykonywany jest kod zawarty w sekcji default. instrukcja-skoku Instrukcja, która powoduje wyjście z danej sekcji case. wyrażenie-stałe W zależności od wartości tego wyrażenia wykonywany jest blok instrukcji znajdujący się w odpowiedniej sekcji case. Uwagi Po wyznaczeniu wartości wyrażenia instrukcji switch następuje wykonywanie bloku kodu tej sekcji case, której wyrażenie stałe ma taką samą wartość jak wyrażenie. W in- strukcji switch można umieścić dowolną liczbę sekcji case, ale nie można zastosować 18 Rozdział 2. Słowa kluczowe języka C# dwóch sekcji case, których wartość wyrażenia stałego jest taka sama. Wykonywanie in- strukcji switch rozpoczyna się od wybranego bloku, a kończy na instrukcji skoku, która powoduje wyjście z sekcji case. Należy zauważyć, że odpowiednia instrukcja skoku jest wymagana na końcu bloku ko- du w każdej sekcji case oraz w sekcji default. W przeciwieństwie do odpowiednika in- strukcji switch w języku C++, C# nie zapewnia domyślnego przejścia z jednej etykiety case do następnej. Aby umożliwić przejście pomiędzy określonymi etykietami, należy skorzystać z instrukcji goto w odpowiednim bloku case lub default. Jeśli wyrażenie ma wartość, która nie pasuje do wartości żadnego wyrażenia stałego etykiet case, sterowanie przechodzi do instrukcji zawartych w sekcji oznaczonej ety- kietą default (umieszczenie tej etykiety w instrukcji switch jest opcjonalne). Jeśli in- strukcja switch nie zawiera etykiety default, następuje wyjście z instrukcji. Przykład KPUVTWMELGAUYKVEJEU WUKPI5[UVGO ENCUU5YKVEJ6GUV ] RWDNKEUVCVKEXQKF/CKP ]  QPUQNG9TKVG.KPG -CYC/CđCĦTGFPKC WľC   QPUQNG9TKVG 2TQUúY[DTCèMCYú  UVTKPIU QPUQNG4GCF.KPG  KPVPKPV2CTUG U  KPVEQUV UYKVEJ P ] ECUG ECUG EQUV  DTGCM ECUG EQUV  IQVQECUG ECUG EQUV  IQVQECUG FGHCWNV  QPUQNG9TKVG.KPG 0KGRTCYKFđQY[Y[DÎT/QľP/CY[DTCèNWD  DTGCM _ KH EQUV  QPUQNG9TKVG.KPG 2TQUúYTWEKè]_ITQU[EQ/UV   QPUQNG9TKVG.KPG  KúMWLGO[CUMQT[UVCPKGP/CUGLWUđWIK  _ _ Przykładowe dane:  Słowa kluczowe instrukcji 19 Przykładowy wynik -CYC/CđCĦTGFPKC WľC 2TQUúY[DTCèMCYú 2TQUúYTWEKèITQU[ KúMWLGO[CUMQT[UVCPKGPCUGLWUđWIK W powyższym przykładzie jako wyrażenia użyto zmiennej typu całkowitego o nazwie P. Można również skorzystać bezpośrednio ze zmiennej typu string o nazwie U, wówczas instrukcja switch przyjmie postać: UYKVEJ U ] ECUG  ECUG  _ Zobacz także:  if Instrukcje iteracyjne Za pomocą instrukcji iteracyjnych można tworzyć pętle. Instrukcje iteracyjne wykonują instrukcję wewnętrzną określoną ilość razy, aż do wystąpienia warunku kończącego działanie pętli. Instrukcje wykonywane są w porządku, w jakim wystąpiły w tekście programu (wyjątkiem jest instrukcja skoku). Poniższe słowa kluczowe są wykorzystywane w instrukcjach iteracyjnych:      FQ HQT HQTGCEJ KP YJKNG do Instrukcja do służy do wielokrotnego wykonywania instrukcji wewnętrznej (lub bloku instrukcji), aż do momentu, gdy określone wyrażenie przyjmie wartość false. Oto skład- nia instrukcji do: FQKPUVTWMELCYJKNG Y[TCľGPKG  gdzie: wyrażenie Jest to wyrażenie, które może być niejawnie przekształcone w wyrażenie boolowskie lub w typ zawierający przeciążone operatory true i false. 20 Rozdział 2. Słowa kluczowe języka C# Wyrażenie to służy do sprawdzania, czy warunek kończący działanie pętli został osiągnięty. instrukcja Wewnętrzna instrukcja (lub blok instrukcji) do wykonania. Uwagi W przeciwieństwie do instrukcji while, w instrukcji do wartość wyrażenia jest oblicza- na po wykonaniu wewnętrznego bloku instrukcji, co sprawia, że blok ten jest wykony- wany przynajmniej raz. Przykład KPUVTWMELGAFQEU WUKPI5[UVGO RWDNKEENCUU6GUV Q9JKNG ] RWDNKEUVCVKEXQKF/CKP ] KPVZ KPV[ FQ ] Z[   QPUQNG9TKVG.KPG Z  _ YJKNG [  _ _ Wynik      Przykład W tym przykładzie pokazano sytuację, w której wyrażenie ma zawsze wartość false, lecz mimo to pętla zostanie wykonana tylko raz. UVCVGOGPVUAFQEU WUKPI5[UVGO ENCUU Q6GUV] RWDNKEUVCVKEXQKF/CKP ] KPVP FQ ]  QPUQNG9TKVG.KPG 9CTVQħèOKGPPGLPY[PQUK]_/P  P  Słowa kluczowe instrukcji 21 _YJKNG P  _ _ Wynik 9CTVQħèOKGPPGLPY[PQUK for Pętle for służą do wielokrotnego wykonywania wewnętrznej instrukcji (lub bloku in- strukcji), aż do momentu, gdy określone wyrażenie przyjmie wartość false. Oto skład- nia pętli for: HQT =KPKELCVQT[?=Y[TCľGPKG?=KVGTCVQT[? KPUVTWMELC gdzie: inicjatory Szereg wyrażeń lub instrukcji przypisania inicjujący liczniki pętli. Wyrażenia i instrukcje przypisania są oddzielone od siebie za pomocą przecinka. wyrażenie Jest to wyrażenie, które może być niejawnie przekształcone w wyrażenie boolowskie lub w typ zawierający operatory przeciążone true i false. Wyrażenie to służy do sprawdzania, czy warunek kończący działanie pętli został osiągnięty. iteratory Instrukcja (lub blok instrukcji) służąca do inkrementacji lub dekrementacji wartości liczników pętli. instrukcja Wewnętrzna instrukcja (lub blok instrukcji) danej pętli. Uwagi Instrukcja for jest wykonywana w następujący sposób:  Najpierw są wyznaczane wartości inicjatorów.  Następnie sprawdzana jest wartość logiczna wyrażenia. Jeśli wyrażenie ma wartość true, następuje wykonanie wewnętrznego bloku instrukcji, po czym wyznaczana jest wartość iteratorów.  Jeśli wyrażenie ma wartość logiczną false, następuje wyjście z pętli. W instrukcji for najpierw sprawdzana jest wartość logiczna wyrażenia, co sprawia, że blok wewnętrzny pętli może w ogóle nie zostać wykonany. Wszystkie wyrażenia sterujące pętlą for są opcjonalne, dzięki czemu można tworzyć pętle nieskończone, na przykład: HQT  ]  22 Rozdział 2. Słowa kluczowe języka C# _ Przykład KPUVTWMELGAHQTEU RúVNCHQT WUKPI5[UVGO RWDNKEENCUU(QT.QQR6GUV ] RWDNKEUVCVKEXQKF/CKP ] HQT KPVKKK  QPUQNG9TKVG.KPG K  _ _ Wynik      foreach, in Instrukcja foreach służy do wielokrotnego wykonywania grupy instrukcji wewnętrz- nych dla każdego elementu znajdującego się w tablicy lub w obiekcie kolekcji. W in- strukcji foreach jest przeprowadzana iteracja po elementach kolekcji w celu uzyskania określonych informacji. Instrukcja ta nie powinna być wykorzystywana do zmiany za- wartości tablicy lub obiektu kolekcji, ponieważ dokonywanie takich zmian może mieć nieprzewidywalne skutki. Oto składnia instrukcji foreach: HQTGCEJ V[RKFGPV[HKMCVQTKPY[TCľGPKG KPUVTWMELC gdzie: typ Typ identyfikatora. identyfikator Zmienna iteracyjna reprezentująca element kolekcji. wyrażenie Kolekcja obiektów lub wyrażenie typu tablicowego. Typ elementów kolekcji musi być przekształcalny do typu zmiennej iteracyjnej. instrukcja Wewnętrzna instrukcja (lub blok instrukcji) do wykonania. Słowa kluczowe instrukcji 23 Uwagi Instrukcja wewnętrzna jest wykonywana dla każdego elementu znajdującego się w ta- blicy lub kolekcji. Po wykonaniu iteracji po wszystkich elementach kolekcji, sterowanie przekazywane jest do następnej instrukcji umieszczonej poniżej bloku foreach. Więcej informacji na temat słowa kluczowego foreach (łącznie z przykładami zastoso- wań) znajduje się w podpunktach:  Wykorzystanie instrukcji foreach z tablicami.  Wykorzystanie instrukcji foreach z kolekcjami. Wykorzystanie instrukcji foreach z tablicami Przy korzystaniu z instrukcji foreach i tablicy, wewnętrzna instrukcja (lub blok instruk- cji) jest wykonywana dla każdego elementu tablicy. Przykład W niniejszym przykładzie znajduje się program, który służy do wyznaczania liczby wszystkich liczb parzystych i nieparzystych zawartych w tablicy. Każdy typ (parzysty i nieparzysty) posiada swój własny licznik, przechowujący liczbę wystąpień danego typu. UVCVGOGPVUAHQTGCEJACTTC[UEU 9[MQT[UVCPKGHQTGCEJVCDNKECOK WUKPI5[UVGO ENCUU/CKP NCUU ] RWDNKEUVCVKEXQKF/CKP ] KPVQFFGXGP KPV=?CTTPGYKPV=?]_ HQTGCEJ KPVKKPCTT ] KH K GXGP  GNUG QFF  _  QPUQNG9TKVG.KPG  PCNGKQPQ]_NKEDPKGRCT[UV/[EJK]_NKEDRCT[UV[EJ QFFGXGP  _ _ Wynik PCNGKQPQNKEDRCT[UV[EJKNKEDRCT[UV[EJ Zobacz także:  foreach, in (strona 65); Tablice (strona 245). 24 Rozdział 2. Słowa kluczowe języka C# Wykorzystanie instrukcji foreach z kolekcjami Aby było możliwe przeprowadzenie iteracji po elementach kolekcji, kolekcja musi spełnić określone wymagania. Na przykład w następującej instrukcji: HQTGCEJ 6[R NGOGPVWGNGOGPVKP/QLC-QNGMELC /QLC-QNGMELC musi spełnić następujące wymagania:  Typ kolekcji:  Musi być jednym z typów: interface, class lub struct.  Musi zawierać metodę o nazwie )GV PWOGTCVQT , zwracającą typ, na przykład PWOGTCVQT (wyjaśniono poniżej).  Typ PWOGTCVQT (klasa lub struktura) musi zawierać:  Właściwość o nazwie WTTGPV, zwracającą 6[R NGOGPVW lub inny typ, który może być przekształcony w 6[R NGOGPVW. Właściwość zwraca aktualny element kolekcji.  Metodę boolowską /QXG0GZV, która służy do przeprowadzania inkrementacji licznika elementów i zwraca wartość logiczną true, jeśli po inkrementacji występują jeszcze elementy w kolekcji. Istnieją trzy sposoby tworzenia i wykorzystywania kolekcji: 1. Utworzenie kolekcji zgodnie z powyższymi instrukcjami. Taka kolekcja może być wykorzystana tylko w programach napisanych w języku C#. 2. Utworzenie kolekcji w postaci ogólnej zgodnie z powyższymi zaleceniami, z dodaniem implementacji interfejsu + PWOGTCDNG. Taka kolekcja może być wykorzystana w innych językach programowania, na przykład w Visual Basic®. 3. Skorzystanie z jednej z predefiniowanych kolekcji, które znajdują się w klasach kolekcji. Poniższe przykłady przedstawiają wyżej wymienione trzy sposoby tworzenia i wyko- rzystywania kolekcji. Przykład Przedstawia: Komentarz Przykład 1 kolekcję dla programów napisanych w języku C#. W tym przykładzie utworzono kolekcję zgodnie z powyższymi zaleceniami. Przykład 2a kolekcję ogólnodostępną. Przykład 2b kolekcję ogólnodostępną zawierającą metodę KURQUG. W tym przykładzie utworzono kolekcję zgodnie z powyższymi zaleceniami oraz zaimplementowano interfejsy + PWOGTCDNG i + PWOGTCVQT. Jest to kolekcja podobna do zdefiniowanej w przykładzie 2a (różnica polega na zastosowaniu w wyliczeniu zdefiniowanym przez użytkownika metody KURQUG, odziedziczonej z interfejsu + KURQUCDNG). Przykład 3 wykorzystanie jednej z predefiniowanych W tym przykładzie utworzono egzemplarz tablicy mieszającej (za pomocą klasy *CUJVCDNG), której Słowa kluczowe instrukcji 25 klas kolekcji. składniki wykorzystano do manipulacji kolekcją. Klasa *CUJVCDNG reprezentuje słownikową strukturę danych opartą o relację klucz-wartość Struktura ta jest implementowana jako tablica mieszająca. Więcej informacji dotyczących interfejsów + PWOGTCVQT i + PWOGTCDNG oraz klasy *CUJ VCDNG znajduje się w „System.Collections” w .NET Framework SDK. Przykład 1 KPUVTWMELGAHQTGCEJAMQNGMELGEU 9[MQT[UVCPKGHQTGCEJMQNGMELæFNC  WUKPI5[UVGO  GMNCTCELCMQNGMELK RWDNKEENCUU/[ QNNGEVKQP ] KPV=?KVGOU RWDNKE/[ QNNGEVKQP ] KVGOUPGYKPV=?]_ _ RWDNKE/[ PWOGTCVQT)GV PWOGTCVQT ] TGVWTPPGY/[ PWOGTCVQT VJKU  _  GMNCTCELCMNCU[Y[NKEGPKC RWDNKEENCUU/[ PWOGTCVQT ] KPVP+PFGZ /[ QNNGEVKQPEQNNGEVKQP RWDNKE/[ PWOGTCVQT /[ QNNGEVKQPEQNN ] EQNNGEVKQPEQNN P+PFGZ _ RWDNKEDQQN/QXG0GZV ] P+PFGZ  TGVWTP P+PFGZEQNNGEVKQPKVGOU)GV.GPIVJ   _ RWDNKEKPV WTTGPV ] IGV ] TGVWTP EQNNGEVKQPKVGOU=P+PFGZ?  _ _ _ _ RWDNKEENCUU/CKP NCUU 26 Rozdział 2. Słowa kluczowe języka C# ] RWDNKEUVCVKEXQKF/CKP ] /[ QNNGEVKQPEQNPGY/[ QNNGEVKQP   QPUQNG9TKVG.KPG 9CTVQħEKYMQNGMELK  9[ħYKGVNGPKGGNGOGPVÎYMQNGMELK HQTGCEJ KPVKKPEQN ]  QPUQNG9TKVG.KPG K  _ _ _ Wynik 9CTVQħEKYMQNGMELK      Przykład 2a W tym przykładzie powtórzono algorytm poprzedniego przykładu, ale zastosowano ogól- nodostępną kolekcję, która może być wyliczana w programach napisanych w innych języ- kach, na przykład w Visual Basic. Ogólnodostępny typ kolekcji musi zawierać imple- mentację interfejsu + PWOGTCDNG znajdującego się w przestrzeni nazw 5[UVGO QNNGEVKQPU. KPUVTWMELGAHQTGCEJAQIÎNPQFQUVúRPCAMQNGMELCEU 9[MQT[UVCPKGHQTGCEJQIÎNPQFQUVúRPæMQNGMELæ WUKPI5[UVGO WUKPI5[UVGO QNNGEVKQPU  GMNCTCELCMQNGMELKKKORNGOGPVCELCKPVGTHGLUW+ PWOG/TCDNG RWDNKEENCUU/[ QNNGEVKQP+ PWOGTCDNG ] KPV=?KVGOU RWDNKE/[ QNNGEVKQP ] KVGOUPGYKPV=?]_ _ RWDNKE/[ PWOGTCVQT)GV PWOGTCVQT ] TGVWTPPGY/[ PWOGTCVQT VJKU  _ +ORNGOGPVCELCOGVQF[)GV PWOGTCVQT  + PWOGTCVQT+ PWOGTCDNG)GV PWOGTCVQT ] TGVWTP)GV PWOGTCVQT  _  GMNCTCELCY[NKEGPKCKKORNGOGPVCELCKPVGTHGLUW/+ PWOGTCVQT RWDNKEENCUU/[ PWOGTCVQT+ PWOGTCVQT Słowa kluczowe instrukcji 27 ] KPVP+PFGZ /[ QNNGEVKQPEQNNGEVKQP RWDNKE/[ PWOGTCVQT /[ QNNGEVKQPEQNN ] EQNNGEVKQPEQNN P+PFGZ _ RWDNKEXQKF4GUGV ] P+PFGZ _ RWDNKEDQQN/QXG0GZV ] P+PFGZ  TGVWTP P+PFGZEQNNGEVKQPKVGOU)GV.GPIVJ   _ RWDNKEKPV WTTGPV ] IGV ] TGVWTP EQNNGEVKQPKVGOU=P+PFGZ?  _ _ 9đCħEKYQħè WTTGPVKPVGTHGLUW+ PWOGTCVQT QDLGEV+ PWOGTCVQT WTTGPV ] IGV ] TGVWTP WTTGPV  _ _ _ _ RWDNKEENCUU/CKP NCUU ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] /[ QNNGEVKQPEQNPGY/[ QNNGEVKQP   QPUQNG9TKVG.KPG 9CTVQħEKYMQNGMELK  9[ħYKGVNGPKGGNGOGPVÎYMQNGMELK HQTGCEJ KPVKKPEQN ]  QPUQNG9TKVG.KPG K  _ _ _ Wynik 9CTVQħEKYMQNGMELK   28 Rozdział 2. Słowa kluczowe języka C#    Przykład 2b Ten przykład jest podobny do poprzedniego. Różni się tylko tym, że wykorzystano tu metodę KURQUG, której implementacja znajduje się w wyliczeniu zdefiniowanym przez użytkownika. Wyliczenie dziedziczy składniki interfejsu + KURQUCDNG. Instrukcja foreach wspiera wyliczenia wykorzystywane jednokrotnie. Jeśli wyliczenie zawiera implementację interfejsu + KURQUCDNG, to — niezależnie od sposobu przerwania pętli w stosunku do wyliczenia — zostanie wywołana metoda KURQUG. KPUVTWMELGAHQTGCEJAQIÎNPQFQUVúRPGAMQNGMELGEU 9[MQT[UVCPKGHQTGCEJMQNGMELCQIÎNPQFQUVúRPæ WUKPI5[UVGO WUKPI5[UVGO QNNGEVKQPU  GMNCTCELCMQNGMELKKKORNGOGPVCELCKPVGTHGLUW+ PWOG/TCDNG RWDNKEENCUU/[ QNNGEVKQP+ PWOGTCDNG ] KPV=?KVGOU RWDNKE/[ QNNGEVKQP ] KVGOUPGYKPV=?]_ _ RWDNKE/[ PWOGTCVQT)GV PWOGTCVQT ] TGVWTPPGY/[ PWOGTCVQT VJKU  _ +ORNGOGPVCELCOGVQF[)GV PWOGTCVQT  + PWOGTCVQT+ PWOGTCDNG)GV PWOGTCVQT ] TGVWTP)GV PWOGTCVQT  _  GMNCTCELCY[NKEGPKCKKORNGOGPVCELCKPVGTHGLUÎ/Y+ PWOGTCVQT K+ KURQUCDNG RWDNKEENCUU/[ PWOGTCVQT+ PWOGTCVQT+ KURQUCDNG/ ] KPVP+PFGZ /[ QNNGEVKQPEQNNGEVKQP RWDNKE/[ PWOGTCVQT /[ QNNGEVKQPEQNN ] EQNNGEVKQPEQNN P+PFGZ _ RWDNKEXQKF4GUGV ] P+PFGZ _ RWDNKEDQQN/QXG0GZV ] Słowa kluczowe instrukcji 29 P+PFGZ  TGVWTP P+PFGZEQNNGEVKQPKVGOU)GV.GPIVJ   _ RWDNKEKPV WTTGPV ] IGV ] TGVWTP EQNNGEVKQPKVGOU=P+PFGZ?  _ _ 9đCħEKYQħè WTTGPVKPVGTHGLUW+ PWOGTCVQT QDLGEV+ PWOGTCVQT WTTGPV ] IGV ] TGVWTP WTTGPV  _ _ RWDNKEXQKF KURQUG ]  QPUQNG9TKVG.KPG  GTQYCPKGMQNGMELK  EQNNGEVKQPPWNN _ _ _ RWDNKEENCUU/CKP NCUU ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] /[ QNNGEVKQPEQNPGY/[ QNNGEVKQP   QPUQNG9TKVG.KPG 9CTVQħEKYMQNGMELK  9[ħYKGVNGPKGGNGOGPVÎYMQNGMELK HQTGCEJ KPVKKPEQN ]  QPUQNG9TKVG.KPG K  _ _ _ Wynik 9CTVQħEKYMQNGMELK      GTQYCPKGMQNGMELK 30 Rozdział 2. Słowa kluczowe języka C# Przykład 3 W tym przykładzie użyto predefiniowanej klasy *CUJVCDNG. Dzięki wykorzystaniu w programie przestrzeni nazw 5[UVGO QNNGEVKQPU mamy dostęp do klasy *CUJVCDNG i jej składników. Aby dodać elementy do obiektu klasy *CUJVCDNG, należy skorzystać z metody #FF. KPUVTWMELGAHQTGCEJAJCUJVCDNGEU 9[MQT[UVCPKGMNCU[MQNGMELK*CUJVCDNG WUKPI5[UVGO WUKPI5[UVGO QNNGEVKQPU RWDNKEENCUU/CKP NCUU ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ]  GMNCTCELCQDKGMVWMNCU[*CUJVCDNG *CUJVCDNGKRJCUJPGY*CUJVCDNG   QFCPKGGNGOGPVÎYCRQOQEæOGVQF[#FF  KRJCUJ#FF $GNNGXWG  KRJCUJ#FF 4GFOQPF  KRJCUJ#FF  XGTGVV  KRJCUJ#FF 5GCVVNG  KRJCUJ#FF 2W[CNNWR  9[ħYKGVNGPKGCYCTVQħEKVCDNKE[OKGUCLæEGL  QPUQNG9TKVG.KPG -QFRQEVQY[/KCUVQ  HQTGCEJ UVTKPIKRKPKRJCUJ-G[U ]  QPUQNG9TKVG.KPG KR  KRJCUJ=K/R?  _ _ _ Wynik -QFRQEVQY[/KCUVQ  XGTGVV 4GFOQPF 5GCVVNG $GNNGXWG 2W[CNNWR Zobacz także:  foreach, in (strona 65). while Instrukcja while służy do wielokrotnego wykonywania określonego bloku instrukcji, aż do momentu, w którym wyrażenie kontrolne przyjmie wartość false. Oto składnia in- strukcji while: YJKNG Y[TCľGPKG KPUVTWMELC gdzie: Słowa kluczowe instrukcji 31 wyrażenie Jest to wyrażenie kontrolne, które może być niejawnie przekształcone w typ bool albo w inny typ zawierający przeciążone operatory true i false. Wyrażenie kontrolne służy do sprawdzania, czy warunek kończący działanie pętli został osiągnięty. instrukcja Wewnętrzna instrukcja (lub blok instrukcji) do wykonania. Uwagi Wartość wyrażenia kontrolnego jest wyznaczana przed wykonaniem wewnętrznego bloku instrukcji, co sprawia, że pętla może w ogóle nie zostać wykonana. Wykonywanie pętli może być przerwane za pomocą instrukcji break, goto, return lub throw, które powodują wyjście z pętli. Aby przekazać sterowanie do następnej iteracji, należy skorzystać z instrukcji continue. Przykład KPUVTWMELGAYJKNGEU WUKPI5[UVGO ENCUU9JKNG6GUV ] RWDNKEUVCVKEXQKF/CKP ] KPVP YJKNG P ]  QPUQNG9TKVG.KPG #MVWCNPCYCTVQħèPY[PQUK]/_P  P  _ _ _ Wynik #MVWCNPCYCTVQħèPY[PQUK #MVWCNPCYCTVQħèPY[PQUK #MVWCNPCYCTVQħèPY[PQUK #MVWCNPCYCTVQħèPY[PQUK #MVWCNPCYCTVQħèPY[PQUK Instrukcje skoku Instrukcje skoku służą do rozgałęziania programu. Za pomocą tych instrukcji można przekazać sterowanie w inne miejsce programu. Poniżej znajduje się wykaz słów klu- czowych wykorzystywanych w instrukcjach skoku:   DTGCM EQPVKPWG 32 Rozdział 2. Słowa kluczowe języka C#    FGHCWNV IQVQ TGVWTP break Instrukcja break powoduje przerwanie wykonywania „najciaśniejszej” pętli lub in- strukcji warunkowej, w której się znajduje. Sterowanie jest przekazywane do najbliższej instrukcji znajdującej się poniżej instrukcji przerwanej. Oto składnia instrukcji break: DTGCM Przykład W tym przykładzie instrukcja sterująca pętli for zawiera licznik, którego wartość po- winna się zmieniać od  do . Zastosowano jednak instrukcję break, która przerywa wykonywanie pętli, gdy licznik osiągnie wartość . UVCVGOGPVUADTGCMEU WUKPI5[UVGO ENCUU$TGCM6GUV ] RWDNKEUVCVKEXQKF/CKP ] HQT KPVKKK ] KH K DTGCM  QPUQNG9TKVG.KPG K  _ _ _ Wynik     Przykład W tym przykładzie zastosowano instrukcję break wewnątrz instrukcji switch. KPUVTWMELGADTGCMEU DTGCMKUYKVEJ WUKPI5[UVGO ENCUU5YKVEJ ] RWDNKEUVCVKEXQKF/CKP ]  QPUQNG9TKVG 9RTQYCFļNWD  UVTKPIU QPUQNG4GCF.KPG  KPVP+PV2CTUG U  Słowa kluczowe instrukcji 33 UYKVEJ P ] ECUG  QPUQNG9TKVG.KPG #MVWCNPCYCTVQħèY[PQUK]/_  DTGCM ECUG  QPUQNG9TKVG.KPG #MVWCNPCYCTVQħèY[PQUK]/_  DTGCM ECUG  QPUQNG9TKVG.KPG #MVWCNPCYCTVQħèY[PQUK]/_  DTGCM FGHCWNV  QPUQNG9TKVG.KPG 9RTQYCFQPQPKGRTCYKFđQY/æYCTVQħè  DTGCM _ _ _ Wprowadzając:  Przykładowy wynik 9RTQYCFļNWD #MVWCNPCYCTVQħèY[PQUK Jeśli wprowadzimy wartość 4, wówczas otrzymamy: 9RTQYCFļNWD 9RTQYCFQPQPKGRTCYKFđQYæYCTVQħè continue Instrukcja continue jest wykorzystywana podczas przekazywania sterowania do na- stępnej iteracji występującej w danej instrukcji iteracyjnej (pętli). Oto składnia instruk- cji continue: EQPVKPWG Przykład W poniższym przykładzie znajduje się pętla for z licznikiem, którego wartości zmie- niają się od  do . Zastosowanie instrukcji continue umieszczonej w warunku K spowodowało, że blok programu umieszczonego pomiędzy instrukcją continue a koń- cem pętli for nie został wykonany. KPUVTWMELGAEQPVKPWGEU WUKPI5[UVGO ENCUU QPVKPWG6GUV ] RWDNKEUVCVKEXQKF/CKP ] HQT KPVKKK ] 34 Rozdział 2. Słowa kluczowe języka C# KH K EQPVKPWG  QPUQNG9TKVG.KPG K  _ _ _ Wynik   goto Za pomocą instrukcji goto można przekazać sterowanie bezpośrednio do instrukcji oznaczonej etykietą, czyli w określone miejsce programu. Oto składnia instrukcji goto: IQVQKFGPV[HKMCVQT IQVQECUGY[TCľGPKGUVCđG IQVQFGHCWNV gdzie: identyfikator Identyfikatorem jest etykieta. wyrażenie-stałe Jest to etykieta instrukcji case wewnątrz instrukcji switch. Uwagi W tabeli przedstawiono trzy postaci omawianej instrukcji. W pierwszej z nich identyfi- kator oznacza etykietę znajdującą się w bieżącym bloku programu, w tym samym za- sięgu leksykalnym lub w zasięgu zawierającym instrukcję goto. Instrukcja goto jest zwykle wykorzystywana do przekazywania sterowania do określo- nej etykiety case instrukcji switch albo do etykiety default instrukcji switch. Za pomocą instrukcji goto można opuścić głęboko zagnieżdżone pętle. Jeśli etykieta, do której odwołuje się instrukcja goto, nie była wcześniej wykorzystywa- na w programie, wówczas w trakcie kompilacji może wystąpić ostrzeżenie. Przykład Przykład wykorzystania instrukcji goto w celu przekazania sterowania do określonej etykiety case instrukcji switch znajduje się w punkcie „switch” na stronie 60. Przykład Poniższy przykład przedstawia wykorzystanie instrukcji goto w celu opuszczenia za- gnieżdżonych pętli. KPUVTWMELGAIQVQEU Słowa kluczowe instrukcji 35  CIPKGľFľQPGRúVNGUđWľæEGFQRTGUWMKYCPKCCYCTVQħE/KVCDNKE[ WUKPI5[UVGO RWDNKEENCUU)QVQ6GUV ] RWDNKEUVCVKEXQKF/CKP ] KPVZ[ KPV=?O[#TTC[PGYKPV=Z[? KPKELCNKCELCVCDNKE[ HQT KPVKKZK HQT KPVLL[L O[#TTC[=KL? K 1FE[VYRTQYCFQPGLRTGWľ[VMQYPKMCYCTVQħE/K  QPUQNG9TKVG 9RTQYCFļNKEDúMVÎTæPCNGľ[PCNGļè/  YRTQYCFGPKGPCMW UVTKPIU QPUQNG4GCF.KPG  KPVO[0WODGT+PV2CTUG U  2TGUWMKYCPKGVCDNKE[FYWY[OKCTQYGL HQT KPVKKZK HQT KPVLL[L KH O[#TTC[=KL?O[0WODGT IQVQ(QWPF  QPUQNG9TKVG.KPG .KED[]_PKGPCNGKQPQO[0WO/DGT  IQVQ(KPKUJ (QWPF  QPUQNG9TKVG.KPG .KEDC]_QUVCđCPCNGKQPCO/[0WODGT  (KPKUJ  QPUQNG9TKVG.KPG 2TGUWMKYCPKGCMQēEQPG  _ _ Źródło  Przykładowy wynik 9RTQYCFļNKEDúMVÎTæPCNGľ[PCNGļè .KEDCQUVCđCPCNGKQPC 2TGUWMKYCPKGCMQēEQPG Przykład KPUVTWMELGAIQVQEU 9[UVæRKDđæFQPWOGTG 5DQ GV[MKGV[PCLFWLæUKúRQCCUKúIKGO WUKPI5[UVGO ENCUU7PTGCEJCDNG QFG ] RWDNKEUVCVKEXQKF/CKP ] KPVZ 36 Rozdział 2. Słowa kluczowe języka C#  QPUQNG9TKVG.KPG Z]_Z  KH Z ] Z IQVQ#$đæF _ ZZ  HQT KPVKKK ] # QPUQNG9TKVG.KPG K  _  QPUQNG9TKVG.KPG Z]_Z  _ _ W tym przykładzie instrukcja goto odwołuje się do etykiety #, która jest poza zasięgiem instrukcji goto. W trakcie kompilacji wystąpi błąd: 0QUWEJNCDGN # YKVJKPVJGUEQRGQHVJGIQVQUVCVGOGPV co oznacza, że nie istnieje etykieta # w zasięgu instrukcji goto. Do etykiety # nie odwołano się wcześniej w programie, wobec czego w trakcie kompi- lacji wystąpi ostrzeżenie. Jeśli etykietę # umieścimy na początku instrukcji rozpoczynającej pętlę for, będziemy mogli skompilować i uruchomić program. #HQT KPVKKK ]6GTCDúFKGOQľPCUMQORKNQY/CèRTQITCO return Instrukcja return powoduje przerwanie wykonywania metody, w której się znajduje i po- wrót sterowania do miejsca, w którym metoda została wywołana. Za pomocą tej instrukcji można również zwrócić wartość określonego wyrażenia. Jeśli dana metoda jest typu void, wówczas nie trzeba korzystać z instrukcji return. Oto składnia instrukcji return: TGVWTP=Y[TCľGPKG? gdzie: wyrażenie Wartość zwrócona przez daną metodę. Wyrażenie nie jest wykorzystywane w metodach typu void. Przykład W poniższym przykładzie metoda CNEWNCVG#TGC KPVT zwraca wartość pola powierzch- ni koła za pomocą zmiennej CTGC typu double. KPUVTWMELGATGVWTPEU WUKPI5[UVGO Słowa kluczowe instrukcji 37 ENCUU4GVWTP6GUV ] UVCVKEFQWDNG CNEWNCVG#TGC KPVT ] FQWDNGCTGC CTGCT T /CVJ2+ TGVWTPCTGC _ RWDNKEUVCVKEXQKF/CKP ] KPVTCFKWU  QPUQNG9TKVG.KPG 2QNGRQYKGTEJPKY[PQUK]_ /CNEWNCVG#TGC TCFKWU  _ _ Wynik 2QNGRQYKGTEJPKY[PQUK Instrukcje obsługi wyjątków Język C# posiada wbudowany system obsługi sytuacji wyjątkowych, zwanych krótko wyjątkami (ang. exceptions), które mogą wystąpić w trakcie wykonywania programu. Wyjątki są obsługiwane w specjalnych, wydzielonych blokach kodu źródłowego, do których sterowanie ma dostęp tylko wtedy, gdy wystąpi sytuacja wyjątkowa. Do obsługi wyjątków wykorzystuje się słowa kluczowe: try, catch, throw i finally. Podrozdział składa się z następujących punktów:     VJTQY VT[ECVEJ VT[HKPCNN[ VT[ECVEJHKPCNN[ throw Instrukcja throw służy do zgłaszania sytuacji wyjątkowych, które wystąpiły podczas wykonywania programu. Oto składnia instrukcji throw: VJTQY=Y[TCľGPKG? gdzie: wyrażenie Jest to obiekt wyjątku. Wyrażenie można opuścić, jeśli ponownie zgłaszany jest wyjątek bieżącego obiektu w bloku catch. 38 Rozdział 2. Słowa kluczowe języka C# Uwagi Zgłoszony wyjątek jest obiektem klasy pochodnej względem System.Exception, na przykład: ENCUU/[ ZEGRVKQP5[UVGO ZEGRVKQP]_ VJTQYPGY/[ ZEGRVKQP  Instrukcja throw najczęściej wykorzystywana jest z instrukcjami obsługi wyjątków try- catch lub try-finally. Gdy dany wyjątek jest zgłaszany, następuje poszukiwanie odpo- wiedniego bloku catch, który może obsłużyć ten wyjątek. Przykład W poniższym przykładzie pokazano sposób wykorzystania instrukcji throw w celu zgło- szenia wyjątku. RT[MđCFWľ[EKCKPUVTWMELKVJTQY WUKPI5[UVGO RWDNKEENCUU6JTQY6GUV ] RWDNKEUVCVKEXQKF/CKP ] UVTKPIUPWNN KH UPWNN ] VJTQY PGY#TIWOGPV0WNN ZEGRVKQP  _  QPUQNG9TKVG 9OKGPPGLUV[RW5VTKPIPCLFWLGUK/úYCTVQħèPWNN  åKPUVTWMELCPKGQUVCPKGY[MQPCPC _ _ Wynik Wynikiem działania programu będzie wystąpienie wyjątku: 5[UVGO#TIWOGPV0WNN ZEGRVKQP Przykład Inne przykłady wykorzystania instrukcji throw znajdują się na stronie 80 („try-catch”, „try-finally” i „try-catch-finally”). try-catch Instrukcja try-catch składa się z bloku try oraz jednego lub kilku bloków catch, które określają odpowiednie sekcje obsługi wyjątków. Oto składnia instrukcji try-catch: VT[DNQMVT[ ECVEJ FGMNCTCELCY[LæVMW DNQMECVEJ ECVEJ FGMNCTCELCY[LæVMW DNQMECVEJ Słowa kluczowe instrukcji 39  VT[DNQMVT[ECVEJDNQMECVEJ gdzie: blok-try Zawiera segment kodu źródłowego, w którym może wystąpić sytuacja wyjątkowa. deklaracja-wyjątku, dekaracja-wyjątku-1, deklaracja-wyjątku-2 Deklaracja obiektów wyjątku. catch-blok, catch-blok-1, catch-blok-2 Bloki zawierają kod obsługi wyjątków. Uwagi W bloku blok-try znajduje się kod źródłowy, którego wykonanie może spowodować wystąpienie wyjątku. Dany kod jest wykonywany aż do momentu zgłoszenia
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual C# .NET. Encyklopedia
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ą: