C i NET.pdf

(740 KB) Pobierz
C# i .NET
IDZ DO
PRZYK£ADOW Y ROZDZIA£
C# i .NET
SPIS TREŒCI
KATALOG KSI¥¯EK
Autor: Stephen C. Perry
T³umaczenie: Miko³aj Szczepaniak (przedmowa, rozdz.
1 – 10), Tomasz Walczak (rozdz. 11 – 18, dod. A, B)
ISBN: 83-246-0320-4
Tytu³ orygina³u : Core C# and .NET
Format: B5, stron: 912
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Doskona³e Ÿród³o wiedzy dla wszystkich programistów C#
• Szczegó³owe omówienie C# i .NET w wersji 2.0
Techniki tworzenia i zabezpieczania aplikacji oraz zarz¹dzania kodem
Ÿród³owym i wersjami
Dziesi¹tki przyk³adów i kodów Ÿród³owych
Platforma .NET i jêzyk C# spowodowa³y prawdziw¹ rewolucjê na rynku narzêdzi
programistycznych. Wersja 2.0 przynios³a kilka interesuj¹cych rozwi¹zañ, w tym
nowe typy danych, komponenty i klasy. Dodatkowe funkcje jêzyka C# pozwalaj¹
na przyspieszenie i usprawnienie procesu tworzenia aplikacji oraz jej wdra¿ania
i rozwijania. Dziêki platformie .NET przygotowanie wydajnej, bezpiecznej i ³atwej
do rozbudowy aplikacji sta³o siê znacznie prostsze i szybsze.
Ksi¹¿ka „C# i .NET” przedstawia mo¿liwoœci platformy .NET i napisanego specjalnie
dla niej jêzyka C#. Opisuje elementy platformy, sk³adniê i mo¿liwoœci jêzyka C# oraz
zagadnienia zwi¹zane z tworzeniem programów za pomoc¹ tych narzêdzi. Omawia
zasady pisania aplikacji Window Forms i efektywne techniki stosowania klas
graficznych z biblioteki GDI+. Charakteryzuje tak¿e technologiê ADO.NET, metody
korzystania z plików XML, przetwarzanie wielow¹tkowe oraz techniki tworzenia
wydajnych aplikacji internetowych w technologii ASP.NET. Szczególn¹ uwagê
poœwiêcono bezpieczeñstwu programów i danych oraz skalowaniu i lokalizacji
oprogramowania.
Elementy platformy .NET
Podstawy jêzyka C#
Praca z klasami i obiektami w C#
Przetwarzanie tekstu oraz operacje wejœcia i wyjœcia
Tworzenie aplikacji Window Forms
Korzystanie z biblioteki GDI+
Po³¹czenia z bazami danych za pomoc¹ ADO.NET
Aplikacje wielow¹tkowe oraz rozproszone
Tworzenie aplikacji internetowych
Jeœli chcesz napisaæ w C# aplikacjê dobrej jakoœci, siêgnij po tê ksi¹¿kê
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOŒCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
400218968.002.png 400218968.003.png 400218968.004.png 400218968.005.png
O autorze .................................................................................................................................................... 17
Podziękowania ........................................................................................................................................... 18
Słowo wstępne ........................................................................................................................................... 19
Przedmowa ................................................................................................................................................ 21
Część I Podstawy programowania w języku C # i wprowadzenie do technologii .NET 25
Rozdział 1. Wprowadzenie do technologii .NET i języka C # .................................................................... 27
1.1. Przegląd składników platformy .NET ...................................................................... 28
Microsoft .NET i standardy CLI ............................................................................. 30
1.2. Wspólne środowisko uruchomieniowe (CLR) .......................................................... 32
Kompilacja kodu platformy .NET ........................................................................... 32
Wspólny system typów (CTS) ................................................................................ 34
Zestawy .NET ...................................................................................................... 36
1.3. Biblioteka klas platformy (FCL) ............................................................................. 41
1.4. Praca z platformą .NET i zestawem narzędzi .NET Framework SDK .......................... 44
Aktualizowanie platformy .NET Framework ............................................................. 45
Narzędzia platformy .NET Framework .................................................................... 46
Ildasm.exe .......................................................................................................... 47
wincv.exe ........................................................................................................... 50
Narzędzie Framework Configuration ...................................................................... 50
1.5. Wyjaśnienie działania kompilatora C# ................................................................... 53
Lokalizowanie kompilatora ................................................................................... 53
Kompilowanie oprogramowania z poziomu wiersza poleceń ..................................... 54
1.6. Podsumowanie ................................................................................................... 57
1.7. Sprawdź, czego się nauczyłeś .............................................................................. 57
Rozdział 2. Podstawy języka C # ............................................................................................................. 59
2.1. Podstawowa struktura programu C# ...................................................................... 60
Ogólne uwagi odnośnie programowania w języku C# ............................................... 62
2.2. Typy proste ......................................................................................................... 65
decimal .............................................................................................................. 67
bool ................................................................................................................... 67
400218968.001.png
6
C # i .NET
char ................................................................................................................... 67
byte, sbyte .......................................................................................................... 68
short, int, long .................................................................................................... 68
single i double .................................................................................................... 68
Konwertowanie łańcuchów numerycznych za pomocą metod Parse() i TryParse() ....... 69
2.3. Operatory arytmetyczne, logiczne i warunkowe ........................................................ 69
Operatory arytmetyczne ........................................................................................ 69
Operatory warunkowe i relacyjne ........................................................................... 70
Instrukcje kontrolujące przepływ sterowania .......................................................... 71
if-else ................................................................................................................. 71
switch ................................................................................................................ 73
2.4. Pętle .................................................................................................................. 74
Pętla while .......................................................................................................... 74
Pętla do ............................................................................................................. 74
Pętla for ............................................................................................................. 75
Pętla foreach ...................................................................................................... 75
Kontrola przepływu sterowania w pętlach .............................................................. 76
2.5. Dyrektywy preprocesora C# .................................................................................. 76
Kompilacja warunkowa ........................................................................................ 77
Dyrektywy diagnostyczne ...................................................................................... 79
Regiony (obszary) kodu ........................................................................................ 79
2.6. Łańcuchy znaków ................................................................................................ 79
Stałe łańcuchowe ................................................................................................ 80
Operacje na łańcuchach ....................................................................................... 81
2.7. Typy wyliczeniowe ................................................................................................ 84
Praca z typami wyliczeniowymi .............................................................................. 84
Metody klasy System.Enum ................................................................................. 85
Typy wyliczeniowe i flagi bitowe ............................................................................ 86
2.8. Tablice ............................................................................................................... 87
Deklarowanie i tworzenie tablic ............................................................................. 88
Stosowanie metod i właściwości tablicy System.Array ............................................ 88
2.9. Typy referencyjne i wartościowe ............................................................................ 90
Klasy System.Object i System.ValueType .............................................................. 90
Techniki przydzielania pamięci dla typów referencyjnych i typów wartościowych ........ 91
Technika pakowania ............................................................................................ 92
Podsumowanie różnic pomiędzy typami wartościowymi a typami referencyjnymi ........ 94
2.10. Podsumowanie ................................................................................................... 95
2.11. Sprawdź, czego się nauczyłeś .............................................................................. 95
Rozdział 3. Projektowanie klas w języku C # ......................................................................................... 97
3.1. Wprowadzenie do klas języka C# .......................................................................... 98
3.2. Definiowanie klas ................................................................................................ 98
Atrybuty .............................................................................................................. 99
Modyfikatory dostępu ........................................................................................ 102
Modyfikatory abstract, sealed i static .................................................................. 102
Identyfikator klasy ............................................................................................. 103
Klasy bazowe, interfejsy i dziedziczenie ............................................................... 103
3.3. Przegląd składowych klasy ................................................................................. 104
Modyfikatory dostępu do składowych .................................................................. 104
3.4. Stałe, pola i właściwości .................................................................................... 104
Stałe ................................................................................................................ 106
Pola ................................................................................................................. 107
Spis treści
7
Właściwości ...................................................................................................... 109
Indeksery ......................................................................................................... 111
3.5. Metody ............................................................................................................. 113
Modyfikatory metod ........................................................................................... 113
Przekazywanie parametrów ................................................................................. 118
3.6. Konstruktory ..................................................................................................... 120
Konstruktor instancji ......................................................................................... 120
Konstruktor prywatny ......................................................................................... 124
Konstruktor statyczny ........................................................................................ 125
3.7. Delegacje i zdarzenia ......................................................................................... 126
Delegacje ......................................................................................................... 127
Obsługa zdarzeń z wykorzystaniem delegacji ........................................................ 129
3.8. Przeciążanie operatorów .................................................................................... 136
3.9. Interfejsy .......................................................................................................... 139
Tworzenie i stosowanie interfejsów niestandardowych .......................................... 139
Praca z interfejsami ........................................................................................... 142
3.10. Klasy uniwersalne ............................................................................................. 143
3.11. Struktury .......................................................................................................... 146
Definiowanie struktur ......................................................................................... 147
Stosowanie struktur z metodami i właściwościami ............................................... 148
3.12. Struktury kontra klasy ....................................................................................... 149
Struktury są typami wartościowymi, klasy są typami referencyjnymi ....................... 149
W przeciwieństwie do klas struktury nie mogą być dziedziczone ............................ 150
Ogólne reguły, które należy uwzględniać,
wybierając pomiędzy strukturami a klasami ....................................................... 150
3.13. Podsumowanie ................................................................................................. 151
3.14. Sprawdź, czego się nauczyłeś ............................................................................ 151
Rozdział 4. Praca z obiektami w języku C # ...........................................................................................155
4.1. Tworzenie obiektów ........................................................................................... 156
Przykład: Tworzenie obiektów za pomocą wielu klas fabrykujących ......................... 158
4.2. Obsługa wyjątków .............................................................................................. 159
Klasa System.Exception .................................................................................... 160
Pisanie kodu obsługującego wyjątki .................................................................... 160
Przykład: Obsługa wspólnych wyjątków SystemException ...................................... 163
Tworzenie niestandardowych klas wyjątków ......................................................... 164
Wyjątki nieobsługiwane ...................................................................................... 167
Wskazówki dotyczące obsługi wyjątków ............................................................... 168
4.3. Implementowanie metod klasy System.Object w klasach niestandardowych ........... 170
Metoda ToString() jako narzędzie opisywania obiektów ......................................... 170
Metoda Equals() jako narzędzie porównywania obiektów ....................................... 172
Klonowanie jako sposób tworzenia kopii obiektów ................................................ 174
4.4. Praca z klasami i interfejsami kolekcji technologii .NET ........................................ 176
Interfejsy kolekcji .............................................................................................. 176
Przestrzeń nazw System.Collections ................................................................... 185
Klasy Stack i Queue .......................................................................................... 185
Klasa ArrayList .................................................................................................. 187
Klasa Hashtable ............................................................................................... 188
Przestrzeń nazw System.Collections.Generic ....................................................... 191
4.5. Serializacja obiektów ......................................................................................... 195
Serializacja binarna ........................................................................................... 195
8
C # i .NET
4.6. Zarządzanie cyklem życia obiektów ..................................................................... 199
Odzyskiwanie pamięci w technologii .NET ............................................................ 199
4.7. Podsumowanie .................................................................................................. 205
4.8. Sprawdź, czego się nauczyłeś ............................................................................. 205
Część II Tworzenie aplikacji z wykorzystaniem biblioteki klas platformy
.NET Framework
207
Rozdział 5. Przetwarzanie tekstu i plikowe operacje wejścia-wyjścia w języku C # ...................... 209
5.1. Znaki i format Unicode ....................................................................................... 210
Format Unicode ................................................................................................. 211
Praca ze znakami .............................................................................................. 212
5.2. Klasa String ...................................................................................................... 215
Tworzenie łańcuchów ......................................................................................... 216
Przegląd operacji na łańcuchach znakowych ........................................................ 218
5.3. Porównywanie łańcuchów znakowych .................................................................. 219
Stosowanie metody String.Compare() ................................................................. 219
Stosowanie metody String.CompareOrdinal() ....................................................... 221
5.4. Przeszukiwanie, modyfikowanie i kodowanie zawartości łańcuchów ....................... 222
Przeszukiwanie zawartości łańcuchów ................................................................. 222
Przeszukiwanie łańcuchów zawierających pary zastępcze ...................................... 222
Przekształcanie łańcuchów ................................................................................. 223
Kodowanie łańcuchów ....................................................................................... 225
5.5. Klasa StringBuilder ............................................................................................ 226
Przegląd składowych klasy StringBuilder .............................................................. 227
Konkatenacja w klasie StringBuilder kontra tradycyjna konkatenacja łańcuchów ..... 228
5.6. Formatowanie wartości liczbowych oraz daty i godziny .......................................... 229
Konstruowanie elementów formatowania ............................................................ 230
Formatowanie wartości liczbowych ...................................................................... 231
Formatowanie daty i godziny ............................................................................... 231
5.7. Wyrażenia regularne .......................................................................................... 236
Klasa Regex ..................................................................................................... 237
Tworzenie wyrażeń regularnych ........................................................................... 242
Przykład dopasowywania wzorca do łańcucha ...................................................... 242
Praca z grupami ................................................................................................ 245
Przykłady stosowania wyrażeń regularnych ........................................................... 247
5.8. Przestrzeń nazw System.IO — klasy obsługujące odczytywanie i zapisywanie
strumieni danych ............................................................................................... 248
Klasa Stream .................................................................................................... 249
Klasa FileStream ............................................................................................... 249
Klasa MemoryStream ........................................................................................ 251
Klasa BufferedStream ....................................................................................... 252
Stosowanie klas StreamReader i StreamWriter odpowiednio do odczytywania
i zapisywania wierszy tekstu ............................................................................. 253
Klasy StringWriter i StringReader ........................................................................ 255
Szyfrowanie danych za pomocą klasy CryptoStream ............................................. 256
5.9. Przestrzeń nazw System.IO — katalogi i pliki ....................................................... 259
Klasa FileSystemInfo ......................................................................................... 259
Praca z katalogami za pomocą klas DirectoryInfo, Directory oraz Path .................... 260
Praca z plikami za pomocą klas FileInfo i File ....................................................... 263
5.10. Podsumowanie ................................................................................................. 265
5.11. Sprawdź, czego się nauczyłeś ............................................................................ 266

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin