[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
C#. Receptury.
SPIS TREœCI
Wydanie II
Autorzy: Jay Hilyard, Stephen Teilhet
T³umaczenie: Rados³aw Meryk (przedmowa,
rozdz. 1 – 11), Daniel Kaczmarek (rozdz. 12 – 20)
ISBN: 83-246-0476-6
Tytu³ orygina³
Format: B5, stron: 1064
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Zbiór gotowych rozwi¹zañ dla programistów C# i .NET 2.0
Przetwarzanie liczb i tekstów
Obs³uga b³êdów i wyj¹tków
Aplikacje sieciowe
C# to jeden z jêzyków programowania przeznaczonych dla platformy .NET. Zosta³ tak
skonstruowany, ¿e programiœci, którzy wczeœniej korzystali z jêzyków Java b¹dŸ C++,
bez problemu opanuj¹ zasady programowania w C#. Wed³ug twórcy C# — firmy
Microsoft — jêzyk ten jest nowatorskim narzêdziem programowania na platformie .NET,
niesprawiaj¹cym k³opotów programistom znaj¹cym inne jêzyki, a jednoczeœnie
zapewniaj¹cym wiêksz¹ kontrolê nad dzia³aj¹cym kodem w fazie wykonywania.
W nowej wersji platformy .NET, oznaczonej numerem 2.0, wprowadzono równie¿
now¹ wersjê jêzyka C#, oferuj¹c¹ dodatkowe mo¿liwoœci.
Ksi¹¿ka „C#. Receptury. Wydanie II” to zbiór ponad 300 porad, które programistom C#
pomog¹ rozwi¹zaæ zadania programistyczne, z jakim spotykaj¹ siê w codziennej pracy.
Przedstawiono w niej metody przetwarzania danych tekstowych i liczbowych, zasady
korzystania z wyra¿eñ regularnych oraz typów generycznych — nowoœci w C# 2.0.
Omówiono sposoby przetwarzania plików XML, obs³ugê wyj¹tków oraz regu³y tworzenia
aplikacji sieciowych ASP.NET i aplikacji dla systemu Windows.
Operacje na liczbach
Przetwarzanie ci¹gów znaków
Typy generyczne
Kolekcje i iteratory
Dzienniki zdarzeñ
Obs³uga zdarzeñ
Korzystanie z wyra¿eñ regularnych
Operacje na systemie plików
Tworzenie aplikacji sieciowych
Zabezpieczanie kodu
Przyspiesz tempo swojej pracy — korzystaj z gotowych rozwi¹zañ
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOœCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Przedmowa ....................................................................................................................17
1. Liczby i typy wyliczeniowe .......................................................................................... 27
1.0. Wprowadzenie
27
1.1. Określanie przybliżonej równości pomiędzy wartością ułamkową
a zmiennoprzecinkową
28
1.2. Konwersja stopni na radiany
30
1.3. Konwersja radianów na stopnie
31
1.4. Zastosowanie operatora negacji bitowej do danych różnych typów
31
1.5. Sprawdzenie, czy liczba jest parzysta czy nieparzysta
33
1.6. Uzyskanie bardziej znaczącego i mniej znaczącego słowa liczby
34
1.7. Konwersja liczby z innego systemu liczbowego na dziesiętny
35
1.8. Sprawdzenie, czy ciąg znaków reprezentuje prawidłową liczbę
37
1.9. Zaokrąglanie wartości zmiennoprzecinkowych
37
1.10. Wybór algorytmu zaokrąglania
38
1.11. Zamiana stopni Celsjusza na stopnie Fahrenheita
39
1.12. Zamiana stopni Fahrenheita na stopnie Celsjusza
40
1.13. Bezpieczna konwersja liczb do mniejszego rozmiaru
40
1.14. Wyznaczanie długości dowolnego z trzech boków trójkąta prostokątnego
43
1.15. Obliczanie kątów trójkąta prostokątnego
44
1.16. Wyświetlanie wartości typu wyliczeniowego w postaci tekstowej
45
1.17. Konwersja zwykłego tekstu na odpowiedniki w postaci wartości typu
wyliczeniowego
47
1.18. Sprawdzanie poprawności wartości typu wyliczeniowego
48
1.19. Sprawdzanie poprawności typu wyliczeniowego z atrybutem Flags
50
1.20. Zastosowanie elementów typu wyliczeniowego w masce bitowej
52
1.21. Sprawdzanie, czy ustawiono jedną czy kilka flag w danych
typu wyliczeniowego
55
1.22. Wyznaczanie części całkowitej zmiennej typu decimal lub double
58
5
2. Znaki i ciągi znaków ..................................................................................................... 59
2.0. Wprowadzenie
59
2.1. Określenie rodzaju znaku w zmiennej char
59
2.2. Sprawdzanie, czy znak znajduje się w określonym zakresie
62
2.3. Porównywanie znaków z rozróżnianiem wielkości liter i bez niego
63
2.4. Wyszukiwanie wszystkich wystąpień znaku w ciągu
65
2.5. Wyszukiwanie wszystkich wystąpień jednego ciągu znaków w innym
67
2.6. Implementacja prostego analizatora dzielącego tekst na słowa
71
2.7. Zarządzanie rozróżnianiem wielkich i małych liter podczas porównywania
dwóch ciągów znaków
73
2.8. Porównywanie jednego ciągu znaków z początkiem lub końcem innego
74
2.9. Wstawianie tekstu do ciągu znaków
75
2.10. Usuwanie lub zastępowanie znaków w ciągu
76
2.11. Kodowanie danych binarnych w formacie Base64
78
2.12. Dekodowanie danych binarnych zakodowanych w formacie Base64
79
2.13. Konwersja obiektu String zwróconego w formacie Byte[] na postać String
80
2.14. Przekazywanie ciągu znaków do metody, która akceptuje wyłącznie
dane typu byte[]
82
2.15. Konwersja ciągów znaków na dane innych typów
83
2.16. Formatowanie danych w ciągach znaków
86
2.17. Tworzenie ciągu znaków rozdzielanego separatorami
89
2.18. Wyodrębnianie elementów z tekstu rozdzielanego separatorami
90
2.19. Ustawienie maksymalnej liczby znaków dla obiektów klasy StringBuilder
91
2.20. Przetwarzanie w pętli wszystkich znaków w ciągu
92
2.21. Poprawa wydajności porównywania ciągów znaków
94
2.22. Poprawa wydajności aplikacji wykorzystujących klasę StringBuilder
97
2.23. Usuwanie znaków z początku i (lub) końca ciągu
100
2.24. Sprawdzanie, czy ciąg znaków jest pusty lub zawiera wartość null
101
2.25. Dołączanie wiersza
101
2.26. Kodowanie danych przekazywanych porcjami
102
3. Klasy i struktury .......................................................................................................... 109
3.0. Wprowadzenie
109
3.1. Tworzenie struktur działających jak unie
111
3.2. Wyprowadzanie wartości typu w postaci ciągu znaków
113
3.3. Konwersja znakowej reprezentacji obiektu na obiekt
118
3.4. Implementacja polimorfizmu za pomocą abstrakcyjnych klas bazowych
122
3.5. Zapewnienie możliwości sortowania danych zdefiniowanego typu
127
3.6. Zapewnienie możliwości wyszukiwania danych typu
132
3.7. Pośrednie przeciążanie operatorów +=, -=, /= i *=
136
6
Spis treści
3.8. Pośrednie przeciążanie operatorów &&, || i ?:
139
3.9. Włączanie i wyłączanie bitów
141
3.10. Tworzenie bezbłędnych wyrażeń
145
3.11. Upraszczanie wyrażeń logicznych
147
3.12. Konwersja prostych typów danych w sposób niezależny od języka
150
3.13. Kiedy należy używać operatora cast, a kiedy as lub is?
156
3.14. Konwersja za pomocą operatora as
157
3.15. Sprawdzanie typu zmiennej za pomocą operatora is
159
3.16. Implementacja polimorfizmu za pomocą interfejsów
162
3.17. Wywoływanie tej samej metody dla wielu typów obiektowych
165
3.18. Implementacja wywoływanej zwrotnie metody powiadamiającej
z wykorzystaniem interfejsów
167
3.19. Wykorzystanie wielu punktów wejścia w celu stworzenia
kilku wersji aplikacji
175
3.20. Zapobieganie tworzeniu częściowo zainicjowanych obiektów
176
3.21. Zwracanie wielu elementów przez metodę
178
3.22. Analiza parametrów wiersza polecenia
181
3.23. Przystosowanie klasy do współpracy z obiektami COM
188
3.24. Inicjowanie stałej w fazie wykonywania programu
192
3.25. Pisanie kodu zgodnego z jak największą liczbą zarządzanych języków
195
3.26. Tworzenie klas, które można klonować
196
3.27. Zapewnienie niszczenia obiektu
199
3.28. Zwalnianie obiektu COM z poziomu zarządzanego kodu
202
3.29. Tworzenie pamięci podręcznej obiektów
203
3.30. Wycofywanie zmian wprowadzonych w obiektach
212
3.31. Zwalnianie niezarządzanych zasobów
218
3.32. Wyszukiwanie operacji pakowania i rozpakowania
224
4. Typy generyczne ......................................................................................................... 227
4.0. Wprowadzenie
227
4.1. Gdzie i kiedy korzystać z typów generycznych?
227
4.2. Podstawowe wiadomości o typach generycznych
228
4.3. Odczytywanie obiektu Type dla danych typu generycznego
235
4.4. Zastępowanie typu ArrayList jego generycznym odpowiednikiem
236
4.5. Zastąpienie obiektów Stack i Queue ich generycznymi odpowiednikami
240
4.6. Implementacja powiązanych list
244
4.7. Tworzenie typu wartości, który można zainicjować wartością null
247
4.8. Odwrócenie porządku posortowanej listy
249
4.9. Tworzenie kolekcji tylko do odczytu z wykorzystaniem
typów generycznych
271
4.10. Zastąpienie typu Hashtable jego generycznym odpowiednikiem
273
Spis treści
7
4.11. Korzystanie z pętli foreach dla generycznego typu Dictionary
276
4.12. Ograniczenia dla argumentów opisujących typy
277
4.13. Inicjowanie zmiennych generycznych na ich wartości domyślne
279
5. Kolekcje ....................................................................................................................... 281
5.0. Wprowadzenie 281
5.1. Zamiana miejscami dwóch elementów w tablicy 283
5.2. Szybkie odwracanie tablicy 284
5.3. Odwracanie tablic dwuwymiarowych 286
5.4. Odwracanie tablic postrzępionych 288
5.5. Bardziej uniwersalna klasa StackTrace 289
5.6. Określanie liczby wystąpień elementu na liście List<T> 294
5.7. Wyodrębnianie wszystkich egzemplarzy określonego elementu z listy List<T> 297
5.8. Wstawianie i usuwanie elementów z tablicy
300
5.9. Utrzymywanie listy List<T> w stanie posortowanym
302
5.10. Sortowanie indeksów i (lub) wartości obiektu klasy Dictionary
304
5.11. Tworzenie obiektu Dictionary z ograniczeniami dla wartości minimalnej
i maksymalnej
307
5.12. Wyświetlanie danych z tablicy w postaci ciągu znaków rozdzielanych
separatorami 310
5.13. Zapisywanie migawek list w tablicy 311
5.14. Utrzymywanie kolekcji pomiędzy sesjami aplikacji 312
5.15. Sprawdzanie wszystkich elementów tablicy Array bądź List<T> 314
5.16. Wykonywanie operacji dla każdego elementu danych typu Array bądź List<T> 315
5.17. Tworzenie obiektów tylko do odczytu typu Array lub List<T>
317
6. Iteratory i typy częściowe .......................................................................................... 319
6.0. Wprowadzenie
319
6.1. Implementacja zagnieżdżonych pętli foreach dla klasy
320
6.2. Tworzenie własnej obsługi pętli foreach
324
6.3. Tworzenie iteratorów dla typu generycznego
327
6.4. Tworzenie iteratora dla typu niegenerycznego
329
6.5. Tworzenie iteratorów z parametrami
331
6.6. Definiowanie wielu iteratorów dla jednego typu
333
6.7. Implementacja iteratorów jako operatorów przeciążonych
336
6.8. Wymuszone zatrzymywanie iteratora
342
6.9. Obsługa bloku finally w iteratorach
344
6.10. Organizacja implementacji interfejsów
347
6.11. Generowanie kodu spoza głównej ścieżki
351
8
Spis treści
[ Pobierz całość w formacie PDF ]