Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00115 007894 11008286 na godz. na dobę w sumie
C# 3.0. Leksykon kieszonkowy. Wydanie II - książka
C# 3.0. Leksykon kieszonkowy. Wydanie II - książka
Autor: , Liczba stron: 280
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1827-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).
Poznaj nowości języka C# i podnieś wydajność programowania.

C# jest obiektowym językiem programowania zalecanym przez Microsoft dla 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 nieznanej w czasie kompilacji. Wiedza programisty jest kluczem do wykorzystania wszystkich jego możliwości. Leksykon stanowi bogate kompendium nowych rozwiązań dostępnych w 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 koniecznych do 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:

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

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

Darmowy fragment publikacji:

C# 3.0. Leksykon kieszonkowy. Wydanie II Autor: Joseph Albahari, Ben Albahari T‡umaczenie: Przemys‡aw Szeremiota ISBN: 978-83-246-1827-9 Tytu‡ orygina‡u: C# 3.0 Pocket Reference: Instant Help for C# 3.0 Programmers, 2nd Edition Format: 115x170, stron: 280 Poznaj nowo(cid:156)ci jŒzyka C# i podnie(cid:156) wydajno(cid:156)(cid:230) programowania (cid:149) Co nowego w C# 3.0? (cid:149) Jak skr(cid:243)ci(cid:230) i usprawni(cid:230) sw(cid:243)j kod? (cid:149) Do czego s‡u¿y mechanizm LINQ? C# jest obiektowym jŒzykiem programowania zalecanym przez Microsoft dla platformy .NET Framework. Pozwala definiowa(cid:230) wiele r(cid:243)¿norodnych element(cid:243)w sk‡adowych klas, nie tylko pola czy metody. Analiza struktury kodu umo¿liwia tworzenie wysoce uniwersalnych mechanizm(cid:243)w operuj„cych na strukturze kodu nieznanej w czasie kompilacji. Wiedza programisty jest kluczem do wykorzystania wszystkich jego mo¿liwo(cid:156)ci. Leksykon stanowi bogate kompendium nowych rozwi„zaæ dostŒpnych w C# 3.0 oraz ich implementacji. Opisane zagadnienia, dotycz„ce mechanizmu LINQ (Language Integrated Query), pozwalaj„ na pozyskanie praktycznej wiedzy niezbŒdnej we wsp(cid:243)‡czesnym programowaniu. Ksi„¿ka C# 3.0 Leksykon kieszonkowy. Wydanie II, poruszaj„ca w spos(cid:243)b przejrzysty i rzeczowy ca‡o(cid:156)(cid:230) pojŒciowych zmian koniecznych do opanowania C#, jest idealn„ pozycj„ dla wszystkich programist(cid:243)w, kt(cid:243)rym nieobca jest Java, C++ lub poprzednie wersje C#. Do najwa¿niejszych cech wyr(cid:243)¿niaj„cych jŒzyk C# w wydaniu 3.0 zaliczamy: (cid:149) wyra¿enia lambda, (cid:149) metody rozszerzaj„ce, (cid:149) niejawne typowanie zmiennych lokalnych, (cid:149) sk‡adniŒ ujmowania zapytaæ w kodzie, (cid:149) typy anonimowe, (cid:149) niejawne typowanie tablic, (cid:149) inicjalizatory obiekt(cid:243)w, (cid:149) w‡a(cid:156)ciwo(cid:156)ci automatyczne, (cid:149) metody czŒ(cid:156)ciowe, (cid:149) drzewa wyra¿eæ. Nie tra(cid:230) czasu na szukanie informacji! Programuj wydajnie i efektywnie z kieszonkowym leksykonem! Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści Nowości w C# 3.0 ........................................................................11 Pierwszy program w C# ............................................................. 15 18 Kompilacja Składnia ...................................................................................... 19 20 22 23 Identyfikatory i słowa kluczowe Literały, znaki interpunkcyjne i operatory Komentarze do kodu System typów .............................................................................23 24 25 29 30 34 Przykłady typów predefiniowanych Przykłady typów własnych Konwersje Typy wartościowe a typy referencyjne Taksonomia typów predefiniowanych Typy liczbowe .............................................................................35 36 38 40 40 41 43 Literały liczbowe Konwersje liczbowe Operatory arytmetyczne Operatory inkrementacji i dekrementacji Specjalizowane operacje na liczbach całkowitych Liczby całkowite 8- i 16-bitowe 3 Wyróżnione wartości zmiennoprzecinkowe double kontra decimal Błędy zaokrąglania liczb rzeczywistych 43 45 46 Typ wartości logicznych i operatory logiczne ...........................47 47 48 Operatory porównania i relacji Operatory logiczne Znaki i ciągi znaków .................................................................. 49 50 51 Konwersje znaków Typ string Tablice .........................................................................................54 55 57 58 60 Domyślna inicjalizacja elementów tablic Tablice wielowymiarowe Wyrażenia uproszczonej inicjalizacji tablic Kontrola zakresów Zmienne i parametry .................................................................. 61 61 63 64 64 69 Stos i sterta Przypisania oznaczone Wartości domyślne Parametry Niejawne typowanie zmiennych lokalnych (C# 3.0) (var) Operatory i wyrażenia ...............................................................70 71 71 71 72 73 Wyrażenia proste Wyrażenia bezwartościowe Wyrażenia przypisania Priorytety i łączność operatorów Tabela operatorów 4 | C# 3.0. Leksykon kieszonkowy Instrukcje ....................................................................................77 77 Instrukcje deklaracji Instrukcje wyrażeniowe 78 79 Instrukcje warunkowe 83 Instrukcje iteracyjne 86 Instrukcje skoku Inne instrukcje 88 Przestrzenie nazw ......................................................................89 90 91 93 Dyrektywa using Reguły obowiązujące w przestrzeniach nazw Synonimy typów i przestrzeni nazw Klasy ............................................................................................93 94 95 96 98 99 100 102 104 105 106 106 107 Pola Metody Konstruktory instancji Inicjalizatory obiektów (C# 3.0) Referencja this Właściwości Indeksery Stałe Konstruktory statyczne Klasy statyczne Finalizatory Klasy i metody częściowe Dziedziczenie ............................................................................108 110 110 112 114 114 Polimorfizm Rzutowanie Wirtualne funkcje składowe Klasy i składowe abstrakcyjne Widoczność składowych dziedziczonych Spis treści | 5 Pieczętowanie funkcji i klas Słowo kluczowe base Konstruktory a dziedziczenie Przeciążanie a rozstrzyganie wywołań 115 116 117 118 Typ object ...................................................................................119 120 121 122 122 123 124 Pakowanie i odpakowywanie Statyczna i dynamiczna kontrola typów Wykaz składowych klasy object Metoda GetType() i operator typeof Equals, ReferenceEquals i GetHashCode Metoda ToString Struktury ................................................................................... 125 126 Semantyka konstrukcji struktury Modyfikatory dostępu .............................................................. 127 128 128 129 Przykłady Narzucanie dostępności Ograniczenia modyfikatorów dostępu Interfejsy ................................................................................... 129 131 Rozszerzanie interfejsu 131 Jawna implementacja interfejsu Wirtualne implementowanie składowych interfejsów 132 133 Ponowna implementacja interfejsu w klasie pochodnej Typy wyliczeniowe ................................................................... 135 136 137 138 Konwersje typów wyliczeniowych Flagi Operatory typów wyliczeniowych 6 | C# 3.0. Leksykon kieszonkowy Typy zagnieżdżone ................................................................... 139 Uogólnienia ..............................................................................140 140 142 143 144 145 146 146 148 149 150 150 151 Typy uogólnione Po co nam uogólnienia Metody uogólnione Deklarowanie parametrów uogólnienia Uogólnienia a typeof Domyślna wartość uogólnienia Ograniczenia uogólnień Uogólnienia i kowariancja Pochodne typów uogólnionych Deklaracje uogólnień z odwołaniami do siebie Dane statyczne Inicjalizowanie kolekcji uogólnionych Delegaty .....................................................................................151 153 153 155 155 155 Pisanie metod-wtyczek dla delegatów Delegaty wielokrotne Metody statyczne i metody instancji jako metody docelowe Uogólnione typy delegatów Zgodność delegatów Zdarzenia .................................................................................. 157 159 163 164 Standardowy schemat zdarzenia Akcesory zdarzenia Modyfikatory zdarzeń Wyrażenia lambda (C# 3.0) .....................................................164 166 166 167 Jawne określanie typów parametrów lambdy Uogólnione wyrażenia lambda i delegaty Func Zmienne zewnętrzne Spis treści | 7 Metody anonimowe .................................................................169 Wyjątki i instrukcja try ............................................................. 170 173 174 176 178 178 Klauzula catch Blok finally Zgłaszanie wyjątków Najważniejsze właściwości klasy System.Exception Najczęstsze wyjątki Enumeratory i iteratory ............................................................180 180 181 183 184 Enumeracja Iteratory Semantyka iteratora Składanie sekwencji Typy z dopuszczalną wartością pustą .....................................185 185 188 190 191 Podstawy Pożyczanie operatorów Typ bool? Operator ?? Przeciążanie operatorów ..........................................................191 192 193 194 Funkcje operatorów Przeciążanie operatorów porównania i relacji Własne konwersje jawne i niejawne Metody rozszerzające (C# 3.0) ................................................196 197 197 Kaskadowe wywołania metod rozszerzających Niejednoznaczność i rozstrzyganie niejednoznaczności Typy anonimowe (C# 3.0) ........................................................199 8 | C# 3.0. Leksykon kieszonkowy LINQ (C# 3.0) ............................................................................200 200 205 207 213 214 218 219 219 221 224 225 228 Podstawy LINQ Opóźnione wykonanie Standardowe operatory zapytań Kaskadowe operatory zapytań Składnia zapytań Słowo kluczowe let Kontynuacje zapytań Zapytania z wieloma generatorami Złączenia Porządkowanie Grupowanie Operatory OfType i Cast Atrybuty ....................................................................................229 229 230 231 231 232 233 Klasy atrybutów Parametry nazwane i pozycyjne Obiekt docelowy atrybutu Nadawanie wielu atrybutów Definiowanie własnych atrybutów Odwołania do atrybutów w czasie wykonania Wskaźniki i kod nienadzorowany .......................................... 234 234 235 235 237 237 238 239 Elementarz wskaźników Kod nienadzorowany Instrukcja fixed Operator dostępu do składowej przez wskaźnik Tablice Typ void* Wskaźniki do kodu nienadzorowanego Spis treści | 9 Dyrektywy preprocesora ..........................................................239 241 242 Atrybuty warunkowe Ostrzeżenia i pragma Dokumentacja XML ................................................................. 243 244 Standardowe znaczniki dokumentacji XML Przegląd infrastruktury i środowiska ......................................247 248 256 261 263 Rdzeń infrastruktury Technologie interfejsu użytkownika Technologie zaplecza aplikacji Technologie systemów rozproszonych Skorowidz .................................................................................267 10 | C# 3.0. Leksykon kieszonkowy 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 neutralny wobec platformy, ale najlepiej współpracuje z .NET Framework firmy Microsoft. Dla C# w wersji 3.0 najodpowiedniejsza jest plat- forma .NET Framework 3.5. Nowości w C# 3.0 Nowoś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 SQL wprost 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ępnia interfejsy uwzględniające mechanizm lokalnych zapytań LINQ dla wszelkich kolekcji, zdalnych baz danych oraz do plików XML. Do najważniejszych cech wyróżniających język C# w wydaniu 3.0 zaliczymy: • wyrażenia lambda, • metody rozszerzające, • niejawne typowanie zmiennych lokalnych, • składnię ujmowania zapytań w kodzie, 11 • 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.0 i 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ów o nowe metody, bez zmieniania pierwotnej definicji typu. Pełnią rolę skrótowca składniowego, ponieważ ich działanie sprowadza się 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); 12 | C# 3.0. Leksykon kieszonkowy Niejawne typowanie zmiennych lokalnych to zezwolenie na pominięcie typu zmiennej w instrukcji deklaracji i zdanie się na wnioskowanie typu przez kompilator. Ponieważ kompilator potrafi samodzielnie określić typ zmiennej filteredNames, możemy nasze zapytanie uproś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 LINQ upodobnionej do składni zapytań SQL zamiast zapytań konstru- owanych z wywołań operatorów. Dzięki temu znacząco upraszcza się zapis wielu rodzajów zapytań; ponownie mamy do czynienia ze skrótowcem składniowym, tym razem dla zamaskowanych wyrażeń lambda. Oto poprzedni przykład, przepisany z użyciem skł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, wykorzystywane czę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 } }; Nowości w C# 3.0 | 13 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 typami anonimowymi 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łby taki kod: Bunny b2 = new Bunny(); b2.Name = Bo ; b2.LikesCarrots = true; Właściwości automatyczne oszczędzają pisania kodu właściwości sprowadzających się do prostych akcesorów ustawiających i od- czytujących wartość prywatnego pola docelowego. W poniższym przykładzie kompilator automatycznie wygeneruje prywatne pole i akcesory dla właściwości X: public class Stock { public decimal X { get; set; } } Metody częściowe pozwalają w klasach generowanych automatycznie na dodawanie ręcznych uzupełnień. Mechanizm LINQ do SQL wykorzystuje 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 drzewo wyrażenia dla każdego wyrażenia lambda przypisanego do instancji specjalnego typu Expression TDelegate : Expression Func string,bool predicate = s = s.Length 10; 14 | C# 3.0. Leksykon kieszonkowy 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 kodzie oznaczają, ż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ęzyku C# 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 klasy Console; 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 klamrowych i dowolną liczbą (zerem albo więcej) instrukcji pomiędzy nimi. W naszym programie zdefiniowaliśmy prostą metodę o nazwie Main: Pierwszy program w C# | 15 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ć dane wyjściowe do wywołującego, za pośrednictwem zadeklarowanej wartości zwracanej. W powyższym przykładzie zdefiniowaliśmy metodę o nazwie FeetToInches (przeliczającą stopy na cale) z pa- rametrem dla wejściowej liczby stóp i wartością zwracaną dla wynikowej 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 16 | C# 3.0. Leksykon kieszonkowy parametrów, ponieważ nie przyjmuje żadnych argumentów; z kolei typ 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 punkt wejścia do programu, czyli miejsce rozpoczęcia wykonywania programu. 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) {…} Uwaga Tablica (jak string[] z powyższego przykładu) reprezentuje pewną ustaloną liczbę elementów o tym samym typie (zobacz też podrozdział „Tablice”). W języku C# metody to jeden z kilku wyróżnionych rodzajów funkcji. W naszym przykładzie wykorzystaliśmy też funkcję in- nego rodzaju: operator *, zastosowany do obliczenia iloczynu. Do tego 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 we wspólnej klasie. Klasa to konstrukcja grupująca składowe — funkcje i dane — w obiektowy „klocek”. Na przykład klasa Console grupuje składowe wykorzystywane do obsługi tekstowych stru- mieni wejścia-wyjścia, w tym choćby metodę WriteLine. W naszej klasie Test zgrupowaliśmy dwie metody: metodę Main i metodę FeetToInches. Klasa definiuje typ, o którym powiemy więcej w podrozdziale „System typów”. Pierwszy program w C# | 17 Na najbardziej zewnętrznym poziomie programu typy są zorgani- zowane w przestrzeniach nazw (ang. namespaces). Dyrektywa using wprowadziła do naszego programu przestrzeń nazw System, dzięki czemu mogliśmy się odwołać do zdefiniowanego w tej przestrzeni typu Console bez konieczności stosowania przedrostka System (System.Console). Ze swojej strony moglibyśmy wszystkie nasze klasy umieścić we wspólnej przestrzeni nazw TestPrograms, jak tutaj: 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ługi tekstu zawiera przestrzeń nazw: using System.Text; Dyrektywa using jest stosowana jedynie dla wygody skróconego zapisywania następnych odwołań do elementów przestrzeni nazw. Nie jest obowiązkowa i można zamiast niej stosować kwalifikowane nazwy 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. Kompilacja Kompilator języka C# kompiluje kod źródłowy, dany w postaci zbioru 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ą. Zwyczajna aplikacja przeznaczona dla środowiska okienkowego albo dla konsoli posiada metodę Main i ma postać pliku wykonywalnego z rozsze- 18 | C# 3.0. Leksykon kieszonkowy rzeniem .exe. Z kolei biblioteka, z rozszerzeniem .dll, jest odpowied- nikiem aplikacji, tyle że bez wyróżnionego punktu wejścia do programu. Biblioteka ma służyć do realizacji wywołań (odwołań) z innych aplikacji i bibliotek. Sama platforma .NET Framework stanowi właśnie zestaw bibliotek. Kompilator języka C# to plik wykonywalny o nazwie csc.exe. Można go stosować z wnętrza środowiska programistycznego takiego jak Visual Studio .NET, w którym kompilator jest wywoływany automatycznie, albo przeprowadzać kompilację ręcznie, z poziomu wiersza poleceń. Aby ręcznie skompilować program, należy najpierw zapisać kod źródłowy programu w pliku, np. My- FirstProgram.cs, a potem w wierszu poleceń wywołać polecenie csc (z Windows Microsoft .NETFramework 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ładnia Składnia C# wywodzi się ze składni języków C i C++. W tym podrozdziale opiszemy elementy składni języka C# na przykładzie poniższego programu: using System; class Test { static void Main() { int x = 12 * 30; Console.WriteLine (x); } } Składnia | 19 Identyfikatory i słowa kluczowe Identyfikatory są nazwami wybieranymi przez programistę jako nazwy 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ć znaki Unicode oraz zaczynać się od litery, ewentualnie od znaku podkreślenia. W identyfikatorach języka C# wielkość liter jest istotna. Przyjęło się, że: 1) argumenty funkcji, zmienne lokalne i pola prywatne zapisuje się zgodnie z tak zwaną konwencją wielbłądzią (ang. camel case), czyli np. mojaZmienna (pierwszy wyraz składowy małą literą, pozostałe wyrazy wyróżniane wielką literą); 2) wszystkie pozostałe identyfikatory zapisuje się w konwencji pascalowej, np. MojaMetoda (wszystkie wyrazy składowe wielką literą). Z kolei słowa kluczowe są nazwami zarezerwowanymi dla kompilatora; nie można ich wykorzystać jako identyfikatorów dla własnych elementów programu. Oto lista słów kluczowych wystę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 as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace 20 | C# 3.0. Leksykon kieszonkowy new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual volatile void while Unikanie kolizji nazw Jeśli koniecznie chcemy zastosować identyfikator, który koliduje z jednym ze słów kluczowych, możemy kwalifikować nasz identyfi- kator znakiem @. Oto przykład: class class {…} // Niedozwolone class @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żna wykorzystywać również jako identyfikatory, i to bez symbolu @. Wśród kontekstowych słów kluczowych mamy: add ascending by descending equals from get global group in into join let on orderby partial remove select set value var where yield Składnia | 21 Stosowanie kontekstowych słów kluczowych jako identyfikatorów jest dozwolone, pod warunkiem że w kontekście wystąpienia identy- fikatora nie pojawi się niejednoznaczność co do jego charakteru. 22 | C# 3.0. Leksykon kieszonkowy
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C# 3.0. Leksykon kieszonkowy. Wydanie II
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


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