c# 3.0. leksykon kieszonkowy. wydanie ii

Wydawnictwo Helionul. Ko�ciuszki 1c44-100 Gliwicetel. 032 230 98 63e-mail: [email protected]

C# 3.0. Leksykonkieszonkowy. Wydanie IIAutor: Joseph Albahari, Ben AlbahariT³umaczenie: Przemys³aw SzeremiotaISBN: 978-83-246-1827-9Tytu³ orygina³u: C# 3.0 Pocket Reference:Instant Help for C# 3.0 Programmers, 2nd EditionFormat: 115x170, stron: 280

Poznaj nowo�ci jêzyka C# i podnie� wydajno�æ programowania

� Co nowego w C# 3.0? � Jak skróciæ i usprawniæ swój kod? � Do czego s³u¿y mechanizm LINQ?

C# jest obiektowym jêzykiem programowania zalecanym przez Microsoftdla platformy .NET Framework. Pozwala definiowaæ wiele ró¿norodnych elementów sk³adowych klas, nie tylko pola czy metody. Analiza struktury kodu umo¿liwia tworzenie wysoce uniwersalnych mechanizmów operuj¹cych na strukturze kodu nieznanejw czasie kompilacji. Wiedza programisty jest kluczem do wykorzystania wszystkich jego mo¿liwo�ci. Leksykon stanowi bogate kompendium nowych rozwi¹zañ dostêpnychw C# 3.0 oraz ich implementacji. Opisane zagadnienia, dotycz¹ce mechanizmu LINQ (Language Integrated Query), pozwalaj¹ na pozyskanie praktycznej wiedzy niezbêdnej we wspó³czesnym programowaniu. Ksi¹¿ka C# 3.0 Leksykon kieszonkowy. Wydanie II, poruszaj¹ca w sposób przejrzysty i rzeczowy ca³o�æ pojêciowych zmian koniecznychdo opanowania C#, jest idealn¹ pozycj¹ dla wszystkich programistów, którym nieobca jest Java, C++ lub poprzednie wersje C#.

Do najwa¿niejszych cech wyró¿niaj¹cych jêzyk C# w wydaniu 3.0 zaliczamy:

� wyra¿enia lambda, � metody rozszerzaj¹ce, � niejawne typowanie zmiennych lokalnych, � sk³adniê ujmowania zapytañ w kodzie, � typy anonimowe, � niejawne typowanie tablic, � inicjalizatory obiektów, � w³a�ciwo�ci automatyczne, � metody czê�ciowe, � drzewa wyra¿eñ.

Nie traæ czasu na szukanie informacji!Programuj wydajnie i efektywnie z kieszonkowym leksykonem!

http://helion.pl/view/2547w



http://helion.pl/add/2547w/cshlk2




mailto:[email protected]

http://helion.pl/view/2547w/cshlk2.htm

http://helion.pl/view/2547w/cshlk2.htm

3

Spis treści

Nowości w C# 3.0 ........................................................................11

Pierwszy program w C# ............................................................. 15Kompilacja 18

Składnia ...................................................................................... 19Identyfikatory i słowa kluczowe 20Literały, znaki interpunkcyjne i operatory 22Komentarze do kodu 23

System typów .............................................................................23Przykłady typów predefiniowanych 24Przykłady typów własnych 25Konwersje 29Typy wartościowe a typy referencyjne 30Taksonomia typów predefiniowanych 34

Typy liczbowe .............................................................................35Literały liczbowe 36Konwersje liczbowe 38Operatory arytmetyczne 40Operatory inkrementacji i dekrementacji 40Specjalizowane operacje na liczbach całkowitych 41Liczby całkowite 8- i 16-bitowe 43

4 | C# 3.0. Leksykon kieszonkowy

Wyróżnione wartości zmiennoprzecinkowe 43double kontra decimal 45Błędy zaokrąglania liczb rzeczywistych 46

Typ wartości logicznych i operatory logiczne ...........................47Operatory porównania i relacji 47Operatory logiczne 48

Znaki i ciągi znaków .................................................................. 49Konwersje znaków 50Typ string 51

Tablice .........................................................................................54Domyślna inicjalizacja elementów tablic 55Tablice wielowymiarowe 57Wyrażenia uproszczonej inicjalizacji tablic 58Kontrola zakresów 60

Zmienne i parametry .................................................................. 61Stos i sterta 61Przypisania oznaczone 63Wartości domyślne 64Parametry 64Niejawne typowanie zmiennych lokalnych (C# 3.0) (var) 69

Operatory i wyrażenia ...............................................................70Wyrażenia proste 71Wyrażenia bezwartościowe 71Wyrażenia przypisania 71Priorytety i łączność operatorów 72Tabela operatorów 73

Spis treści | 5

Instrukcje .................................................................................... 77Instrukcje deklaracji 77Instrukcje wyrażeniowe 78Instrukcje warunkowe 79Instrukcje iteracyjne 83Instrukcje skoku 86Inne instrukcje 88

Przestrzenie nazw ......................................................................89Dyrektywa using 90Reguły obowiązujące w przestrzeniach nazw 91Synonimy typów i przestrzeni nazw 93

Klasy ............................................................................................93Pola 94Metody 95Konstruktory instancji 96Inicjalizatory obiektów (C# 3.0) 98Referencja this 99Właściwości 100Indeksery 102Stałe 104Konstruktory statyczne 105Klasy statyczne 106Finalizatory 106Klasy i metody częściowe 107

Dziedziczenie ............................................................................ 108Polimorfizm 110Rzutowanie 110Wirtualne funkcje składowe 112Klasy i składowe abstrakcyjne 114Widoczność składowych dziedziczonych 114


Pieczętowanie funkcji i klas 115Słowo kluczowe base 116Konstruktory a dziedziczenie 117Przeciążanie a rozstrzyganie wywołań 118

Typ object ...................................................................................119Pakowanie i odpakowywanie 120Statyczna i dynamiczna kontrola typów 121Wykaz składowych klasy object 122Metoda GetType() i operator typeof 122Equals, ReferenceEquals i GetHashCode 123Metoda ToString 124

Struktury ................................................................................... 125Semantyka konstrukcji struktury 126

Modyfikatory dostępu .............................................................. 127Przykłady 128Narzucanie dostępności 128Ograniczenia modyfikatorów dostępu 129

Interfejsy ................................................................................... 129Rozszerzanie interfejsu 131Jawna implementacja interfejsu 131Wirtualne implementowanie składowych interfejsów 132Ponowna implementacja interfejsu w klasie pochodnej 133

Typy wyliczeniowe ................................................................... 135Konwersje typów wyliczeniowych 136Flagi 137Operatory typów wyliczeniowych 138

Spis treści | 7

Typy zagnieżdżone ................................................................... 139

Uogólnienia .............................................................................. 140Typy uogólnione 140Po co nam uogólnienia 142Metody uogólnione 143Deklarowanie parametrów uogólnienia 144Uogólnienia a typeof 145Domyślna wartość uogólnienia 146Ograniczenia uogólnień 146Uogólnienia i kowariancja 148Pochodne typów uogólnionych 149Deklaracje uogólnień z odwołaniami do siebie 150Dane statyczne 150Inicjalizowanie kolekcji uogólnionych 151

Delegaty .....................................................................................151Pisanie metod-wtyczek dla delegatów 153Delegaty wielokrotne 153Metody statyczne i metody instancji jako metody docelowe 155Uogólnione typy delegatów 155Zgodność delegatów 155

Zdarzenia .................................................................................. 157Standardowy schemat zdarzenia 159Akcesory zdarzenia 163Modyfikatory zdarzeń 164

Wyrażenia lambda (C# 3.0) ..................................................... 164Jawne określanie typów parametrów lambdy 166Uogólnione wyrażenia lambda i delegaty Func 166Zmienne zewnętrzne 167


Metody anonimowe ................................................................. 169

Wyjątki i instrukcja try ............................................................. 170Klauzula catch 173Blok finally 174Zgłaszanie wyjątków 176Najważniejsze właściwości klasy System.Exception 178Najczęstsze wyjątki 178

Enumeratory i iteratory ............................................................ 180Enumeracja 180Iteratory 181Semantyka iteratora 183Składanie sekwencji 184

Typy z dopuszczalną wartością pustą ..................................... 185Podstawy 185Pożyczanie operatorów 188Typ bool? 190Operator ?? 191

Przeciążanie operatorów ..........................................................191Funkcje operatorów 192Przeciążanie operatorów porównania i relacji 193Własne konwersje jawne i niejawne 194

Metody rozszerzające (C# 3.0) ................................................ 196Kaskadowe wywołania metod rozszerzających 197Niejednoznaczność i rozstrzyganie niejednoznaczności 197

Typy anonimowe (C# 3.0) ........................................................ 199

Spis treści | 9

LINQ (C# 3.0) ............................................................................200Podstawy LINQ 200Opóźnione wykonanie 205Standardowe operatory zapytań 207Kaskadowe operatory zapytań 213Składnia zapytań 214Słowo kluczowe let 218Kontynuacje zapytań 219Zapytania z wieloma generatorami 219Złączenia 221Porządkowanie 224Grupowanie 225Operatory OfType i Cast 228

Atrybuty ....................................................................................229Klasy atrybutów 229Parametry nazwane i pozycyjne 230Obiekt docelowy atrybutu 231Nadawanie wielu atrybutów 231Definiowanie własnych atrybutów 232Odwołania do atrybutów w czasie wykonania 233

Wskaźniki i kod nienadzorowany .......................................... 234Elementarz wskaźników 234Kod nienadzorowany 235Instrukcja fixed 235Operator dostępu do składowej przez wskaźnik 237Tablice 237Typ void* 238Wskaźniki do kodu nienadzorowanego 239


Dyrektywy preprocesora ..........................................................239Atrybuty warunkowe 241Ostrzeżenia i pragma 242

Dokumentacja XML ................................................................. 243Standardowe znaczniki dokumentacji XML 244

Przegląd infrastruktury i środowiska ......................................247Rdzeń infrastruktury 248Technologie interfejsu użytkownika 256Technologie zaplecza aplikacji 261Technologie systemów rozproszonych 263

Skorowidz .................................................................................267

11

C# 3.0.Leksykon kieszonkowy. Wydanie II

C# to obiektowy język programowania ogólnego przeznaczenia,z kontrolą typów, w którym największe znaczenie ma produk-tywność programisty. Aby ją zwiększyć, w języku należało zrów-noważyć prostotę, wyrazistość i wydajność. Język C# jest neutralnywobec platformy, ale najlepiej współpracuje z .NET Frameworkfirmy Microsoft. Dla C# w wersji 3.0 najodpowiedniejsza jest plat-forma .NET Framework 3.5.

Nowości w C# 3.0Nowości wprowadzone w C# 3.0 koncentrują się wokół mecha-nizmu integracji zapytań w kodzie — Language Integrated Query,w skrócie LINQ. Pozwala on na stosowanie zapytań w stylu SQLwprost w programie C#. Zapytania takie mają tę zaletę, że podlegająstatycznej kontroli poprawności. Mogą być wykonywane na zbio-rach lokalnych i zdalnych; platforma .NET Framework udostępniainterfejsy uwzględniające mechanizm lokalnych zapytań LINQdla wszelkich kolekcji, zdalnych baz danych oraz do plików XML.

Do najważniejszych cech wyróżniających język C# w wydaniu 3.0zaliczymy:

• wyrażenia lambda,

• metody rozszerzające,

• niejawne typowanie zmiennych lokalnych,

• składnię ujmowania zapytań w kodzie,


• typy anonimowe,

• niejawne typowanie tablic,

• inicjalizatory obiektów,

• właściwości automatyczne,

• metody częściowe,

• drzewa wyrażeń.

Wyrażenia lambda stanowią miniatury funkcji, definiowanych„w locie”, to jest w miejscu wystąpienia wyrażenia. Stanowią natu-ralne rozwinięcie metod anonimowych wprowadzonych do C# 2.0i w zasadzie całkowicie wypierają funkcjonalność metod anoni-mowych. Oto przykład:

Func<int,int> sqr = x => x * x;Console.WriteLine (sqr(3)); // 9

Najważniejszym zastosowaniem wyrażeń lambda w języku C#są zapytania LINQ, takie jak poniższe:

string[] names = { "Arek", "Ala", "Gosia" };

// Tylko imiona o długości >= 4 znaki

IEnumerable<string> filteredNames = Enumerable.Where (names, n => n.Length >= 4);

Metody rozszerzające służą do uzupełniania już istniejących typówo nowe metody, bez zmieniania pierwotnej definicji typu. Pełniąrolę skrótowca składniowego, ponieważ ich działanie sprowadzasię do upodobnienia wywołań metod statycznych do wywołańmetod na rzecz instancji. Ponieważ operatory LINQ są zaimple-mentowane właśnie jako metody rozszerzające, możemy poprzed-nie zapytanie uprościć do następującej postaci:

IEnumerable<string> filteredNames = names.Where (n => n.Length >= 4);

Nowości w C# 3.0 | 13

Niejawne typowanie zmiennych lokalnych to zezwolenie na pominięcietypu zmiennej w instrukcji deklaracji i zdanie się na wnioskowanietypu przez kompilator. Ponieważ kompilator potrafi samodzielnieokreślić typ zmiennej filteredNames, możemy nasze zapytanieuprościć jeszcze bardziej:

var filteredNames = names.Where (n => n.Length >= 4);

Składnia zapytania ujętego w kodzie służy do stosowania składni LINQupodobnionej do składni zapytań SQL zamiast zapytań konstru-owanych z wywołań operatorów. Dzięki temu znacząco upraszczasię zapis wielu rodzajów zapytań; ponownie mamy do czynieniaze skrótowcem składniowym, tym razem dla zamaskowanychwyrażeń lambda. Oto poprzedni przykład, przepisany z użyciemskładni ujęcia zapytania w kodzie:

var filteredNames = from n in names where n.Length >= 4 select n;

Typy anonimowe to proste klasy tworzone w locie, wykorzystywaneczęsto do reprezentowania wyników zapytań:

var query = from n in names where n.Length >= 4 select new { Name = n, Length = n.Length };

Oto prostszy przykład:

var dude = new { Name = "Robert", Age = 20 };

Niejawne typowanie tablic to mechanizm pozwalający na wyelimino-wanie obowiązku określania typu elementów tablicy przy kon-struowaniu i inicjalizowaniu tablicy za jednym zamachem:

var dudes = new[]{ new { Name = "Robert", Age = 20 } new { Name = "Roman", Age = 30 }};


Inicjalizatory obiektów upraszczają konstruowanie instancji klas,pozwalając na ustawienie właściwości już przy wywołaniu kon-struktora obiektu. Inicjalizatory obiektów można stosować z typamianonimowymi i z typami nazwanymi. Oto przykład:

Bunny b1 = new Bunny { Name = "Bo", LikesCarrots = true };

W języku C# w wydaniu 2.0 odpowiednikiem powyższego byłbytaki kod:

Bunny b2 = new Bunny();b2.Name = "Bo";b2.LikesCarrots = true;

Właściwości automatyczne oszczędzają pisania kodu właściwościsprowadzających się do prostych akcesorów ustawiających i od-czytujących wartość prywatnego pola docelowego. W poniższymprzykładzie kompilator automatycznie wygeneruje prywatne polei akcesory dla właściwości X:

public class Stock{ public decimal X { get; set; }}

Metody częściowe pozwalają w klasach generowanych automatyczniena dodawanie ręcznych uzupełnień. Mechanizm LINQ do SQLwykorzystuje metody częściowe dla generowanych klas odwzoro-wania tabel SQL.

Drzewa wyrażeń to miniaturowe obiektowe modele wyrażeń, opisu-jące wyrażenia lambda. Kompilator C# w wersji 3.0 generuje drzewowyrażenia dla każdego wyrażenia lambda przypisanego do instancjispecjalnego typu Expression<TDelegate>:

Expression<Func<string,bool>> predicate = s => s.Length > 10;

Pierwszy program w C# | 15

Drzewa wyrażeń pozwalają na zdalne (np. na serwerze baz danych)wykonywanie zapytań LINQ, bo są dostępne do refleksji i tłuma-czenia w czasie wykonania (można je więc tłumaczyć np. na za-pytania SQL).

Pierwszy program w C#Oto program wyliczający iloczyn 12 * 30 i wypisujący wynik (360)na konsoli. Podwójne znaki ukośników umieszczone w kodzieoznaczają, że reszta danego wiersza to komentarz do kodu:

using System; // Import przestrzeni nazw

class Test // Deklaracja klasy{ static void Main() // Deklaracja metody w klasie { int x = 12 * 30; // Instrukcja (1) Console.WriteLine (x); // Instrukcja (2) } // Koniec metody} // Koniec klasy

Sedno tego programu tkwi w dwóch instrukcjach. Instrukcje w językuC# są wykonywane sekwencyjnie (jedna po drugiej). Każda instruk-cja kończy się znakiem średnika:

int x = 12 * 30; Console.WriteLine (x);

Pierwsza z tych instrukcji oblicza wartość wyrażenia 12 * 30 i zapi-suje ustalony wynik w zmiennej lokalnej o nazwie x, typu całko-witego. Druga instrukcja wywołuje metodę WriteLine z klasyConsole; metoda ta wypisuje wartość zmiennej x na konsolę,czyli tekstowe okno na ekranie.

Metoda jest miejscem wykonywania akcji w postaci szeregu in-strukcji, zwanego blokiem instrukcji — z parą nawiasów klamrowychi dowolną liczbą (zerem albo więcej) instrukcji pomiędzy nimi.W naszym programie zdefiniowaliśmy prostą metodę o nazwieMain:


static void Main(){ …}

Kod programu można uprościć przez napisanie funkcji wysokopo-ziomowych, wywołujących funkcje niższego poziomu. Nasz pro-gram można by przerobić tak, aby wielokrotnie wykorzystywałzmodyfikowaną metodę obliczającą iloczyn argumentu i liczby 12,jak tutaj:

using System;

class Test{ static void Main() { Console.WriteLine (FeetToInches (30)); // 360 Console.WriteLine (FeetToInches (100)); // 1200 }

static int FeetToInches (int feet) { int inches = feet * 12; return inches; }}

Metoda może pobierać dane wejściowe od wywołującego za po-średnictwem zadeklarowanych parametrów, a także zwracać danewyjściowe do wywołującego, za pośrednictwem zadeklarowanejwartości zwracanej. W powyższym przykładzie zdefiniowaliśmymetodę o nazwie FeetToInches (przeliczającą stopy na cale) z pa-rametrem dla wejściowej liczby stóp i wartością zwracaną dlawynikowej liczby cali:

static int FeetToInches (int feet) {…}

Argumentami przekazywanymi do metody FeetToInches są literały(wartości liczbowe) 30 oraz 100. Metoda Main z naszego przy-kładu nie zawiera pomiędzy nawiasami w deklaracji żadnych

Pierwszy program w C# | 17

parametrów, ponieważ nie przyjmuje żadnych argumentów; z koleityp wartości zwracanej w metodzie Main został ustalony jako void,ponieważ metoda nie zwraca żadnych wartości do wywołującego:

static void Main()

Język C# rozpoznaje metodę o nazwie Main jako domyślny punktwejścia do programu, czyli miejsce rozpoczęcia wykonywaniaprogramu. Metoda Main może opcjonalnie, zamiast void, zwracaćdo środowiska wykonawczego wartość typu całkowitego (liczbę).Metoda Main może też opcjonalnie w wywołaniu przyjmowaćargumenty w postaci tablicy ciągów znaków (wypełnianej ar-gumentami, z którymi uruchomiono program). Oto przykład:

static int Main (string[] args) {…}

UwagaTablica (jak string[] z powyższego przykładu) reprezentujepewną ustaloną liczbę elementów o tym samym typie (zobaczteż podrozdział „Tablice”).

W języku C# metody to jeden z kilku wyróżnionych rodzajówfunkcji. W naszym przykładzie wykorzystaliśmy też funkcję in-nego rodzaju: operator *, zastosowany do obliczenia iloczynu. Dotego dochodzą jeszcze konstruktory (ang. constructors), właściwości(ang. properties), zdarzenia (ang. events), indeksery (ang. indexers)i finalizatory (ang. finalizers).

W naszym przykładzie obie zdefiniowane metody zostały ujęte wewspólnej klasie. Klasa to konstrukcja grupująca składowe — funkcjei dane — w obiektowy „klocek”. Na przykład klasa Consolegrupuje składowe wykorzystywane do obsługi tekstowych stru-mieni wejścia-wyjścia, w tym choćby metodę WriteLine. W naszejklasie Test zgrupowaliśmy dwie metody: metodę Main i metodęFeetToInches. Klasa definiuje typ, o którym powiemy więcejw podrozdziale „System typów”.


Na najbardziej zewnętrznym poziomie programu typy są zorgani-zowane w przestrzeniach nazw (ang. namespaces). Dyrektywa usingwprowadziła do naszego programu przestrzeń nazw System, dziękiczemu mogliśmy się odwołać do zdefiniowanego w tej przestrzenitypu Console bez konieczności stosowania przedrostka System(System.Console). Ze swojej strony moglibyśmy wszystkie naszeklasy umieścić we wspólnej przestrzeni nazw TestPrograms, jaktutaj:

using System;

namespace TestPrograms{ class Test1 {…} class Test1 {…}}

Cała platforma .NET Framework jest zorganizowana w zagnieżdżo-nych w sobie przestrzeniach nazw. Na przykład typy do obsługitekstu zawiera przestrzeń nazw:

using System.Text;

Dyrektywa using jest stosowana jedynie dla wygody skróconegozapisywania następnych odwołań do elementów przestrzeni nazw.Nie jest obowiązkowa i można zamiast niej stosować kwalifikowanenazwy typów, a więc poprzedzać właściwe nazwy typów przed-rostkami z nazwami przestrzeni nazw, w których te typy sądefiniowane, np. System.Text.StringBuilder.

KompilacjaKompilator języka C# kompiluje kod źródłowy, dany w postacizbioru plików o rozszerzeniu .cs, w tak zwany zestaw (ang. assembly).Zestaw jest w .NET jednostką mechanizmu budowania i rozmiesz-czania, i może być zarówno aplikacją, jak biblioteką. Zwyczajnaaplikacja przeznaczona dla środowiska okienkowego albo dla konsoliposiada metodę Main i ma postać pliku wykonywalnego z rozsze-

Składnia | 19

rzeniem .exe. Z kolei biblioteka, z rozszerzeniem .dll, jest odpowied-nikiem aplikacji, tyle że bez wyróżnionego punktu wejścia doprogramu. Biblioteka ma służyć do realizacji wywołań (odwołań)z innych aplikacji i bibliotek. Sama platforma .NET Frameworkstanowi właśnie zestaw bibliotek.

Kompilator języka C# to plik wykonywalny o nazwie csc.exe. Możnago stosować z wnętrza środowiska programistycznego takiego jakVisual Studio .NET, w którym kompilator jest wywoływanyautomatycznie, albo przeprowadzać kompilację ręcznie, z poziomuwiersza poleceń. Aby ręcznie skompilować program, należynajpierw zapisać kod źródłowy programu w pliku, np. My-FirstProgram.cs, a potem w wierszu poleceń wywołać poleceniecsc (z <Windows>\Microsoft .NET\Framework\<wersja platformy>):

csc MyFirstProgram.cs

W taki sposób powstanie aplikacja o nazwie MainFirstProgram.exe;gdybyśmy chcieli utworzyć bibliotekę (.dll), powinniśmy wydaćpolecenie:

csc /target:library MyFirstProgram.cs

SkładniaSkładnia C# wywodzi się ze składni języków C i C++. W tympodrozdziale opiszemy elementy składni języka C# na przykładzieponiższego programu:

using System;

class Test{ static void Main() { int x = 12 * 30; Console.WriteLine (x); }}


Identyfikatory i słowa kluczoweIdentyfikatory są nazwami wybieranymi przez programistę jakonazwy dla klas, metod, zmiennych itd. W naszym kodzie przy-kładowym występują następujące identyfikatory (w kolejności,w jakiej pojawiają się w tekście programu):

System Test Main x Console WriteLine

Identyfikator musi mieć charakter słowa, to znaczy zawierać znakiUnicode oraz zaczynać się od litery, ewentualnie od znakupodkreślenia. W identyfikatorach języka C# wielkość liter jestistotna. Przyjęło się, że: 1) argumenty funkcji, zmienne lokalne i polaprywatne zapisuje się zgodnie z tak zwaną konwencją wielbłądzią(ang. camel case), czyli np. mojaZmienna (pierwszy wyraz składowymałą literą, pozostałe wyrazy wyróżniane wielką literą); 2) wszystkiepozostałe identyfikatory zapisuje się w konwencji pascalowej,np. MojaMetoda (wszystkie wyrazy składowe wielką literą).

Z kolei słowa kluczowe są nazwami zarezerwowanymi dlakompilatora; nie można ich wykorzystać jako identyfikatorówdla własnych elementów programu. Oto lista słów kluczowychwystępujących w naszym przykładowym kodzie:

using class static void int

A oto pełna lista słów kluczowych w języku C#:

abstract class event ifas const explicit implicitbase continue extern inbool decimal false intbreak default finally interfacebyte delegate fixed internalcase do float iscatch double for lockchar else foreach longchecked enum goto namespace

Składnia | 21

new readonly struct unsafenull ref switch ushortobject return this usingoperator sbyte throw virtualout sealed true volatileoverride short try voidparams sizeof typeof whileprivate stackalloc uintprotected static ulongpublic string unchecked

Unikanie kolizji nazw

Jeśli koniecznie chcemy zastosować identyfikator, który kolidujez jednym ze słów kluczowych, możemy kwalifikować nasz identyfi-kator znakiem @. Oto przykład:

class class {…} // Niedozwoloneclass @class {…} // Dozwolone

Symbol @ nie wchodzi formalnie w skład samego identyfikatora,więc @mojaZmienna to dla kompilatora to samo co mojaZmienna.

Kontekstowe słowa kluczowe

W języku C# występują też słowa, które nie są słowami klu-czowymi w ścisłym znaczeniu, ale również mają specjalne zna-czenie. Są to tak zwane kontekstowe słowa kluczowe, które możnawykorzystywać również jako identyfikatory, i to bez symbolu @.Wśród kontekstowych słów kluczowych mamy:

add get let setascending global on valueby group orderby vardescending in partial whereequals into remove yieldfrom join select


Stosowanie kontekstowych słów kluczowych jako identyfikatorówjest dozwolone, pod warunkiem że w kontekście wystąpienia identy-fikatora nie pojawi się niejednoznaczność co do jego charakteru.

c# 3.0. leksykon kieszonkowy. wydanie ii

Technology