okladka

Wzorce projektowe są modelami gotowych rozwiązań problemów programistycznych, przed jakimi często stają twórcy oprogramowania. Dzięki nim nie musimy ponownie "wymyślać koła". Dysponując wzorcami projektowymi, jesteśmy w stanie szybciej i efektywniej zbudować aplikację, ponieważ koncentrujemy się na samej implementacji algorytmu, a nie na jego opracowaniu. Najczęściej stosowane, klasyczne już, 23 wzorce projektowe opracowane przez twórców notacji UML implementowano już w wielu językach programowania. Jak sprawdzą się w połączeniu z jedną z najnowszych technologii, jaką jest .NET?

"C#. Wzorce projektowe" to kompletny przewodnik po wzorcach projektowych w C# i środowisku .NET. Przedstawia sposoby wykorzystania obiektowych cech języka C# i tworzenia eleganckiego kodu poprzez zastosowanie wzorców projektowych oraz korzystanie z ogromnych możliwości oferowanych przez biblioteki klas FCL dla środowiska Microsoft .NET. Wszystkie przedstawione w książce wzorce projektowe zostały zilustrowane przykładami kodu oraz diagramami UML, co ułatwia ich zrozumienie oraz zastosowanie w praktyce.

  • Podstawowe wiadomości o wzorcach projektowych
  • Interfejsy i klasy abstrakcyjne
  • Wzorce interfejsów
  • Wzorce odpowiedzialności
  • Wzorce konstrukcyjne
  • Wprowadzenie do operacji
  • Wzorce operacji
  • Wzorce rozszerzeń
  • Wzorce rozszerzające

Poznaj zastosowanie wzorców projektowych
i wykorzystaj je w swojej pracy.


Wprowadzenie (13)
1. Wstęp (15)
  • Dlaczego wzorce? (15)
  • Dlaczego wzorce projektowe? (16)
  • Dlaczego C#? (16)
  • UML (17)
  • Zadania (17)
  • Układ książki (18)
  • Witamy w firmie Oozinoz! (19)
  • Podsumowanie (19)
Część I Wzorce interfejsów (21)
2. Wprowadzenie do interfejsów (23)
  • Interfejsy a klasy abstrakcyjne (23)
  • Interfejsy a delegacje (24)
  • Interfejsy a właściwości (28)
  • Szczegóły interfejsów (28)
  • Podsumowanie (29)
  • Poza zwykłe interfejsy (29)
3. Adapter (31)
  • Adaptacja kodu do potrzeb interfejsu (31)
  • Adaptery klas i obiektów (34)
  • Adaptacja danych w .NET (37)
  • Podsumowanie (41)
4. Facade (Fasada) (43)
  • Zwykła fasada (43)
  • Refaktoryzacja do postaci fasady (45)
  • Fasady, klasy narzędziowe i demonstracje (54)
  • Podsumowanie (55)
5. Composite (Kompozyt) (57)
  • Zwykły kompozyt (57)
  • Rekurencja w kompozytach (58)
  • Kompozyty, drzewa i cykle (59)
  • Kompozyty z cyklami (64)
  • Konsekwencje cykli (67)
  • Podsumowanie (67)
6. Bridge (Pomost) (69)
  • Zwykła abstrakcja (69)
  • Od abstrakcji do pomostu (71)
  • Sterowniki jako pomosty (73)
  • Sterowniki baz danych (73)
  • Podsumowanie (74)
Część II Wzorce odpowiedzialności (75)
7. Pojęcie odpowiedzialności (77)
  • Zwykła odpowiedzialność (77)
  • Kontrola odpowiedzialności poprzez kontrolę dostępu (79)
  • Podsumowanie (81)
  • Poza zwykłą odpowiedzialność (82)
8. Singleton (83)
  • Zasada działania wzorca Singleton (83)
  • Singletony a wątki (84)
  • Rozpoznawanie singletonów (86)
  • Podsumowanie (86)
9. Observer (Obserwator) (87)
  • Obsługa wzorca Observer w C# (87)
  • Sposób działania delegacji (88)
  • GUI - klasyczny przykład obserwacji (91)
  • Model-View-Controller (97)
  • Warstwy (99)
  • Podsumowanie (103)
10. Mediator (105)
  • Klasyczny przykład: mediacja w GUI (105)
  • Mediatorzy integralności relacji (109)
  • Podsumowanie (115)
11. Proxy (Pośrednik) (117)
  • Prosty pośrednik (117)
  • Pośrednik danych (121)
  • Zdalny pośrednik (126)
  • Podsumowanie (130)
12. Chain of Responsibility (Łańcuch odpowiedzialności) (131)
  • Zwykły łańcuch odpowiedzialności (131)
  • Wprowadzanie łańcucha odpowiedzialności (132)
  • Zaczepianie łańcucha (135)
  • Łańcuch odpowiedzialności bez kompozytów (137)
  • Podsumowanie (137)
13. Flyweight (Waga piórkowa) (139)
  • Niezmienność (139)
  • Wydzielenie niezmiennej części obiektu (140)
  • Współużytkowanie obiektów (141)
  • Podsumowanie (145)
Część III Wzorce konstrukcyjne (147)
14. Pojęcie konstrukcji (149)
  • Kilka zadań konstrukcyjnych (149)
  • Podsumowanie (152)
  • Poza zwykłą konstrukcję (152)
15. Builder (Budowniczy) (153)
  • Zwykły budowniczy (153)
  • Budowanie z ograniczeniami (155)
  • Pobłażliwy budowniczy (157)
  • Podsumowanie (158)
16. Factory Method (Metoda fabrykująca) (159)
  • Klasyczny przykład: enumeratory (159)
  • Rozpoznawanie wzorca Factory Method (161)
  • Kontrola wyboru klasy (161)
  • Metody fabryczne w hierarchiach równoległych (163)
  • Podsumowanie (164)
17. Abstract Factory (Fabryka abstrakcji) (167)
  • Klasyczny przykład: zestawy GUI (167)
  • Fabryki abstrakcji a metody fabrykujące (172)
  • Przestrzenie nazw a fabryki abstrakcji (175)
  • Podsumowanie (175)
18. Prototype (Prototyp) (177)
  • Prototypy jako fabryki (177)
  • Klonowanie prototypów (178)
  • Podsumowanie (181)
19. Memento (183)
  • Klasyczny przykład: cofnięcie ostatniej czynności (183)
  • Trwałe memento (190)
  • Memento wielosesyjne (191)
  • Podsumowanie (193)
Część IV Wzorce operacji (195)
20. Operacje - wprowadzenie (197)
  • Operacje a metody (197)
  • Sygnatury (198)
  • Delegacje (199)
  • Wyjątki (200)
  • Algorytmy a polimorfizm (201)
  • Podsumowanie (202)
  • Poza operacje niestandardowe (203)
21. Template Method (Metoda szablonu) (205)
  • Klasyczny przykład: sortowanie (205)
  • Uzupełnianie algorytmu (208)
  • Punkty zaczepienia w Template Method (210)
  • Refaktoryzacja do wzorca Template Method (211)
  • Podsumowanie (213)
22. State (Stan) (215)
  • Modelowanie stanów (215)
  • Refaktoryzacja do wzorca State (218)
  • Stałe obiekty stanu (222)
  • Podsumowanie (224)
23. Strategy (Strategia) (225)
  • Modelowanie strategii (225)
  • Refaktoryzacja do wzorca Strategy (227)
  • Porównanie wzorców Strategy i State (232)
  • Porównanie wzorców Strategy i Template Method (232)
  • Podsumowanie (232)
24. Command (Polecenie) (235)
  • Klasyczny przykład: polecenia menu (235)
  • Zastosowanie wzorca Command w usługach (236)
  • Punkty zaczepienia w Command (239)
  • Command a inne wzorce (241)
  • Podsumowanie (242)
25. Interpreter (Interpreter) (243)
  • Przykład interpretera (243)
  • Interpretery, języki i parsery (254)
  • Podsumowanie (255)
Część V Wzorce rozszerzeń (257)
26. Wprowadzenie do rozszerzeń (259)
  • Zasady projektowania obiektowego (259)
  • Zasada podstawienia Barbary Liskov (259)
  • Prawo Demeter (261)
  • Usuwanie z kodu "przykrych zapachów" (262)
  • Poza rozszerzenia niestandardowe (263)
  • Podsumowanie (264)
27. Decorator (Dekorator) (265)
  • Klasyczny przykład: strumienie (265)
  • Opakowania funkcji (273)
  • Wykorzystanie dekoratora w graficznym interfejsie użytkownika (279)
  • Decorator a inne wzorce (279)
  • Podsumowanie (279)
28. Iterator (Iterator) (281)
  • Zwykła iteracja (281)
  • Iteracja z bezpiecznymi wątkami (281)
  • Iteracja kompozytu (286)
  • Podsumowanie (296)
29. Visitor (Wizytator) (297)
  • Mechanizm działania wzorca (297)
  • Standardowy wizytator (299)
  • Cykle wizytatora (304)
  • Kontrowersje związane z wizytatorem (308)
  • Podsumowanie (309)
Dodatki (311)
A Dalsze kierunki (313)
  • Wykorzystanie wiedzy zawartej w książce (313)
  • Zrozumienie klasyki (313)
  • Wplatanie wzorców we własny kod (314)
  • Ciągła nauka (315)
B Rozwiązania (317)
C Źródła Oozinoz (383)
  • Pobranie i wykorzystanie źródeł (383)
  • Wykonywanie kodu Oozinoz (383)
  • Pomoc w lokalizacji plików (384)
  • Testowanie kodu za pomocą NUnit (385)
  • Samodzielne szukanie plików (385)
  • Podsumowanie (386)
D Rzut oka na UML (387)
  • Klasy (387)
  • Relacje pomiędzy klasami (389)
  • Interfejsy (390)
  • Delegacje i zdarzenia (391)
  • Obiekty (392)
  • Stany (393)
E Słowniczek (395)
Bibliografia (403)
Skorowidz (405)