Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00389 007635 11070027 na godz. na dobę w sumie
C#. Leksykon kieszonkowy - książka
C#. Leksykon kieszonkowy - książka
Autor: , , Liczba stron: 148
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-082-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).
Książka 'C#. Leksykon kieszonkowy' dostarcza programistom zwięzłego opisu najbardziej innowacyjnego z języków środowiska .NET. Zaprojektowana jako poręczny, przenośny przewodnik do codziennego użytku, stanowi niezbędną pomoc dla programistów. Pomoże także Czytelnikowi przypomnieć sobie typowe wzorce składniowe, a ponadto ułatwi poruszanie się po środowisku .NET Framework.

Książka ta zawiera:

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE C#. Leksykon kieszonkowy Autorzy: Peter Drayton, Ben Albahari, Ted Neward T³umaczenie: Przemys³aw Steæ ISBN: 83-7361-082-0 Tytu³ orygina³u: C# Language Pocket Reference Format: B5, stron: 146 Ksi¹¿ka „C#. Leksykon kieszonkowy” dostarcza programistom zwiêz³ego opisu najbardziej innowacyjnego z jêzyków ġrodowiska .NET. Zaprojektowana jako porêczny, przenoġny przewodnik do codziennego u¿ytku, stanowi niezbêdn¹ pomoc dla programistów. Pomo¿e tak¿e Czytelnikowi przypomnieæ sobie typowe wzorce sk³adniowe, a ponadto u³atwi poruszanie siê po ġrodowisku .NET Framework. Ksi¹¿ka ta zawiera: • Opis jêzyka C# zawieraj¹cy regu³y sk³adniowe dotycz¹ce s³ów kluczowych, deklaracji i instrukcji • Wprowadzenie do systemu typów, w tym opis mechanizmu opakowywania i odpakowywania pomiêdzy typami referencyjnymi a typami wartoġciowymi • Zestawienie opcji kompilatora C# oraz przewodnik po istotnych narzêdziach ġrodowiska .NET • Tabele opisuj¹ce sk³adniê wyra¿eñ regularnych, specyfikatory formatu oraz zestawienie przestrzeni nazw i odpowiadaj¹cych im z³o¿eñ Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Identyfikatory oraz słowa kluczowe.......................................... 8 Podstawowe elementy ............................................................... 9 Typy wartościowe i referencyjne ............................................ 10 Typy wartościowe...................................................ś.................................10 Typy referencyjne...................................................ś..................................11 Typy predefiniowane ............................................................... 16 Typy całkowite ...................................................ś......................................16 Typy zmiennoprzecinkowe ...................................................ś.................18 Typ dziesiętny (decimal)...................................................ś......................19 Typ znakowy (char)...................................................ś..............................20 Typ logiczny (bool) ...................................................ś...............................21 Typ object ...................................................ś...............................................22 Typ łańcuchowy (string) ...................................................ś......................22 Tablice...................................................................................... 23 Tablice wielowymiarowe ...................................................ś.....................24 Lokalne deklaracje tablic i deklaracje tablic jako pól..........................25 Długość i rząd tablicy...................................................ś...........................25 Kontrola zakresów ...................................................ś................................25 Konwersje tablic ...................................................ś....................................26 Zmienne i parametry .............................................................. 26 Określone przypisanie...................................................ś..........................26 Wartości domyślne ...................................................ś...............................27 Parametry ...................................................ś...............................................28 Wyrażenia i operatory............................................................. 31 Priorytet operatorów ...................................................ś............................31 Operatory kontroli przepełnienia arytmetycznego ............................34 Instrukcje................................................................................. 34 Instrukcje wyrażeniowe ...................................................ś.......................35 Instrukcje deklaracyjne...................................................ś.........................35 Instrukcje wyboru ...................................................ś.................................36 Instrukcje pętli ...................................................ś.......................................39 Instrukcje skoku ...................................................ś....................................41 Przestrzenie nazw ................................................................... 44 Pliki ...................................................ś...................................................ś......44 Wykorzystanie przestrzeni nazw ...................................................ś.......45 Klasy ........................................................................................ 48 Słowo kluczowe this ...................................................ś.............................51 Pola...................................................ś...................................................ś.......52 Stałe ...................................................ś...................................................ś......52 Właściwości...................................................ś............................................54 Indeksatory ...................................................ś............................................55 Metody...................................................ś...................................................ś.56 Konstruktory egzemplarzy...................................................ś..................57 Konstruktory statyczne ...................................................ś........................59 Destruktory i finalizery ...................................................ś........................60 Typy zagnieżdżone...................................................ś...............................61 Modyfikatory dostępu ............................................................. 62 Ograniczenia modyfikatorów dostępu .................................................64 Struktury................................................................................. 65 Interfejsy.................................................................................. 66 Definiowanie interfejsu ...................................................ś........................67 Implementacja interfejsu...................................................ś......................68 Wykorzystanie interfejsu ...................................................ś.....................68 Rozszerzanie interfejsu...................................................ś.........................69 Jawna implementacja interfejsu ...................................................ś..........69 Ponowna implementacja interfejsu ...................................................ś....70 Konwersje interfejsów ...................................................ś..........................71 Wyliczenia ............................................................................... 71 Operatory wyliczeń ...................................................ś..............................73 Konwersje wyliczeń...................................................ś..............................73 Delegaty................................................................................... 74 Delegaty zbiorowe ...................................................ś................................74 Zdarzenia................................................................................. 76 Definiowanie delegata dla zdarzenia...................................................ś.76 Przechowywanie danych zdarzenia z wykorzystaniem klasśy EventArgs...................................................ś...............................................76 Deklaracja i wywoływanie zdarzenia ...................................................ś77 Reagowanie na zdarzenie z wykorzystaniem procedury obsługi zdarzenia ...................................................ś..................................78 Akcesory zdarzenia ...................................................ś..............................79 Przeciążanie operatorów.......................................................... 80 Implementacja równości wartości ...................................................ś......80 Logiczne pary operatorów...................................................ś...................82 Niestandardowe konwersje — jawne i niejawne ................................82 Operatory przeciążalne pośrednio ...................................................ś.....83 Instrukcje try i wyjątki ........................................................... 84 Wyjątki...................................................ś...................................................ś.84 Klauzula catch ...................................................ś.......................................86 Blok finally ...................................................ś.............................................87 Główne właściwości klasy System.Exception......................................88 Atrybuty .................................................................................. 89 Klasy atrybutów ...................................................ś....................................90 Parametry nazwane i pozycyjne...................................................ś.........90 Elementy docelowe atrybutów ...................................................ś...........91 Zastosowanie kilku atrybutów ...................................................ś...........92 Kod niebezpieczny i wskaźniki ............................................... 92 Podstawowe informacje o wskaźnikach...............................................92 Kod niebezpieczny...................................................ś................................93 Instrukcja fixed ...................................................ś......................................94 Operator wskaźnikowego dostępu do składowych ...........................95 Słowo kluczowe stackalloc ...................................................ś..................95 Void* ...................................................ś...................................................ś....96 Wskaźniki do kodu niezarządzanego...................................................ś96 Dyrektywy preprocesora ......................................................... 97 Opis biblioteki Framework Class Library............................... 98 Typy rdzenne...................................................ś.........................................99 Tekst ...................................................ś...................................................ś...100 Kolekcje...................................................ś.................................................100 Strumienie i operacje wejścia-wyjścia .................................................101 Praca sieciowa...................................................ś......................................101 Wątki...................................................ś...................................................ś..102 Bezpieczeństwo ...................................................ś...................................102 Refleksje i metadane ...................................................ś...........................103 Złożenia ...................................................ś................................................104 Serializacja...................................................ś............................................104 Zdalne wykorzystanie obiektów ...................................................ś......104 Usługi WWW...................................................ś.......................................105 Dostęp do danych ...................................................ś...............................106 XML...................................................ś...................................................ś....106 Grafika ...................................................ś..................................................107 Rozbudowane aplikacje klienckie ...................................................ś....107 Aplikacje WWW...................................................ś..................................108 Globalizacja ...................................................ś..........................................109 Konfiguracja...................................................ś.........................................109 Zaawansowane usługi komponentowe ..............................................109 Diagnostyka i testowanie...................................................ś...................110 Współpraca z kodem niezarządzanym...............................................110 Obsługa kompilatora i narzędzi ...................................................ś.......111 Funkcje środowiska uruchomieniowego............................................112 Rodzime funkcje systemu operacyjnego ............................................112 Przestrzenie nazw a złożenia................................................ 112 Wyrażenia regularne............................................................. 120 Specyfikatory formatu ........................................................... 124 Specyfikatory formatu wizualnego ...................................................ś..126 Specyfikatory formatu typu DateTime ...............................................127 Opcje kompilatora języka C# ................................................ 129 Istotne narzędzia środowiska .NET ...................................... 134 Skorowidz .............................................................................. 139 Opakowywanie i odpakowywanie typów wartościowych Aby można było wykonywać wspólne operacje — przeprowa- dzane zarówno na typach referencyjnych, jak i wartościowych — każdy typ wartościowy posiada odpowiadający mu ukryty typ referencyjny. Zostaje on utworzony w przypadku przypisania typu wartościowego do egzemplarza typu System.Object lub do interfejsu. Proces ten zwany jest opakowywaniem (ang. boxing). Typ wartościowy można rzutować do klasy object (wyjścio- wej klasy bazowej dla wszystkich typów wartościowych i refe- rencyjnych) lub do implementowanego przez niego interfłejsu. W zaprezentowanym tu przykładzie opakowujemy typ warto- ściowy int w odpowiadający mu typ referencyjny, a następnie odpakowujemy go: class Test { static void Main () { int x = 9; object o = x; // opakuj typ int int y = (int)o; // odpakuj typ int } } Podczas opakowywania typu wartościowego tworzony jest nowy typ referencyjny, który przechowywać będzie kopię opakowy- wanego typu. Operacja odpakowania powoduje przekopiowanie wartości z typu referencyjnego z powrotem do typu wartościo- wego. Wymaga ona jawnego rzutowania, podczas którego wyko- nywane jest sprawdzenie, czy docelowy typ wartościowy jest zgodny z typem zawartym w typie referencyjnym. W przypadku niepomyślnego wyniku tego sprawdzenia zgłaszany jest wyjątek InvalidCastException. Nie musimy się martwić o to, co stanie się z opakowanymi obiektami, gdy przestaniemy z nich korzy- Typy predefiniowane 3 stać — poradzi sobie z nimi za nas mechanizm odśmiecania pamięci. Dobrym przykładem operacji opakowania i odpakowania jest za- stosowanie klas kolekcji (ang. collection classes). W następującym fragmencie kodu wykorzystujemy klasę Queue w połączeniu z typami wartościowymi: using System; using System.Collections; class Test { static void Main () { Queue q = new Queue (); q.Enqueue (1); // opakuj wartość typu int q.Enqueue (2); // opakuj wartość typu int Console.WriteLine ((int)q.Dequeue()); // odpakuj wartość typu int Console.WriteLine ((int)q.Dequeue()); // odpakuj wartość typu int } } Typy predefiniowane Wszystkie typy predefiniowane w języku C# są nazwami zastęp- czymi typów występujących w przestrzeni nazw System. Na przykład, pomiędzy następującymi dwoma instrukcjami istnieje jedynie różnica składniowa: int i = 5; System.Int32 i = 5; Typy całkowite Typy całkowite oraz ich właściwości przedstawia zamieszczona poniżej tabela. 4 C#. Leksykon kieszonkowy W przypadku typów całkowitych bez znaku, o szerokości n bi- tów, możliwe wartości należą do zakresu od 0 do 2n–1. W przy- padku typów całkowitych ze znakiem, o takiej samej szerokości Typ w języku C# Typ systemowy Rozmiar Ze znakiem sbyte short int long byte ushort uint ulong System.SByte System.Int16 System.Int32 1 bajt 2 bajty 4 bajty System.Int64 8 bajtów 1 bajt System.Byte System.UInt16 2 bajty System.UInt32 4 bajty System.UInt64 8 bajtów Tak Tak Tak Tak Nie Nie Nie Nie (n bitów), możliwe wartości mieszczą się w zakresie od –2n–1 do 2n–1–1. W literałach całkowitych stosować można notację dzie- siętną lub szesnastkową: int x = 5; ulong y = 0x1234AF; // w przypadku liczb szesnastkowych stosujemy przedrostek 0x W przypadku, gdy dany literał całkowity jest poprawnył dla kilku możliwych typów całkowitych, typ domyślny wybierany jest w następującej kolejności: int, uint, long oraz ulong. W celu jawnego określenia wybranego typu można użyć następujących przyrostków: U L UL uint lub ulong long lub ulong ulong Typy predefiniowane 5 Konwersje całkowite Niejawna konwersja pomiędzy typami całkowitymi jest dozwo- lona w przypadku, gdy typ, na który chcemy konwertować, zawiera wszystkie możliwe wartości typu konwertowanego. W przeciwnym razie konieczna jest konwersja jawna. Możemy, na przykład, niejawnie skonwertować typ int na typ long, lecz typ int na typ short musimy już konwertować jawnie: int x = 123456; long y = x; // konwersja niejawna, nie ma utraty informacji short z = (short)x; // konwersja jawna, wartość x zostaje obcięta Typy zmiennoprzecinkowe Typ w języku C# Typ systemowy Rozmiar float double System.Single System.Double 4 bajty 8 bajtów Typ float może pomieścić wartości z zakresu od około ±1,5×10–45 do około ±3,4×1038, z dokładnością do siedmiu cyfr znaczących. Typ double może pomieścić wartości z zakresu od około ±5,0× 10–324 do około ±1,7×10308, z dokładnością do 15 – 16 cyfr zna- czących. Typy zmiennoprzecinkowe mogą przechowywać wartości spe- cjalnie +0, –0, +∞, –∞, NaN (ang. not a number — wartość nielicz- bowa). Reprezentują one wyniki takich operacji matematycz- nych jak dzielenie przez zero. Typy float oraz double stanowią implementację specyfikacji typów formatu IEEE 754, obsługiwłaną przez prawie wszystkie procesory, a zdefiniowaną przez orga- nizację IEEE w witrynie http://www.ieee.org. 6 C#. Leksykon kieszonkowy W literałach zmiennoprzecinkowych stosować można notację dziesiętną lub wykładniczą. Literał typu float wymaga dołą- czenia przyrostka f lub F. Do literału typu double można (lecz nie jest to koniecznie) dodać przyrostek d lub D. float x = 9.81f; double y = 7E-02; // 0.07 Konwersje zmiennoprzecinkowe Niejawna konwersja typu float na typ double nie powoduje utraty informacji i jest dozwolona — lecz nigdy na odwrót. Dla zapewnienia czytelności dozwolona jest również konwersja typów int, uint i long na typ float oraz typu long na typ double: int sila = 2; int przesuniecie = 3; float x = 9.53f * sila - przesuniecie; Jeśli w przykładzie tym użyjemy większych wartości, może na- stąpić utrata precyzji. Jednak możliwy zakres wartości nie jest okrojony, ponieważ najniższa i najwyższa wartość zarówno typu float, jak i double, przekraczają najniższą i najwyższą wartość typów int, uint czy long. Wszystkie pozostałe konwersje po- między typami całkowitymi a zmiennoprzecinkowymi muszą być jawne: float x = 3.53f; int przesuniecie = (int)x; Typ dziesiętny (decimal) Typ decimal może przechowywać wartości z zakresu od ±1,0× 10–28 do około ±7,9×1028, przy użyciu 28 – 29 cyfr znaczących. Typ decimal zawiera 28 cyfr oraz położenie przecinka oddzie- lającego części dziesiętne. W przeciwieństwie do wartości zmien- Typy predefiniowane 7 noprzecinkowej typ ten charakteryzuje się większą dokładnością, lecz mniejszym zakresem. Przydatny jest on zwykle w oblicze- niach finansowych, gdzie połączenie jego wysokiej dokładności oraz możliwości zapisania liczby dziesiętnej bez błędów zaokrą- glenia jest bardzo cenne. Na przykład liczba 0,1 zostanie za pomo- cą typu decimal przedstawiona dokładnie, lecz jeśli użyjemy do jej zapisania typu zmiennoprzecinkowego, jej reprezentacją będzie liczba dwójkowa okresowa. W przypadku typu decimal nie istnieją pojęcia wartości +0, –0, +∞, –∞ czy NaN. Literał dziesiętny wymaga dołączenia przyrostka m lub M. decimal x = 80603.454327m; // przechowuje dokładną wartość Konwersje typu decimal Dozwolona jest niejawna konwersja wszystkich typów całko- witych na typ dziesiętny (decimal), ponieważ typ ten repre- zentować może dowolną wartość całkowitą. Konwersja typu decimal na typ zmiennoprzecinkowy (i odwrotnie) wymaga konwersji jawnej, ponieważ typy zmiennoprzecinkowe posia- dają większy zakres niż typ dziesiętny, ten zaś posiada większą dokładność niż typy zmiennoprzecinkowe. Typ znakowy (char) Typ w języku C# Typ systemowy Rozmiar char System.Char 2 bajty Typ char reprezentuje znak w formacie Unicode. Literał typu char może być albo znakiem prostym, albo znakiem w forma- cie Unicode, albo znakiem sterującym (ang. escape character). We wszystkich tych przypadkach użyty jako taki literał znak powi- nien być ujęty w apostrofy: 8 C#. Leksykon kieszonkowy A // znak prosty u0041 // znak w kodzie Unicode x0041 // znak w kodzie szesnastkowym unsigned short // znak sekwencji sterującej Znaki sekwencji sterującej zebrano w tabeli 1. Tabela 1. Znaki sekwencji sterującej Znak Znaczenie Wartość \ a  f v Apostrof Cudzysłów Lewy ukośnik Zero Alarm Znak cofania Wysuw strony Nowy wiersz Powrót karetki 0x0027 0x0022 0x005C 0x0000 0x0007 0x0008 0x000C 0x000A 0x000D Tabulacja pozioma 0x0009 Tabulacja pionowa 0x000B Konwersje typu char Niejawna konwersja typu char na większość typów numerycz- nych jest zwykle wykonywana, przy czym jest ona zależna od tego, czy dany typ numeryczny może pomieścić typ short bez znaku. Jeśli nie — konieczna jest konwersja jawna. Typ logiczny (bool) Typ w języku C# Typ systemowy Rozmiar Typy predefiniowane 9 bool System.Boolean 1 bajt/2 bajty Typ bool jest wartością logiczną, której przypisać można literał true lub false. Chociaż wartość boolowska wymaga tylko jednego bitu (0 lub 1), zajmuje ona 1 bajt pamięci, gdyż jest to minimalna porcja, która może podlegać adresowaniu w przypadku większości archiłtektur procesorów. Każdy element w tablicy boolowskiej zajmuje dwa bajty pamięci. Konwersje typu bool Nie są możliwe jakiekolwiek konwersje wartości boolowskich na typy numeryczne i odwrotnie. Typ object Typ w języku C# Typ systemowy Rozmiar object System.Object 0-bajtowy/8-bajtowy narzut Klasa object jest wyjściowym typem bazowym zarówno dla typów wartościowych, jak i referencyjnych. Typy wartościowe nie zawierają narzutu pamięci pochodzącego od obiektu. Typy referencyjne, które przechowywane są na stercie, z natury wy- magają narzutu. W środowisku uruchomieniowym .NET egzem- plarz typu referencyjnego posiada 8-bajtowy narzut, który zawiera typ obiektu, a także informacje tymczasowe, dotyczące na przy- kład stanu blokady synchronizacji lub tego, czy dany obiekt został zabezpieczony przed usunięciem przez mechanizm odśmiecania pamięci. Warto wiedzieć, że każda referencja do egzemplarza typu referencyjnego zajmuje 4 bajty pamięci. 10 C#. Leksykon kieszonkowy
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C#. Leksykon kieszonkowy
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ą: