Poznaj najlepsze techniki pisania kodu w Delphi!

• Klasy generyczne, metody anonimowe i atrybuty — nowe funkcjonalności języka Delphi
• Testy jednostkowe, poprawianie jakości kodu i wykorzystanie platformy izolacyjnej
• Wstrzykiwanie zależności a tworzenie czytelnego, luźno sprzężonego i łatwego do testowania kodu

Wbrew pozorom na świecie pracuje bardzo wielu programistów posługujących się językiem Delphi. Sęk w tym, że większość z nich nie ma pojęcia o niezwykłych i użytecznych funkcjonalnościach dostępnych w nowszych wersjach tego języka oraz nie umie zastosować tych narzędzi we własnej pracy. Jeśli czujesz, że i Ty zaliczasz się do tego grona, a brak umiejętności sprawia, że nie możesz rozwinąć skrzydeł, ta książka jest dla Ciebie. Są w niej opisane niezwykle przydatne narzędzia oraz sytuacje, w których te narzędzia sprawdzają się szczególnie dobrze, a także kilka ogólnie dostępnych platform.

W gruncie rzeczy ta książka jest poświęcona wyłącznie tworzeniu nowego, dobrego kodu w języku Delphi. Nie znajdziesz w niej nic o projektowaniu okienek, języku VCL ani platformie FMX, ale jeśli chcesz się dowiedzieć więcej o kodowaniu interfejsów zamiast implementacji, o właściwych sposobach korzystania z wyjątków i o ich obsłudze, o testowaniu i poprawianiu kodu, o zastosowaniu platformy String for Delphi do lepszego zarządzania kolekcjami danych albo o uzyskiwaniu wglądu w kod podczas jego wykonywania za pomocą nowego, potężnego narzędzia RTTI, z pewnością niniejsza publikacja Cię zachwyci.

• Wyjątki i ich obsługa
• Interfejsy i typy generyczne
• Metody anonimowe
• Kolekcje i enumeratory w Delphi
• Interfejs IEnumerable
• Informacje RTTI i atrybuty
• Klasa TVirtualInterface
• Wstrzykiwanie zależności
• Testy jednostkowe
• Testy z użyciem platformy izolacyjnej

Rozdziały:

Przedmowa (9)

Wprowadzenie (11)

Podziękowania (13)

Platformy wykorzystane w książce (15)

Rozdział 1. Wyjątki i ich obsługa (17)

• 1.1. Wprowadzenie (17)
• 1.2. Strukturalna obsługa wyjątków (17)
• 1.3. Jak nie korzystać z wyjątków (18)
  • Nie "połykaj" wyjątków (18)
  • Nie przechwytuj wyjątków bezkrytycznie (18)
  • Nie nadużywaj wyjątków (19)
  • Nie używaj wyjątków jako podstawowego sposobu sygnalizacyjnego (19)
• 1.4. Jak prawidłowo korzystać z wyjątków (20)
  • Używaj wyjątków tak, aby kod ich obsługi nie zakłócał realizacji programu (20)
  • Twórcy aplikacji powinni tylko przechwytywać wyjątki (20)
  • Przechwytuj tylko wybrane wyjątki (20)
  • Wyjątki mogą zgłaszać twórcy komponentów i bibliotek (22)
  • Zgłaszaj własne niestandardowe wyjątki (22)
  • Niech inni programiści widzą komunikaty o wyjątkach (22)
  • Śmiało podawaj dokładne komunikaty o wyjątkach (23)
  • W bibliotece twórz dwie wersje każdej metody (23)
• 1.5. Wnioski (24)

Rozdział 2. Interfejsy (25)

• 2.1. Wprowadzenie (25)
• 2.2. Rozprzęganie kodu (25)
• 2.3. Czym jest interfejs? (26)
• 2.4. Interfejsy są wszędzie (26)
• 2.5. Prosty przykład (28)
• 2.6. Implementacja interfejsu (29)
• 2.7. Kilka dodatkowych uwag (30)
• 2.8. Dziedziczenie interfejsów (30)
• 2.9. Inne uwagi warte zapamiętania (31)
• 2.10. Klasa TInterfacedObject (31)
• 2.11. Jak poprawnie używać interfejsów (33)
• 2.12. Dlaczego należy używać interfejsów? (34)
  • Kodowanie abstrakcyjne (34)
  • Implementacje podłączane (35)
  • Komunikacja między modułami (35)
  • Testowalny kod (36)
  • Wzorce kodu (36)

Rozdział 3. Typy generyczne (37)

• 3.1. Z pomocą przybywa typ generyczny (38)
• 3.2. Ograniczenia (39)
  • Ograniczenie constructor (40)
  • Ograniczenie class (40)
  • Ograniczenie record (41)
  • Ograniczenie interface (42)
  • Przekazywanie rekordów jako typów parametrycznych (42)
• 3.3. Interfejsy generyczne (43)
• 3.4. Metody generyczne (43)
• 3.5. Kolekcje generyczne (44)
• 3.6. Myślenie generyczne (45)
• 3.7. Wystudiowany, prosty przykład (45)
• 3.8. Praktyczny przykład (46)
  • Typ TWylicz (46)
  • Problemy z typami generycznymi (48)
• 3.9. Wnioski (49)
• 3.10. Wywiad z typem generycznym (49)

Rozdział 4. Metody anonimowe (51)

• 4.1. Wprowadzenie (51)
• 4.2. Definicja (51)
• 4.3. Po co to wszystko? (52)
  • Prosty przykład (53)
  • Metody anonimowe jako zmienne (55)
• 4.4. Domknięcia (55)
• 4.5. Deklaracje standardowe (56)
• 4.6. Praktyczny przykład (57)
• 4.7. Inny, jeszcze ciekawszy przykład (58)
  • Metody anonimowe są bardzo elastyczne (59)
• 4.8. Metody anonimowe w bibliotece RTL (61)
  • Klasa TThread i metody anonimowe (61)
• 4.9. Predykaty (61)
  • I co z tego? (61)
• 4.10. Wnioski (63)
• 4.11. Wywiad z metodą anonimową (63)

Rozdział 5. Kolekcje (65)

• 5.1. Wprowadzenie (65)
• 5.2. Ogólne uwagi dotyczące kolekcji (65)
• 5.3. Kolekcje w języku Delphi (66)
  • Kolekcja TList (66)
  • Kolekcja TStack (68)
  • Kolekcja TQueue (69)
  • Kolekcja TDictionary (70)
  • Kolekcje obiektów (72)
• 5.4. Kolekcje w platformie Delphi Spring Framework (72)
  • Ogólne informacje (72)
  • Dwa nieopisane dotychczas typy kolekcji (73)
• 5.5. Dlaczego należy używać kolekcji Spring4D? (73)
• 5.6. Wnioski (74)

Rozdział 6. Enumeratory w Delphi (75)

• 6.1. Wprowadzenie (75)
• 6.2. Interfejs IEnumerator (77)
• 6.3. Specjalistyczne enumeratory (78)
• 6.4. Klasa TEnumerable w module Generics.Collections (80)
• 6.5. Wnioski (80)

Rozdział 7. Interfejs IEnumerable (81)

• 7.1. Interfejs IEnumerable (82)
• 7.2. Predykaty (83)
• 7.3. Wywiad z interfejsem IEnumerable (IEoT) (87)

Rozdział 8. Informacje RTTI (89)

• 8.1. Wprowadzenie (89)
• 8.2. Typ TValue (90)
• 8.3. RTTI i klasy (92)
  • Klasa TRttiType (94)
• 8.4. RTTI i instancje klas (96)
  • Odczytywanie i nadawanie wartości (96)
  • Wywoływanie metod (97)
• 8.5. Uwagi ogólne (98)
• 8.6. RTTI i inne typy danych (98)
  • RTTI i typy porządkowe (99)
  • RTTI i rekordy (99)
  • RTTI i tabele (99)
• 8.7. Inne metody RTTI (100)
• 8.8. Dyrektywy kompilatora związane z RTTI (100)
  • Silna konsolidacja typów (102)
• 8.9. Wnioski (102)

Rozdział 9. Atrybuty (103)

• 9.1. Wprowadzenie (103)
• 9.2. Czym są atrybuty? (103)
• 9.3. Prosty przykład (107)
• 9.4. Wnioski (109)
• 9.5. Wywiad z atrybutem (109)

Rozdział 10. Klasa TVirtualInterface (111)

• 10.1. Trochę lepsza klasa TVirtualInterface (115)
• 10.2. Naprawdę użyteczny przykład (116)
• 10.3. Interfejs IProstaAtrapa (116)
• 10.4. Klasa TProstaImitacja (118)
• 10.5. Wnioski (120)

Rozdział 11. Wstęp do wstrzykiwania zależności (121)

• 11.1. Wprowadzenie (121)
• 11.2. Czym jest zależność? (121)
• 11.3. Prawo Demeter (122)
• 11.4. Przykład projektu (122)
• 11.5. Prawo Demeter w języku Delphi (123)
• 11.6. Przykładowy kod krok po kroku (124)
• 11.7. Kontener wstrzykiwania zależności (131)
• 11.8. Wnioski (134)

Rozdział 12. Więcej o wstrzykiwaniu zależności (135)

• 12.1. Zależności opcjonalne (136)
• 12.2. Wstrzykiwanie metod przypisujących (136)
• 12.3. Wstrzykiwanie metod (137)
• 12.4. Kontener Spring Container i klasa ServiceLocator (138)
  • Rejestrowanie interfejsów (139)
  • Zarządzanie czasem życia obiektów (140)
  • Niestandardowe tworzenie obiektów (141)
  • Określenie domyślnego obiektu (142)
  • Rejestrowanie tych samych klas dla dwóch interfejsów (142)
  • Wstrzykiwanie pól i właściwości podczas rejestracji (142)
  • Wykorzystanie rejestracji do wstrzykiwania konstruktorów i metod (144)
• 12.5. Rejestrowanie elementów za pomocą atrybutów (145)
• 12.6. Klasa ServiceLocator jako antywzorzec (147)
• 12.7. Podsumowanie wstrzykiwania zależności (151)

Rozdział 13. Testy jednostkowe (153)

• 13.1. Co to są testy jednostkowe? (153)
  • Co to jest "jednostka"? (154)
  • Czy rzeczywiście wykonuję testy jednostkowe? (154)
  • Czym jest platforma izolacyjna? (154)
• 13.2. Po co wykonywać testy jednostkowe? (157)
  • Dzięki testom jednostkowym wyszukasz błędy (157)
  • Dzięki testom jednostkowym unikniesz błędów (157)
  • Dzięki testom jednostkowym oszczędzisz czas (157)
  • Testy jednostkowe zapewniają spokój (157)
  • Testy jednostkowe dokumentują właściwe użycie klas (158)
• 13.3. Testy jednostkowe w Delphi (158)
  • Platforma DUnit (158)
  • Platforma DUnitX (158)
• 13.4. Ogólne zasady testów jednostkowych (159)
  • Testuj jedną klasę w izolacji (159)
  • Przestrzegaj zasady AAA (159)
  • Najpierw twórz proste testy, "krótkie i na temat" (159)
  • Twórz testy sprawdzające zakresy (159)
  • Testuj granice (160)
  • Jeżeli to możliwe, sprawdź całe spektrum możliwych wartości (160)
  • Jeżeli to możliwe, sprawdź każdy przebieg kodu (160)
  • Twórz testy wyszukujące błędy i poprawiaj je (160)
  • Każdy test musi być niezależny od innych testów (160)
  • Stosuj w teście tylko jedną asercję (161)
  • Nadawaj testom czytelne nazwy i nie przejmuj się, że są długie (161)
  • Sprawdzaj, czy każdy wyjątek jest rzeczywiście zgłaszany (161)
  • Unikaj stosowania metod CheckTrue i Assert.IsTrue (161)
  • Regularnie wykonuj testy (161)
  • Wykonuj testy przy każdorazowej kompilacji kodu (161)
• 13.5. Programowanie uwzględniające testy (162)
• 13.6. Prosty przykład (162)

Rozdział 14. Testy z użyciem platformy izolacyjnej (169)

• 14.1. Krótkie przypomnienie (169)
• 14.2. Platformy izolacyjne w Delphi (170)
• 14.3. Jak zacząć (170)
  • Do akcji wkracza platforma izolacyjna (170)
  • Prosta atrapa (170)
  • Testowanie dziennika (172)
  • Atrapy, które wykonują operacje (173)
  • Zależności wykonujące oczekiwane operacje (176)
  • Zależności zgłaszające wyjątki (178)
  • W teście stosuj tylko jedną imitację (179)
  • Oczekiwane parametry muszą być zgodne z rzeczywistymi (180)
• 14.4. Wnioski (180)

Dodatek A. Materiały (181)

• Wstrzykiwanie zależności (181)
• Testy jednostkowe (181)
• Systemy kontroli kodu źródłowego (182)
  • Subversion (182)
  • Git (182)
  • Mercurial (182)
• Projekty (182)
• Inne ciekawe materiały (183)

Dodatek B. Moja przygoda z Delphi (185)

Skorowidz (189)