Visual C# .NET. Encyklopedia

IDZ DO
PRZYK£ADOWY ROZDZIA£

SPIS TRE CI Visual C# .NET.
Encyklopedia
KATALOG KSI¥¯EK
Autor: Microsoft Corporation
KATALOG ONLINE T³umaczenie: Tomasz Miszkiel
ISBN: 83-7197-819-7
ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Microsoft Visual C# .Net
Language Reference
Format: B5, stron: 390
TWÓJ KOSZYK
DODAJ DO KOSZYKA 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
CENNIK I INFORMACJE 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#,
ZAMÓW INFORMACJE zawiera ona wiele przyk³adów gotowych do wykorzystania w konkretnych aplikacjach.
O NOWO CIACH Jest to ksi¹¿ka, do której bêdziesz czêsto powraca³.
Omówiono:
ZAMÓW CENNIK • Typy
• Modyfikatory
• Polecenia
CZYTELNIA • Przestrzenie nazw
• Operatory
FRAGMENTY KSI¥¯EK ONLINE • 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#............................................................................................................ 9
Ogólna struktura programu napisanego w języku C#.............................................................. 10

Rozdział 2. Słowa kluczowe języka C# 13
Słowa kluczowe.................................................................................................................. 13
Modyfikatory ..................................................................................................................... 14
Modyfikatory dostępu.................................................................................................... 15
abstract ........................................................................................................................ 25
const ............................................................................................................................ 27
event............................................................................................................................ 29
extern........................................................................................................................... 35
override........................................................................................................................ 36
readonly ....................................................................................................................... 38
sealed........................................................................................................................... 40
static ............................................................................................................................ 40
unsafe .......................................................................................................................... 43
virtual .......................................................................................................................... 44
volatile ......................................................................................................................... 46
Przekształcenia ................................................................................................................... 47
explicit ......................................................................................................................... 47
implicit......................................................................................................................... 49
operator........................................................................................................................ 50
Słowa kluczowe dostępu ..................................................................................................... 52
base ............................................................................................................................. 52
this............................................................................................................................... 54
Słowa kluczowe instrukcji ................................................................................................... 56
Instrukcje wyboru ......................................................................................................... 56
Instrukcje iteracyjne ...................................................................................................... 62
Instrukcje skoku............................................................................................................ 74
Instrukcje obsługi wyjątków........................................................................................... 80
Instrukcje checked i unchecked ...................................................................................... 87
Instrukcja fixed ............................................................................................................. 93
Instrukcja lock .............................................................................................................. 95

4 Spis treści

Słowa kluczowe literałów .................................................................................................... 97
null .............................................................................................................................. 97
true .............................................................................................................................. 97
false ............................................................................................................................. 98
Słowa kluczowe operatorów ................................................................................................ 99
as............................................................................................................................... 100
is ............................................................................................................................... 101
new............................................................................................................................ 103
sizeof ......................................................................................................................... 107
typeof ........................................................................................................................ 108
true ............................................................................................................................ 110
false ........................................................................................................................... 111
stackalloc ................................................................................................................... 112
Słowa kluczowe parametrów ............................................................................................. 113
params ....................................................................................................................... 114
ref.............................................................................................................................. 115
out ............................................................................................................................. 116
Słowa kluczowe przestrzeni nazw ...................................................................................... 117
namespace.................................................................................................................. 117
using .......................................................................................................................... 119
Słowa kluczowe typów...................................................................................................... 122
Typy bezpośrednie ...................................................................................................... 123
Opakowywanie i rozpakowywanie................................................................................ 149
Typy referencyjne ....................................................................................................... 152
Tabele typów.............................................................................................................. 163

Rozdział 3. Język C# 171
Operatory......................................................................................................................... 171
Operatory przecią alne ................................................................................................ 172
Operator [ ] ................................................................................................................ 173
Operator () ................................................................................................................. 174
Operator .................................................................................................................... 175
Operator +.................................................................................................................. 176
Operator -................................................................................................................... 177
Operator * .................................................................................................................. 178
Operator /................................................................................................................... 179
Operator %................................................................................................................. 180
Operator & ................................................................................................................. 180
Operator | ................................................................................................................... 181
Operator ^ .................................................................................................................. 182
Operator !................................................................................................................... 183
Operator ~.................................................................................................................. 184
Operator =.................................................................................................................. 184
Operator <.................................................................................................................. 185
Operator >.................................................................................................................. 186
Operator ?: ................................................................................................................. 187
Operator ++................................................................................................................ 188
Operator -- ................................................................................................................. 189
Operator && .............................................................................................................. 190
Operator ||................................................................................................................... 191

Spis treści 5

Operator <<................................................................................................................ 193
Operator >>................................................................................................................ 194
Operator ==................................................................................................................ 195
Operator !=................................................................................................................. 196
Operator <=................................................................................................................ 197
Operator >=................................................................................................................ 198
Operator +=................................................................................................................ 199
Operator -=................................................................................................................. 200
Operator *= ................................................................................................................ 200
Operator /=................................................................................................................. 201
Operator %=............................................................................................................... 202
Operator &= ............................................................................................................... 203
Operator |= ................................................................................................................. 204
Operator ^= ................................................................................................................ 205
Operator <<=.............................................................................................................. 206
Operator >>=.............................................................................................................. 207
Operator ->................................................................................................................. 208
Atrybuty .......................................................................................................................... 209
Wprowadzenie do atrybutów........................................................................................ 209
AttributeUsage............................................................................................................ 216
Conditional................................................................................................................. 217
Obsolete ..................................................................................................................... 219
Przewodnik po atrybutach............................................................................................ 220
Deklaracje........................................................................................................................ 226
Składniki.......................................................................................................................... 229
Składniki przestrzeni nazw........................................................................................... 229
Składniki struktur........................................................................................................ 230
Składniki klas ............................................................................................................. 230
Inne składniki ............................................................................................................. 231
Dostęp do składników.................................................................................................. 231
Dostępność deklarowana.............................................................................................. 231
Dziedziny dostępności ................................................................................................. 232
Dostęp chroniony do składników .................................................................................. 235
Ograniczenia dostępności............................................................................................. 236
Dyrektywy preprocesora ................................................................................................... 237
#if.............................................................................................................................. 238
#else .......................................................................................................................... 239
#elif ........................................................................................................................... 239
#endif......................................................................................................................... 240
#define ....................................................................................................................... 240
#undef........................................................................................................................ 241
#warning .................................................................................................................... 242
#error......................................................................................................................... 242
#line........................................................................................................................... 243
#region....................................................................................................................... 244
#endregion.................................................................................................................. 244
Tablice............................................................................................................................. 245
Tablice jednowymiarowe ............................................................................................. 245
Tablice wielowymiarowe ............................................................................................. 247
Tablice nieregularne .................................................................................................... 248

6 Spis treści

Przekazywanie tablic za pomocą ref i out ...................................................................... 250
Przewodnik po tablicach .............................................................................................. 252
Konstruktory i destruktory................................................................................................. 257
Konstruktory klas........................................................................................................ 257
Konstruktory struktur .................................................................................................. 264
Destruktory ................................................................................................................ 265
Indeksatory ...................................................................................................................... 268
Deklaracja indeksatora................................................................................................. 268
Porównanie indeksatorów z właściwościami .................................................................. 271
Indeksatory interfejsu .................................................................................................. 272
Przewodnik po indeksatorach ....................................................................................... 275
Właściwości ..................................................................................................................... 278
Deklaracja właściwości................................................................................................ 279
Akcesory .................................................................................................................... 281
Właściwości interfejsów .............................................................................................. 287
Przewodnik po właściwościach..................................................................................... 289
Sygnatury i przecią anie.................................................................................................... 295
Zasięg.............................................................................................................................. 296
Ogólne reguły rządzące zasięgami ................................................................................ 296
Ukrywanie nazw ......................................................................................................... 299
Ukrywanie przez zagnie d enie.................................................................................... 299
Ukrywanie przez dziedziczenie..................................................................................... 300
Przekazywanie parametrów ............................................................................................... 302
Metoda Main.................................................................................................................... 307
Wartości zwracane ...................................................................................................... 308
Argumenty z wiersza poleceń ....................................................................................... 309
Przewodnik po metodach warunkowych ............................................................................. 310
Przewodnik po delegacjach................................................................................................ 313
Przewodnik po zdarzeniach ............................................................................................... 319
Dokumentacja XML ......................................................................................................... 326
Znaczniki w komentarzach........................................................................................... 326
Przetwarzanie pliku XML ............................................................................................ 339

Dodatek A Opcje kompilatora języka C# 343
Budowanie programu z wiersza poleceń.............................................................................. 343
Opcje kompilatora C# — wykaz z podziałem na kategorie.................................................... 345
Opcje kompilatora C# — wykaz alfabetyczny ..................................................................... 347
@ (określenie pliku odpowiedzi) ........................................................................................ 349
/addmodule (import metadanych) ....................................................................................... 350
/baseaddress (określenie adresu bazowego biblioteki DLL)................................................... 350
/bugreport (tworzenie informacji o wystąpieniu problemu) ................................................... 351
/checked (kontrola przepełnienia arytmetycznego) ............................................................... 352
/codepage (określenie strony kodowej dla plików z kodem źródłowym)................................. 353
/debug (generowanie informacji diagnostycznych)............................................................... 353
/define (definicja preprocesora) .......................................................................................... 354
/doc (przetwarzanie komentarzy dokumentacji) ................................................................... 355
/filealign (określenie rozmiaru sekcji) ................................................................................. 356
/fullpaths (określenie pełnej ście ki dostępu do pliku) .......................................................... 357
/help, /? (wyświetlenie informacji dotyczących opcji kompilatora) ........................................ 357
/incremental (umo liwienie kompilacji przyrostowej) .......................................................... 358

Spis treści 7

/lib (określenie lokalizacji odwołania do zło eń).................................................................. 359
/linkresource (odnośnik do zasobu .NET Framework).......................................................... 360
/main (określenie lokalizacji metody Main) ......................................................................... 361
/noconfig (ignorowanie pliku csc.rsp) ................................................................................. 362
/nologo (usunięcie informacji o kompilatorze) ........................................................................ 363
/nostdlib (pominięcie biblioteki standardowej)..................................................................... 363
/nowarn (pominięcie określonych ostrze eń)......................................................................... 364
/optimize (włączenie lub wyłączenie optymalizacji)............................................................. 364
/out (określenie nazwy pliku wyjściowego) ......................................................................... 365
/recurse (przeszukanie podkatalogów w celu odnalezienia plików źródłowych) ...................... 366
/reference (import metadanych).......................................................................................... 367
/resource (umieszczenie zasobu w pliku wyjściowym) ......................................................... 368
/target (określenie formatu pliku wyjściowego) ................................................................... 369
/unsafe (uaktywnienie trybu nienadzorowanego).................................................................. 372
/utf8output (wyświetlenie komunikatów kompilatora w kodzie UTF-8) ................................. 373
/warn (określenie poziomu ostrze eń) ................................................................................. 373
/warnaserror (traktowanie ostrze eń na równi z błędami)...................................................... 374
/win32icon (importowanie pliku .ico) ................................................................................. 375
/win32res (importowanie pliku zasobów Win32) ................................................................. 376

Skorowidz 377

RWDNKE ENCUU /CKP%NCUU
]
RWDNKE UVCVKE XQKF /CKP

]
6YQTGPKG QDKGMVÎY
'ORNQ[GG ' PGY 'ORNQ[GG
,QJP / 6TCKPGT LVTCKPGT

9[ YKGVNGPKG Y[PKMÎY
'RTKPV'ORNQ[GG

_
_

Wynik
0CYKUMQ ,QJP / 6TCKPGT
#NKCU LVTCKPGT
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 Słowa kluczowe C#
Instrukcje wyboru KH, GNUG, UYKVEJ, ECUG
Instrukcje iteracyjne FQ, HQT, HQTGCEJ, KP, YJKNG
Instrukcje skoków DTGCM, EQPVKPWG, FGHCWNV, IQVQ, TGVWTP
Instrukcje obsługi wyjątków VJTQY, VT[-ECVEJ, VT[HKPCNN[
Instrukcje EJGEMGF i WPEJGEMGF EJGEMGF, WPEJGEMGF
Instrukcja HKZGF HKZGF
Instrukcja NQEM 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 CF CUVQUQYCPKC KHGNUG
WUKPI 5[UVGO
RWDNKE ENCUU +H6GUV
]

]
%QPUQNG9TKVG
2TQUú YRTQYCFKè PCM
EJCT E
EJCT %QPUQNG4GCF

KH
%JCT+U.GVVGT
E
KH
%JCT+U.QYGT
E
%QPUQNG9TKVG.KPG
9RTQYCFQPQ OC æ NKVGTú
GNUG
%QPUQNG9TKVG.KPG
9RTQYCFQPQ YKGNMæ NKVGTú
GNUG
%QPUQNG9TKVG.KPG
9RTQYCFQP[ PCM PKG LGUV NKVGTæ CNHCDGVW
_
_

Przykładowe dane:

Przykładowy wynik:
9RTQYCFQP[ PCM PKG LGUV NKVGTæ CNHCDGVW

Poni ej przedstawiono kilka innych wyników działania tego programu:

Uruchomienie 2
2TQUú YRTQYCFKè PCM #


Uruchomienie 3
2TQUú YRTQYCFKè PCM J

Dzięki konstrukcji else-if mo na rozszerzyć instrukcję warunkową o większą liczbę wa-
runków, na przykład:
KH
9CTWPGMA
+PUVTWMELCA
GNUG KH
9CTWPGMA
+PUVTWMELCA
GNUG KH
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
WUKPI 5[UVGO
RWDNKE ENCUU +H6GUV
]

]
%QPUQNG9TKVG
EJCT E
EJCT %QPUQNG4GCF

KH
%JCT+U7RRGT
E
%QPUQNG9TKVG.KPG
GNUG KH
%JCT+U.QYGT
E
%QPUQNG9TKVG.KPG
GNUG KH
%JCT+UKIKV
E
%QPUQNG9TKVG.KPG
9RTQYCFQPQ E[HTú
GNUG
%QPUQNG9TKVG.KPG
6Q PKG LGUV PCM CNHCPWOGT[EP[
_
_

Przykładowe dane
'

Przykładowy wynik:
2TQUú YRTQYCFKè PCM '

Uruchomienie 2
2TQUú YRTQYCFKè PCM G


Uruchomienie 3
9RTQYCFQPQ E[HTú

Uruchomienie 4
6Q PKG LGUV PCM CNHCPWOGT[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
]
ECUG Y[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ć


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
WUKPI 5[UVGO
ENCUU 5YKVEJ6GUV
]

]
%QPUQNG9TKVG.KPG
-CYC /C C TGFPKC W C
%QPUQNG9TKVG
2TQUú Y[DTCè MCYú
UVTKPI U %QPUQNG4GCF.KPG

KPV P KPV2CTUG
U
KPV EQUV
UYKVEJ
P
]
ECUG
ECUG
EQUV

DTGCM
ECUG
EQUV

IQVQ ECUG
ECUG
EQUV

IQVQ ECUG
FGHCWNV
%QPUQNG9TKVG.KPG
0KGRTCYKF QY[ Y[DÎT /Q PC Y[DTCè NWD
DTGCM
_
KH
EQUV
%QPUQNG9TKVG.KPG
2TQUú YTWEKè ]_ ITQU[ EQUV
%QPUQNG9TKVG.KPG
KúMWLGO[ C UMQT[UVCPKG PCUGL WU WIK
_
_

Przykładowe dane:


Przykładowy wynik
-CYC /C C TGFPKC W C
2TQUú Y[DTCè MCYú
2TQUú YTWEKè ITQU[
KúMWLGO[ C UMQT[UVCPKG PCUGL WU 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:
FQ KPUVTWMELC YJKNG
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.


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
WUKPI 5[UVGO
RWDNKE ENCUU 6GUVQ9JKNG
]

]
KPV Z
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
WUKPI 5[UVGO
ENCUU Q6GUV ]

]
KPV P
FQ
]
%QPUQNG9TKVG.KPG
9CTVQ è OKGPPGL P Y[PQUK ]_ P
P


_ YJKNG
P
_
_

Wynik
9CTVQ è OKGPPGL P Y[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
]


_

Przykład
KPUVTWMELGAHQTEU
RúVNC HQT
WUKPI 5[UVGO
RWDNKE ENCUU (QT.QQR6GUV
]

]
HQT
KPV K K K

%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[R KFGPV[HKMCVQT KP Y[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


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[UVCPKG HQTGCEJ VCDNKECOK
WUKPI 5[UVGO
ENCUU /CKP%NCUU
]

]
KPV QFF GXGP
KPV=? CTT PGY KPV =? ]_

HQTGCEJ
KPV K KP CTT
]
KH
K
GXGP

GNUG
QFF

_

%QPUQNG9TKVG.KPG
PCNGKQPQ ]_ NKED PKGRCT[UV[EJ K ]_ NKED RCT[UV[EJ
QFF GXGP
_
_

Wynik
PCNGKQPQ NKED RCT[UV[EJ K NKED RCT[UV[EJ

Zobacz tak e:
foreach, in (strona 65); Tablice (strona 245).


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'NGOGPVW GNGOGPV KP /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 W tym przykładzie utworzono kolekcję zgodnie
napisanych w języku C#. z powy szymi zaleceniami.
Przykład 2a kolekcję W tym przykładzie utworzono kolekcję zgodnie
ogólnodostępną. z powy szymi zaleceniami oraz zaimplementowano
interfejsy +'PWOGTCDNG i +'PWOGTCVQT.
Przykład 2b kolekcję ogólnodostępną Jest to kolekcja podobna do zdefiniowanej
zawierającą metodę w przykładzie 2a (ró nica polega na zastosowaniu
KURQUG. w wyliczeniu zdefiniowanym przez u ytkownika
metody KURQUG, odziedziczonej z interfejsu
+KURQUCDNG).
Przykład 3 wykorzystanie jednej W tym przykładzie utworzono egzemplarz tablicy
z predefiniowanych mieszającej (za pomocą klasy *CUJVCDNG), której


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[UVCPKG HQTGCEJ MQNGMELæ FNC %
WUKPI 5[UVGO

GMNCTCELC MQNGMELK
RWDNKE ENCUU /[%QNNGEVKQP
]
KPV=? KVGOU

RWDNKE /[%QNNGEVKQP

]
KVGOU PGY KPV=? ] _
_

RWDNKE /['PWOGTCVQT )GV'PWOGTCVQT

]
TGVWTP PGY /['PWOGTCVQT
VJKU
_

GMNCTCELC MNCU[ Y[NKEGPKC
RWDNKE ENCUU /['PWOGTCVQT
]
KPV P+PFGZ
/[%QNNGEVKQP EQNNGEVKQP
RWDNKE /['PWOGTCVQT
/[%QNNGEVKQP EQNN
]
EQNNGEVKQP EQNN
P+PFGZ
_

RWDNKE DQQN /QXG0GZV

]
P+PFGZ

TGVWTP
P+PFGZ EQNNGEVKQPKVGOU)GV.GPIVJ

_

RWDNKE KPV %WTTGPV
]
IGV
]
TGVWTP
EQNNGEVKQPKVGOU=P+PFGZ?
_
_
_
_



]

]
/[%QNNGEVKQP EQN PGY /[%QNNGEVKQP

%QPUQNG9TKVG.KPG
9CTVQ EK Y MQNGMELK

9[ YKGVNGPKG GNGOGPVÎY MQNGMELK
HQTGCEJ
KPV K KP EQN
]
%QPUQNG9TKVG.KPG
K
_
_
_

Wynik
9CTVQ EK Y MQNGMELK

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[UVCPKG HQTGCEJ QIÎNPQFQUVúRPæ MQNGMELæ
WUKPI 5[UVGO
WUKPI 5[UVGO%QNNGEVKQPU

GMNCTCELC MQNGMELK K KORNGOGPVCELC KPVGTHGLUW +'PWOGTCDNG
RWDNKE ENCUU /[%QNNGEVKQP +'PWOGTCDNG
]
KPV=? KVGOU
RWDNKE /[%QNNGEVKQP

]
KVGOU PGY KPV=? ] _
_


]
VJKU
_

+ORNGOGPVCELC OGVQF[ )GV'PWOGTCVQT

+'PWOGTCVQT +'PWOGTCDNG)GV'PWOGTCVQT

]
TGVWTP )GV'PWOGTCVQT

_

GMNCTCELC Y[NKEGPKC K KORNGOGPVCELC KPVGTHGLUW +'PWOGTCVQT
RWDNKE ENCUU /['PWOGTCVQT +'PWOGTCVQT


]
KPV P+PFGZ
RWDNKE /['PWOGTCVQT
/[%QNNGEVKQP EQNN
]
EQNNGEVKQP EQNN
P+PFGZ
_

RWDNKE XQKF 4GUGV

]
P+PFGZ
_

]
P+PFGZ

TGVWTP

_

RWDNKE KPV %WTTGPV
]
IGV
]
TGVWTP
_
_

9 C EKYQ è %WTTGPV KPVGTHGLUW +'PWOGTCVQT
QDLGEV +'PWOGTCVQT%WTTGPV
]
IGV
]
TGVWTP
%WTTGPV
_
_
_
_

]
UVTKPI =? CTIU
]

%QPUQNG9TKVG.KPG
9CTVQ EK Y MQNGMELK

HQTGCEJ
KPV K KP EQN
]
%QPUQNG9TKVG.KPG
K
_
_
_

Wynik
9CTVQ EK Y MQNGMELK


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[UVCPKG HQTGCEJ MQNGMELC QIÎNPQFQUVúRPæ
WUKPI 5[UVGO

GMNCTCELC MQNGMELK K KORNGOGPVCELC KPVGTHGLUW +'PWOGTCDNG
RWDNKE ENCUU /[%QNNGEVKQP +'PWOGTCDNG
]
KPV=? KVGOU
RWDNKE /[%QNNGEVKQP

]
KVGOU PGY KPV=? ] _
_


]
VJKU
_

+ORNGOGPVCELC OGVQF[ )GV'PWOGTCVQT

+'PWOGTCVQT +'PWOGTCDNG)GV'PWOGTCVQT

]
TGVWTP )GV'PWOGTCVQT

_

GMNCTCELC Y[NKEGPKC K KORNGOGPVCELC KPVGTHGLUÎY +'PWOGTCVQT
K +KURQUCDNG
RWDNKE ENCUU /['PWOGTCVQT +'PWOGTCVQT +KURQUCDNG
]
KPV P+PFGZ
RWDNKE /['PWOGTCVQT
/[%QNNGEVKQP EQNN
]
EQNNGEVKQP EQNN
P+PFGZ
_

RWDNKE XQKF 4GUGV

]
P+PFGZ
_

]


P+PFGZ

TGVWTP

_

RWDNKE KPV %WTTGPV
]
IGV
]
TGVWTP
_
_

9 C EKYQ è %WTTGPV KPVGTHGLUW +'PWOGTCVQT
QDLGEV +'PWOGTCVQT%WTTGPV
]
IGV
]
TGVWTP
%WTTGPV
_
_

RWDNKE XQKF KURQUG

]
%QPUQNG9TKVG.KPG
GTQYCPKG MQNGMELK
EQNNGEVKQP PWNN
_
_
_

]
UVTKPI =? CTIU
]

%QPUQNG9TKVG.KPG
9CTVQ EK Y MQNGMELK

HQTGCEJ
KPV K KP EQN
]
%QPUQNG9TKVG.KPG
K
_
_
_

Wynik
9CTVQ EK Y MQNGMELK

GTQYCPKG MQNGMELK


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[UVCPKG MNCU[ MQNGMELK *CUJVCDNG
WUKPI 5[UVGO
]
UVTKPI =? CTIU
]
GMNCTCELC QDKGMVW MNCU[ *CUJVCDNG
*CUJVCDNG KRJCUJ PGY *CUJVCDNG

QFCPKG GNGOGPVÎY C RQOQEæ OGVQF[ #FF

KRJCUJ#FF
$GNNGXWG
KRJCUJ#FF
4GFOQPF
KRJCUJ#FF
'XGTGVV
KRJCUJ#FF
5GCVVNG
KRJCUJ#FF
2W[CNNWR

9[ YKGVNGPKG CYCTVQ EK VCDNKE[ OKGUCLæEGL
%QPUQNG9TKVG.KPG
-QF RQEVQY[ /KCUVQ
HQTGCEJ
UVTKPI KR KP KRJCUJ-G[U
]
%QPUQNG9TKVG.KPG
KR

KRJCUJ=KR?
_
_
_

Wynik
-QF RQEVQY[ /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:


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

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
WUKPI 5[UVGO
ENCUU 9JKNG6GUV
]

]
KPV P

YJKNG
P
]
%QPUQNG9TKVG.KPG
#MVWCNPC YCTVQ è P Y[PQUK ]_ P
P

_
_
_

Wynik
#MVWCNPC YCTVQ è P Y[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


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
WUKPI 5[UVGO
ENCUU $TGCM6GUV
]

]
HQT
KPV K K K

]
KH
K
DTGCM
%QPUQNG9TKVG.KPG
K
_
_
_

Wynik

Przykład

W tym przykładzie zastosowano instrukcję break wewnątrz instrukcji switch.
KPUVTWMELGADTGCMEU
DTGCM K UYKVEJ
WUKPI 5[UVGO
ENCUU 5YKVEJ
]

]
%QPUQNG9TKVG
9RTQYCF NWD

KPV P +PV2CTUG
U


UYKVEJ
P
]
ECUG
%QPUQNG9TKVG.KPG
#MVWCNPC YCTVQ è Y[PQUK ]_
DTGCM
ECUG
%QPUQNG9TKVG.KPG
DTGCM
ECUG
%QPUQNG9TKVG.KPG
DTGCM
FGHCWNV
%QPUQNG9TKVG.KPG
9RTQYCFQPQ PKGRTCYKF QYæ YCTVQ è
DTGCM
_
_
_

Wprowadzając:

Przykładowy wynik
9RTQYCF NWD
#MVWCNPC YCTVQ è Y[PQUK

Jeśli wprowadzimy wartość 4, wówczas otrzymamy:
9RTQYCF NWD
9RTQYCFQPQ PKGRTCYKF 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
WUKPI 5[UVGO
ENCUU %QPVKPWG6GUV
]

]
HQT
KPV K K K

]


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:
IQVQ KFGPV[HKMCVQT
IQVQ ECUG Y[TC GPKGUVC G
IQVQ FGHCWNV

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


CIPKG F QPG RúVNG U W æEG FQ RTGUWMKYCPKC CYCTVQ EK VCDNKE[
WUKPI 5[UVGO
RWDNKE ENCUU )QVQ6GUV
]

]
KPV Z [
KPV=? O[#TTC[ PGY KPV=Z[?

KPKELCNKCELC VCDNKE[
HQT
KPV K K Z K

HQT
KPV L L [ L

O[#TTC[=KL?

K
1FE[V YRTQYCFQPGL RTG W [VMQYPKMC YCTVQ EK
%QPUQNG9TKVG
9RTQYCF NKEDú MVÎTæ PCNG [ PCNG è

YRTQYCFGPKG PCMW

KPV O[0WODGT +PV2CTUG
U

2TGUWMKYCPKG VCDNKE[ FYWY[OKCTQYGL
HQT
KPV K K Z K

HQT
KPV L L [ L

KH
O[#TTC[=KL? O[0WODGT
IQVQ (QWPF

%QPUQNG9TKVG.KPG
.KED[ ]_ PKG PCNGKQPQ O[0WODGT
IQVQ (KPKUJ
(QWPF
%QPUQNG9TKVG.KPG
.KEDC ]_ QUVC C PCNGKQPC O[0WODGT

(KPKUJ
%QPUQNG9TKVG.KPG
2TGUWMKYCPKG CMQ EQPG
_
_

Źródło

Przykładowy wynik
9RTQYCF NKEDú MVÎTæ PCNG [ PCNG è
.KEDC QUVC C PCNGKQPC
2TGUWMKYCPKG CMQ EQPG

Przykład
KPUVTWMELGAIQVQEU
9[UVæRK D æF Q PWOGTG %5 DQ
GV[MKGV[ PCLFWLæ UKú RQC CUKúIKGO
WUKPI 5[UVGO
ENCUU 7PTGCEJCDNG%QFG
]

]
KPV Z


%QPUQNG9TKVG.KPG
Z ]_ Z

KH
Z
]
Z
IQVQ # $ æF
_

Z Z

HQT
KPV K K K

]
# %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:
0Q UWEJ NCDGN # YKVJKP VJG UEQRG QH VJG IQVQ UVCVGOGPV

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
KPV K K K

] 6GTC DúFKG OQ PC UMQORKNQYCè 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
KPV T zwraca wartość pola powierzch-
ni koła za pomocą zmiennej CTGC typu double.
KPUVTWMELGATGVWTPEU
WUKPI 5[UVGO


ENCUU 4GVWTP6GUV
]
UVCVKE FQWDNG %CNEWNCVG#TGC
KPV T
]
FQWDNG CTGC
CTGC T

/CVJ2+
TGVWTP CTGC
_


]
KPV TCFKWU
%QPUQNG9TKVG.KPG
2QNG RQYKGTEJPK Y[PQUK ]_ %CNEWNCVG#TGC
TCFKWU
_
_

Wynik
2QNG RQYKGTEJPK Y[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.


Uwagi

Zgłoszony wyjątek jest obiektem klasy pochodnej względem System.Exception, na
przykład:
ENCUU /['ZEGRVKQP 5[UVGO'ZEGRVKQP ]_
VJTQY PGY /['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 CF W [EKC KPUVTWMELK VJTQY
WUKPI 5[UVGO
RWDNKE ENCUU 6JTQY6GUV
]

]
UVTKPI U PWNN

KH
U PWNN
]
VJTQY
PGY #TIWOGPV0WNN'ZEGRVKQP

_

%QPUQNG9TKVG
9 OKGPPGL U V[RW 5VTKPI PCLFWLG UKú YCTVQ è PWNN
å KPUVTWMELC PKG QUVCPKG Y[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


VT[ DNQMVT[ ECVEJ DNQMECVEJ

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 wyjątku
lub do chwili pomyślnego wykonania całego bloku blok-try. Na przykład w poni szy
fragment jest próbą konwersji jawnej obiektu null w wartość zmiennej typu int, która
zakończy się wystąpieniem wyjątku NullReferenceException:
QDLGEV Q PWNN
VT[
]
KPV K
KPV Q $ æF
_

Klauzula catch mo e być wykorzystana bez argumentów. Przechwytuje ona wówczas
wyjątek ka dego typu. Taką klauzulę nazywamy ogólną klauzulą catch. Klauzuli catch
mo na tak e przekazać argument odziedziczony po klasie System.Exception, wówczas
klauzula zawiera kod obsługi określonego wyjątku, na przykład:
ECVEJ
+PXCNKF%CUV'ZEGRVKQP G
]
_

W jednej instrukcji try-catch mo na wykorzystać kilka klauzuli catch, przeznaczonych
do przechwytywania określonych wyjątków. Jeśli instrukcja zawiera kilka klauzuli catch,
nale y umieścić je w odpowiednim porządku, bo w trakcie wystąpienia wyjątku klau-
zule catch są sprawdzane po kolei. Bardziej specyficzne wyjątki powinny być wychwy-
tywane wcześniej od wyjątków ogólnych.

W bloku catch mo na wykorzystać instrukcję throw. Wykorzystanie tej instrukcji
umo liwia ponowne zgłoszenie wyjątku, który wcześniej został przechwycony przez
daną instrukcję catch, na przykład:
ECVEJ
+PXCNKF%CUV'ZEGRVKQP G
]
VJTQY
G 2QPQYPG I QUGPKG Y[LæVMW G
_


Jeśli chcemy zgłosić wyjątek, który właśnie jest obsługiwany w bezparametrowym blo-
ku catch, mo emy u yć instrukcji throw nie zawierającej argumentów, na przykład:
ECVEJ
]
VJTQY
_

Nie nale y inicjować zmiennych wewnątrz bloku try, poniewa nie ma pewności, e
blok ten zostanie w całości wykonany w trakcie działania programu. Wyjątek mo e
wystąpić przed wykonaniem wszystkich instrukcji znajdujących się w danym bloku.
Przykładem jest poni szy fragment kodu źródłowego, w którym następuje inicjalizacja
zmiennej Z wewnątrz bloku try. Próba wykorzystania tej zmiennej na zewnątrz bloku
try w instrukcji 9TKVG
Z spowoduje wystąpienie błędu podczas kompilacji:
7UG QH WPCUUKIPGF NQECN XCTKCDNG

co oznacza, e nastąpiła próba wykorzystania zmiennej lokalnej, której nie przypisano
adnej wartości.

]
KPV Z
VT[
]
Z 6CM PKG PCNG [ TQDKè

_
ECVEJ
]

_
%QPUQNG9TKVG
Z $ æF 7UG QH WPCUUKIPGF NQECN XCTKCDNG Z
_

Więcej informacji na temat bloku catch znajduje się w punkcie „try-catch-finally” na
stronie 86.

Przykład

W niniejszym przykładzie w bloku try wywoływana jest metoda /[(P
, która mo e
spowodować wystąpienie wyjątku. Klauzula catch zawiera kod obsługi wyjątku, które-
go zadaniem jest wyświetlenie komunikatu na ekranie. Gdy wewnątrz metody /[(P

wywoływana jest instrukcja throw, następuje poszukiwanie sekcji catch, w której znaj-
duje się odpowiedni kod obsługi wyjątku. Na ekranie pojawi się komunikat 9[LæVGM
RTGEJY[EQP[.
2QPQYPG I CUCPKG Y[LæVMÎY
WUKPI 5[UVGO
ENCUU /[%NCUU
]

]
/[%NCUU Z PGY /[%NCUU

VT[
]


UVTKPI U PWNN
Z/[(P
U
_

ECVEJ
'ZEGRVKQP G
]
%QPUQNG9TKVG.KPG
]_ 9[LæVGM RTGEJY[EQPQ G
_
_

RWDNKE XQKF /[(P
UVTKPI U
]
KH
U PWNN
VJTQY
PGY #TIWOGPV0WNN'ZEGRVKQP

_
_

Wynik

Podczas wykonywania programu wystąpi wyjątek:

Przykład

W poni szym przykładzie wykorzystano dwie instrukcje catch. W pierwszej kolejności
umieszczono blok obsługi najbardziej specyficznego wyjątku.
7RQTæFMQYCPG MNCWWNG ECVEJ
WUKPI 5[UVGO
ENCUU /[%NCUU
]

]
/[%NCUU Z PGY /[%NCUU

VT[
]
UVTKPI U PWNN
Z/[(P
U
_

0CLDCTFKGL UEGIÎNP[ Y[LæVGM
ECVEJ
#TIWOGPV0WNN'ZEGRVKQP G
]
%QPUQNG9TKVG.KPG
]_ 2TGEJY[EQPQ RKGTYU[ Y[LæVGM G
_

0CLDCTFKGL QIÎNP[ Y[LæVGM
ECVEJ
'ZEGRVKQP G
]
%QPUQNG9TKVG.KPG
]_ 2TGEJY[EQPQ FTWIK Y[LæVGM G
_

_

RWDNKE XQKF /[(P
UVTKPI U
]
KH
U PWNN


VJTQY PGY #TIWOGPV0WNN'ZEGRVKQP

_
_

Wynik
Podczas wykonywania programu wystąpi wyjątek:

Gdybyśmy umieścili klauzule catch w odwrotnej kolejności, w trakcie wykonywania
programu wystąpiłby błąd:
# RTGXKQWU ECVEJ ENCWUG CNTGCF[ ECVEJGU CNN GZEGRVKQPU QH VJKU QT C UWRGT V[RG
å
5[UVGO'ZEGRVKQP

który oznacza, e poprzednia klauzula catch (w naszym przypadku pierwsza) prze-
chwytuje wszystkie wyjątki typu 5[UVGO'ZEGRVKQP (lub typu pochodnego).

Aby wychwycić najbardziej ogólny wyjątek, zamiast instrukcji throw nale y umieścić:
VJTQY PGY 'ZEGRVKQP

Zobacz tak e:
throw (strona 80), try-finally (strona 85).

try-finally
Blok finally jest u yteczny, gdy istnieje potrzeba zwolnienia zasobów przydzielonych
w bloku try. Jest to spowodowane tym, e sterowanie zawsze jest przekazywane do
bloku finally, niezale nie od wykonania bloku try. Instrukcja try-finally ma postać:
VT[ DNQMVT[ HKPCNN[ DNQMHKPCNN[

gdzie:
blok-try
Zawiera fragment kodu, w którym mo e wystąpić wyjątek.
blok-finally
Zawiera kod obsługi wyjątku i kod porządkujący system.

Uwagi

Klauzula catch słu y do przechwytywania określonych wyjątków. Kod zawarty w blo-
ku catch jest wykonywany tylko wtedy, gdy dany wyjątek wystąpi. Instrukcja finally
obejmuje blok kodu źródłowego, który jest wykonywany niezale nie od wystąpienia ja-
kichkolwiek wyjątków w bloku try.

Przykład

W poni szym przykładzie umieszczono instrukcję dokonującą nieprawidłowej konwer-
sji, która powoduje wystąpienie wyjątku. Po uruchomieniu programu na ekranie pojawi


się komunikat o wystąpieniu błędu, a następnie, po umieszczeniu instrukcji w bloku fi-
nally, zostanie wyświetlony wynik działania.
VT[HKPCNN[
WUKPI 5[UVGO
RWDNKE ENCUU 6GUV6T[(KPCNN[
]

]
KPV K
UVTKPI U C EWEJ PCMÎY
QDLGEV Q U

VT[
]
CDTQPKQPC MQPYGTULC Q CYKGTC C EWEJ PCMÎY C PKG YCTVQ è V[RW KPV
K
KPV Q
_

HKPCNN[
]
%QPUQNG9TKVG
K ]_ K
_
_
_

Wynik

Podczas działania programu wystąpi następujący wyjątek:
5[UVGO+PXCNKF%CUV'ZEGRVKQP

Pomimo wystąpienia, przechwycenia i obsługi wyjątku, na ekranie pojawi się wartość
zmiennej K po umieszczeniu w bloku finally instrukcji wyświetlającej tą wartość.
K

Więcej informacji na temat słowa kluczowego finally znajduje się w punkcie „try-
catch-finally”.

Zobacz tak e:
throw (strona 80), try-catch (strona 81).

try-catch-finally
Instrukcje catch i finally najczęściej są stosowane razem w celu rezerwacji i wykorzy-
stania zasobów w bloku try, przechwycenia i obsługi ewentualnych wyjątków za po-
mocą klauzuli catch, a tak e w celu zwolnienia zasobów w bloku finally.

Przykład
VT[ECVEJHKPCNN[
WUKPI 5[UVGO
RWDNKE ENCUU '*%NCUU
]



]
VT[
]
%QPUQNG9TKVG.KPG
9[MQP[YCPKG KPUVTWMELK DNQMW VT[
VJTQY PGY 0WNN4GHGTGPEG'ZEGRVKQP

_

ECVEJ
0WNN4GHGTGPEG'ZEGRVKQP G
]
%QPUQNG9TKVG.KPG
]_ 2TGEJY[EQPQ Y[LæVGM G
_

ECVEJ
]
%QPUQNG9TKVG.KPG
2TGEJY[EQPQ Y[LæVGM
_

HKPCNN[
]
%QPUQNG9TKVG.KPG
9[MQP[YCPKG DNQMW HKPCNN[
_
_
_

Wynik
9[MQP[YCPKG KPUVTWMELK DNQMW VT[
5[UVGO0WNN4GHGTGPEG'ZEGRVKQP #VVGORVGF VQ FGTGHGTGPEG C PWNN QDLGEV TGHGTGPEG
CV '*%NCUU/CKP
2TGEJY[EQPQ Y[LæVGM
9[MQP[YCPKG DNQMW HKPCNN[

Zobacz tak e:
throw (strona 80).

Instrukcje checked i unchecked
Instrukcje języka C# mogą być wykonywane w kontekście z kontrolą przepełnienia
arytmetycznego (checked) lub bez takiej kontroli (unchecked). W trybie checked
przepełnienie arytmetyczne powoduje wystąpienie wyjątku. W trybie unchecked prze-
pełnienie arytmetyczne jest ignorowane przez kompilator, a wynik operacji jest dosto-
sowany do typu zmiennej.
EJGEMGF — określa kontekst kontrolowany,
WPEJGEMGF — określa kontekst niekontrolowany.

Jeśli w stosunku do danego bloku instrukcji nie u yjemy ani checked, ani unchecked,
wówczas domyślny kontekst zale y od czynników zewnętrznych, takich jak np. para-
metry kompilatora.

Kontekst kontroli przepełnienia dotyczy następujących operacji:


Wyra enia wykorzystujące predefiniowane operatory w stosunku do typów
całkowitych:

(jednoargumentowe)

Jawne przekształcenia liczbowe pomiędzy typami całkowitymi.

Opcja kompilatora /checked umo liwia określenie kontekstu kontroli przepełnienia dla
wszystkich instrukcji arytmetycznych, które nie znajdują się jawnie w zasięgu działania
słowa kluczowego checked lub unchecked.

checked
Słowo kluczowe checked słu y do sterowania kontrolą przepełnienia podczas działań
arytmetycznych i przekształceń typów całkowitych. Słowo kluczowe checked jest wy-
korzystywane jako operator lub instrukcja.

Instrukcja checked:
EJGEMGF DNQM

Operator checked:
EJGEMGF
Y[TC GPKG

gdzie:
blok
Blok instrukcji zawierający wyra enia wyliczane w kontekście kontrolowanym.
wyra enie
Wyra enie wyliczane w kontekście kontrolowanym. Nale y zauwa yć,
e wyra enie musi być umieszczone w nawiasach okrągłych.

Uwagi

Jeśli w wyniku obliczenia wyra enia w kontekście kontrolowanym powstanie wartość
wykraczająca poza zakres typu docelowego, wynik zale y od tego, czy dane wyra enie
jest stałe, czy nie ma ono stałej wartości. W przypadku wyra eń stałych wystąpi błąd
w trakcie kompilacji, a wyra enia nie mające stałej wartości spowodują wystąpienie wy-
jątku w trakcie działania programu.

Jeśli określone wyra enie nie jest oznaczone jako checked lub unchecked, to w przy-
padku wyra enia stałego domyślnie przeprowadzana jest kontrola przepełnienia w trak-
cie kompilacji, co oznacza, e u ywany jest operator checked. Gdy wyra enie nie ma
stałej wartości, kontrola przepełnienia zale y od czynników zewnętrznych, takich jak
opcje kompilatora czy konfiguracja środowiska.

Poni ej przedstawiono trzy przykłady pokazujące zastosowanie operatorów checked
i unchecked w stosunku do wyra eń nie mających wartości stałej. We wszystkich przy-
kładach posłu ono się tym samym algorytmem, ale innymi kontekstami kontroli. Kon-
trola przepełnienia następuje w trakcie działania programu.


Przykład 1: Wykorzystanie wyra enia z operatorem checked.
Przykład 2: Wykorzystanie wyra enia z operatorem unchecked.
Przykład 3: Wykorzystanie domyślnego operatora przepełnienia.

Tylko w pierwszym przykładzie wystąpi wyjątek przepełnienia w trakcie działania pro-
gramu i w tym wypadku będziemy mieli do wyboru przerwanie wykonywania progra-
mu lub przejście w tryb poprawiania i kontroli przebiegu programu (debugging mode).
W dwóch pozostałych przykładach otrzymamy wartości „przycięte”.

Inne przykłady znajdują się w punkcie poświęconym instrukcji unchecked.

Przykład 1
KPUVTWMELGAEJGEMGFEU
2TGRG PKGPKG Y[TC GPKC PKGUVC GIQ LGUV MQPVTQNQYCPG Y VTCMEKG FKC CPKC RTQITCOW
WUKPI 5[UVGO
ENCUU 1XGT(NQY6GUV
]
UVCVKE UJQTV Z /CMU[OCNPC YCTVQ è V[RW UJQTV
UVCVKE UJQTV [

9[MQT[UVCPKG QRGTCVQTC EJGEMGF
RWDNKE UVCVKE KPV O[/GVJQF%J

]
KPV

VT[
]
EJGEMGF

UJQTV
Z
[
_
ECVEJ
5[UVGO1XGTHNQY'ZEGRVKQP G
]
5[UVGO%QPUQNG9TKVG.KPG
G6Q5VTKPI

_
TGVWTP I QUGPKG Y[LæVMW 1XGTHNQY'ZEGRVKQP
_


]
%QPUQNG9TKVG.KPG
-QPVTQNQYCPC YCTVQ è Y[PKMQYC Y[PQUK ]_ O[/GVJQF%J

_
_

Przykładowy wynik

Po uruchomieniu programu wystąpi wyjątek 1XGTHNQY'ZEGRVKQP. Mo na albo debugo-
wać program, albo przerwać jego wykonywanie.
5[UVGO1XGTHNQY'ZEGRVKQP #P GZEGRVKQP QH V[RG 5[UVGO1XGTHNQY'ZEGRVKQP YCU VJTQYP
CV 1XGT(NQY6GUVO[/GVJQF%J

-QPVTQNQYCPC YCTVQ è Y[PKMQYC Y[PQUK

Przykład 2


9[MQT[UVCPKG QRGTCVQTC WPEJGEMGF
WUKPI 5[UVGO

ENCUU 1XGT(NQY6GUV
]
UVCVKE UJQTV [

RWDNKE UVCVKE KPV O[/GVJQF7PEJ

]
KPV WPEJGEMGF

UJQTV
Z
[
TGVWTP YTCEC
_


]
%QPUQNG9TKVG.KPG
9CTVQ è PKGMQPVTQNQYCPC Y[PQUK ]_ O[/GVJQF7PEJ

_
_

Wynik
9CTVQ è PKGMQPVTQNQYCPC Y[PQUK

Przykład 3
9[MQT[UVCPKG FQO[ NPGL MQPVTQNK RTGRG PKGPKC
WUKPI 5[UVGO

ENCUU 1XGT(NQY6GUV
]
UVCVKE UJQTV [

RWDNKE UVCVKE KPV O[/GVJQF7PEJ

]
KPV
UJQTV
Z
[
TGVWTP YTCEC
_


]
%QPUQNG9TKVG.KPG
9[PKMQYC YCTVQ è Y[PQUK ]_ O[/GVJQF7PEJ

_
_

Wynik
9[PKMQYC YCTVQ è Y[PQUK

Zobacz tak e:
unchecked


unchecked
Słowo kluczowe unchecked słu y do sterowania kontrolą przepełnienia podczas dzia-
łań arytmetycznych i przekształceń typów całkowitych. Słowo kluczowe unchecked
jest wykorzystywane jako operator lub instrukcja.

Instrukcja unchecked:
WPEJGEMGF DNQM

Operator unchecked:
WPEJGEMGF
Y[TC GPKG

gdzie:
blok
Blok instrukcji zawierający wyra enia wyliczane w kontekście niekontrolowanym.
wyra enie
Wyra enie wyliczane w kontekście niekontrolowanym. Nale y zauwa yć,
e wyra enie musi być umieszczone w nawiasie okrągłym.

Uwagi

Jeśli w wyniku obliczenia wyra enia w kontekście niekontrolowanym powstanie war-
tość wykraczająca poza zakres typu docelowego, wartość ta jest przycinana.

Jeśli określone wyra enie nie jest oznaczone jako checked lub unchecked, to w przy-
padku wyra enia stałego domyślnie przeprowadzana jest kontrola przepełnienia w trak-
cie kompilacji, co oznacza, e u ywany jest operator checked. Gdy wyra enie nie ma
stałej wartości, kontrola przepełnienia zale y od czynników zewnętrznych, takich jak
opcje kompilatora czy konfiguracja środowiska.

Poni ej przedstawiono trzy przykłady pokazujące zastosowanie operatorów checked
i unchecked w stosunku do wyra eń nie mających wartości stałej. We wszystkich przy-
kładach posłu ono się tym samym algorytmem, ale innymi kontekstami kontroli. Kon-
trola przepełnienia następuje w trakcie działania programu.
Przykład 1: Wykorzystanie wyra enia z operatorem unchecked.
Przykład 2: Wykorzystanie domyślnego operatora przepełnienia.
Przykład 3: Wykorzystanie wyra enia z operatorem checked.

Tylko w pierwszym przykładzie otrzymamy w wyniku „obciętą” wartość. W dwóch po-
zostałych wystąpi błąd podczas kompilacji.

Inne przykłady znajdują się w punkcie poświęconym instrukcji checked.

Przykład 1
KPUVTWMELGAWPEJGEMGFEU
9[MQT[UVCPKG KPUVTWMELK WPEJGEMGF Y[TC GPKGO UVC [O


2TGRG PKGPKG LGUV URTCYFCPG Y VTCMEKG MQORKNCELK RTQITCOW
WUKPI 5[UVGO

ENCUU 6GUV%NCUU
]
EQPUV KPV Z /CMU[OCNPC YCTVQ è V[RW KPV
EQPUV KPV [

RWDNKE KPV /GVJQF7P%J

]
+PUVTWMELC WPEJGEMGF
WPEJGEMGF
]
KPV Z

[
TGVWTP YTCEC
_
_


]
6GUV%NCUU O[1DLGEV PGY 6GUV%NCUU

%QPUQNG9TKVG.KPG
9[PKMQYC YCTVQ è PKGMQPVTQNQYCPC Y[PQUK ]_
O[1DLGEV/GVJQF7P%J

_
_

Wynik
9[PKMQYC YCTVQ è PKGMQPVTQNQYCPC Y[PQUK

Przykład 2
KPUVTWMELGAWPEJGEMGFEU
1EGMKYCP[ D æF Q PWOGTG%5
9[MQT[UVCPKG FQO[ NPGL MQPVTQNK RTGRG PKGPKC Y UVQUWPMW FQ Y[TC GPKC UVC GIQ
-QPVTQNC RTGRG PKGPKC PCUVúRWLG Y VTCMEKG MQORKNCELK
WUKPI 5[UVGO

ENCUU 6GUV%NCUU
]
EQPUV KPV Z /CMU[OCNPC YCTVQ è V[RW KPV
EQPUV KPV [

RWDNKE KPV /GVJQFGH

]
9[MQT[UVCPKG FQO[ NPGL MQPVTQNK RTGRG PKGPKC
KPV Z

Visual C# .NET. Encyklopedia

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (9)

Ähnlich wie Visual C# .NET. Encyklopedia

Ähnlich wie Visual C# .NET. Encyklopedia (19)

Mehr von Wydawnictwo Helion

Mehr von Wydawnictwo Helion (20)

Visual C# .NET. Encyklopedia