C Receptury Wydanie II.pdf

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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin