C_Receptury_Wydanie_II_cshre2.pdf

IDZ DO

PRZYK£ADOW Y ROZDZIA£

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³ u: C# Cookbook

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

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

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

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

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

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

Spis treści

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: