Wstrzykiwanie zależności

Spis treści książki

• Okładka
• Strona tytułowa
• Strona redakcyjna
• Spis treści
  • przedmowa
  • podziękowania
  • o książce
  • o autorach
  • o ilustracji na okładce
• Część 1. Umiejscowienie Wstrzykiwania zależności na mapie
  • 1. Podstawy Wstrzykiwania zależności: co, jak i dlaczego
    • 1.1. Pisanie utrzymywalnego kodu
      • 1.1.1. Powszechne mity na temat DI
      • 1.1.2. Rozumienie celu DI
    • 1.2. Prosty przykład: Hello DI!
      • 1.2.1. Kod Hello DI!
      • 1.2.2. Korzyści (płynące) z DI
    • 1.3. Co wstrzykiwać, a czego nie wstrzykiwać
      • 1.3.1. stabilne zależności
      • 1.3.2. niestabilne zależności
    • 1.4. Zakres DI
      • 1.4.1. kompozycja obiektowa
      • 1.4.2. Cykl życia obiektu
      • 1.4.3. Przechwytywanie
      • 1.4.4. DI w trzech wymiarach
    • 1.5. Konkluzje
  • 2. Pisanie ściśle powiązanego kodu
    • 2.1. Budowanie ściśle powiązanej aplikacji
      • 2.1.1. Poznajmy Mary Rowan
      • 2.1.2. Tworzenie warstwy danych
      • 2.1.3. Tworzenie warstwy domeny
      • 2.1.4. Tworzenie warstwy interfejsu użytkownika
    • 2.2. Ocena aplikacji ściśle powiązanej
      • 2.2.1. Ocena grafu zależności
      • 2.2.2. Ocena tworzenia strukturalności
    • 2.3. Analiza braku strukturalności
      • 2.3.1. Analiza wykresu zależności
      • 2.3.2. Analiza interfejsu dostępu do danych
      • 2.3.3. Inne kwestie
    • 2.4. Konkluzja
  • 3. Pisanie luźno powiązanego kodu
    • 3.1. Ponowne budowanie aplikacji e-commerce
      • 3.1.1. Budowanie bardziej utrzymywanego UI
      • 3.1.2. Budowanie niezależnego modelu domeny
      • 3.1.3. Budowanie nowej warstwy dostępu do danych
      • 3.1.4. Implementacja Adaptera IUserContext specyficznego dla ASP.NET Core
      • 3.1.5. Tworzenie aplikacji w podstawie kompozycji
    • 3.2. Analiza luźno powiązanej implementacji
      • 3.2.1. Zrozumienie interakcji między komponentami
      • 3.2.2. Analizowanie nowego grafu zależności
• Część 2. Katalog
  • 4. Wzorce DI
    • 4.1. podstawa kompozycji
      • 4.1.1. Jak działa PODSTAWA KOMPOZYCJI
      • 4.1.2. Użycie KONTENERA DI w PODSTAWIE KOMPOZYCJI
      • 4.1.3. Przykład: Implementowanie PODSTAWY KOMPOZYCJI przy użyciu CZYSTEGO DI
      • 4.1.4. Pozorna eksplozja zależności
    • 4.2. wstrzykiwanie konstruktorem
      • 4.2.1. Jak działa WSTRZYKIWANIE KONSTRUKTOREM
      • 4.2.2. Kiedy używać WSTRZYKIWANIA KONSTRUKTOREM
      • 4.2.3. Znany sposób użycia WSTRZYKIWANIA KONSTRUKTOREM
      • 4.2.4. Przykład: Dodawanie przeliczania walut do wyróżnionych produktów
      • 4.2.5. Podsumowanie
    • 4.3. wstrzykiwanie metodą
      • 4.3.1. Jak działa WSTRZYKIWANIE METODĄ
      • 4.3.2. Kiedy używać WSTRZYKIWANIA METODĄ
      • 4.3.3. Znany sposób użycia WSTRZYKIWANIA METODĄ
      • 4.3.4. Przykład: Dodawanie przewalutowania do ENCJI Product
    • 4.4. WSTRZYKIWANIE WŁAŚCIWOŚCIĄ
      • 4.4.1. Jak działa WSTRZYKIWANIE WŁAŚCIWOŚCIĄ
      • 4.4.2. Kiedy używać WSTRZYKIWANIA WŁAŚCIWOŚCIĄ
      • 4.4.3. Znane zastosowania WSTRZYKIWANIA WŁAŚCIWOŚCIĄ
      • 4.4.4. Przykład: WSTRZYKIWANIE WŁAŚCIWOŚCIĄ jako model rozszerzalności biblioteki do ponownego użycia
    • 4.5. Wybieranie wzorca (do pracy)
  • 5. Antywzorce DI
    • 5.1. ANTYWZORZEC CONTROL FREAK
      • 5.1.1. Przykład: CONTROL FREAK przez nowo powstające ZALEŻNOŚCI
      • 5.1.2. Przykład: CONTROL FREAK przez fabryki
      • 5.1.3. Przykład: control freak przez przeciążone konstruktory
      • 5.1.4. Analiza CONTROL FREAK
    • 5.2. LOKALIZATOR USŁUG
      • 5.2.1. Przykład: ProductService przy użyciu LOKALIZATORA USŁUG
      • 5.2.2. Analiza LOKALIZATORA USŁUG
    • 5.3. kontekst otoczenia
      • 5.3.1. Przykład: Dostęp do czasu przez KONTEKST OTOCZENIA
      • 5.3.2. Przykład: Logowanie przez kontekst otoczenia
      • 5.3.3. Analiza KONTEKSTU OTOCZENIA
    • 5.4. Antywzorzec OGRANICZONEJ KONSTRUKCJI
      • 5.4.1. Przykład: Późne wiązanie ProductRepository
      • 5.4.2. Analiza OGRANICZONEJ KONSTRUKCJI
  • 6. Zapachy kodu
    • 6.1. Radzenie sobie z zapachem kodu Przesadnego Wstrzykiwania Konstruktorem
      • 6.1.1. Rozpoznawanie Przesadnego Wstrzykiwania Konstruktorem
      • 6.1.2. Refaktorowanie z Przesadnego Wstrzykiwania Konstruktorem do Usług fasadowych
      • 6.1.3. Refaktorowanie z Przesadnego Wstrzykiwania Konstruktorem do zdarzeń domeny
    • 6.2. Nadużywanie Fabryk abstrakcyjnych
      • 6.2.1. Nadużywanie Fabryk abstrakcyjnych do pokonania problemów cyklu życia
      • 6.2.2. Nadużywanie Fabryk abstrakcyjnych do wybierania ZALEŻNOŚCI na podstawie danych czasu wykonania
    • 6.3. Naprawianie cyklicznych ZALEŻNOŚCI
      • 6.3.1. Przykład: Cykliczne ZALEŻNOŚCI spowodowane naruszeniem SRP
      • 6.3.2. Analiza cyklu ZALEŻNOŚCI Mary
      • 6.3.3. Refaktoring naruszeń SRP, aby rozwiązać cykl ZALEŻNOŚCI
      • 6.3.4. Powszechne strategie przerywania cyklów ZALEŻNOŚCI
      • 6.3.5. Ostateczność: przerwanie cyklu za pomocą WSTRZYKIWANIA WŁAŚCIWOŚCIĄ
• Część 3. Czyste DI
  • 7. Kompozycja aplikacji
    • 7.1. Komponowanie aplikacji konsolowej
      • 7.1.1. Przykład: Uaktualnienie kursu walut przy użyciu programu UpdateCurrency
      • 7.1.2. Budowanie podstawy kompozycji programu UpdateCurrency
      • 7.1.3. Komponowanie grafów obiektów w CreateCurrencyParser
      • 7.1.4. Głębsze spojrzenie na warstwy UpdateCurrency
    • 7.2. Komponowanie aplikacji UWP
      • 7.2.1. Kompozycja UWP
      • 7.2.2. Przykład: Podłączanie aplikacji typu gruby klient do zarządzania produktami
      • 7.2.3. Implementowanie PODSTAWY KOMPOZYCJI w aplikacji UWP
    • 7.3. Komponowanie aplikacji ASP.NET Core MVC
      • 7.3.1. Tworzenie własnego aktywatora kontrolera
      • 7.3.2. Konstruowanie własnej warstwy middleware przy użyciu CZYSTEGO DI
  • 8. Cykl życia obiektu
    • 8.1. Zarządzanie cyklem życia zależności
      • 8.1.1. Wprowadzenie ZARZĄDZANIA CYKLEM ŻYCIA
      • 8.1.2. Zarządzanie cyklem życia przy użyciu CZYSTEGO DI
    • 8.2. Pracowanie z usuwalnymi zależnościami
      • 8.2.1. Konsumowanie usuwalnych ZALEŻNOŚCI
      • 8.2.2. Zarządzanie usuwalnymi ZALEŻNOŚCIAMI
    • 8.3. Katalog STYLÓW ŻYCIA
      • 8.3.1. styl życia singleton
      • 8.3.2. przejściowy styl życia
      • 8.3.3. zakresowy styl życia
    • 8.4. Złe wybory STYLU ŻYCIA
      • 8.4.1. pojmane zależności
      • 8.4.2. Wybór STYLU ŻYCIA wyciekający do klas konsumujących przez CIEKNĄCE ABSTRAKCJE
      • 8.4.3. Powodowanie błędów współbieżności przez łączenie instancji z cyklem życia jednego wątku
  • 9. Przechwytywanie
    • 9.1. Przedstawienie PRZECHWYTYWANIA
      • 9.1.1. Wzorzec projektowy dekorator
      • 9.1.2. Przykład: Implementowanie audytowania przy użyciu Dekoratora
    • 9.2. Implementowanie ZAGADNIEŃ PRZEKROJOWYCH
      • 9.2.1. Przechwytywanie za pomocą wzorca Bezpiecznik
      • 9.2.2. Raportowanie wyjątków przy użyciu wzorca Dekorator
      • 9.2.3. Zapobieganie nieautoryzowanemu dostępowi do wrażliwej funkcjonalności przy użyciu Dekoratora
  • 10. Rozmyślne Programowanie Aspektowe
    • 10.1. Wprowadzenie do AOP
    • 10.2. Zasady SOLID
      • 10.2.1. zasada pojedynczej odpowiedzialności (srp)
      • 10.2.2. zasada otwarte/zamknięte (ocp)
      • 10.2.3. zasada podstawienia liskov (lsp)
      • 10.2.4. zasada segregacji interfejsów (isp)
      • 10.2.5. zasada odwrócenia zależności (dip)
      • 10.2.6. Zasady solid a przechwytywanie
    • 10.3. SOLID jako sterownik dla AOP
      • 10.3.1. Przykład: Implementowanie funkcjonalności związanych z produktem przy użyciu IProductService
      • 10.3.2. Analiza IProductService z perspektywy SOLID
      • 10.3.3. Ulepszanie projektu przez zastosowanie zasad solid
      • 10.3.4. Dodanie większej liczby ZAGADNIEŃ PRZEKROJOWYCH
      • 10.3.5. Wnioski
  • 11. Programowanie Aspektowe oparte na narzędziach
    • 11.1. Dynamiczne PRZECHWYTYWANIE
      • 11.1.1. Przykład: PRZECHWYTYWANIE za pomocą Castle Dynamic Proxy
      • 11.1.2. Analiza dynamicznego PRZECHWYTYWANIA
    • 11.2. Tkanie w czasie kompilacji
      • 11.2.1. Przykład: Zastosowanie aspektu transakcji przy użyciu tkania w czasie kompilacji
      • 11.2.2. Analiza tkania w czasie kompilacji
• Część 4. Kontenery DI
  • 12. Wprowadzenie do Kontenera DI
    • 12.1. Wprowadzenie do KONTENERÓW DI
      • 12.1.1. Odkrywanie api kontenerów rozwiązującego ZALEŻNOŚCI
      • 12.1.2. automatyczne podłączanie
      • 12.1.3. Przykład: Implementowanie uproszczonego KONTENERA DI, który wspiera AUTOMATYCZNE PODŁĄCZANIE
    • 12.2. Konfigurowanie KONTENERÓW DI
      • 12.2.1. Konfigurowanie kontenerów za pomocą plików konfiguracyjnych
      • 12.2.2. Kontenery konfiguracyjne przy użyciu KONFIGURACJI JAKO KODU
      • 12.2.3. Konfigurowanie kontenerów przez konwencję przy użyciu AUTO-REJESTRACJI
      • 12.2.4. Mieszanie i dopasowywanie podejść konfiguracji
    • 12.3. Kiedy używać KONTENERA DI
      • 12.3.1. Używanie bibliotek trzecich oznacza koszty i ryzyko
      • 12.3.2. CZYSTE DI daje krótszy cykl feedbacku
      • 12.3.3. Werdykt: kiedy używać kontenera di
  • 13. Kontener DI Autofac
    • 13.1. Wprowadzenie do Autofac
      • 13.1.1. Rozwiązywanie obiektów
      • 13.1.2. Konfigurowanie ContainerBuilder
    • 13.2. Zarządzanie cyklem życia
      • 13.2.1. Konfigurowanie zakresów instancji
      • 13.2.2. Zwalnianie komponentów
    • 13.3. Rejestrowanie trudnych API
      • 13.3.1. Konfigurowanie prymitywnych ZALEŻNOŚCI
      • 13.3.2. Rejestrowanie obiektów za pomocą bloków kodu
    • 13.4. Praca z licznymi komponentami
      • 13.4.1. Wybieranie wśród wielu kandydatów
      • 13.4.2. Podłączenie sekwencji
      • 13.4.3. Podłączanie Dekoratorów
      • 13.4.4. Pisanie Kompozytów
  • 14. Kontener DI Simple Injector
    • 14.1. Wprowadzenie do Simple Injector
      • 14.1.1. Tworzenie obiektów
      • 14.1.2. Konfigurowanie kontenera
    • 14.2. Zarządzanie cyklem życia
      • 14.2.1. Konfigurowanie STYLÓW ŻYCIA
      • 14.2.2. Zwalnianie komponentów
      • 14.2.3. Zakresy otoczenia
      • 14.2.4. Diagnozowanie kontenera pod kątem częstych problemów cyklu życia
    • 14.3. Rejestrowanie trudnych API
      • 14.3.1. Konfigurowanie prymitywnych zależności
      • 14.3.2. Wyciąganie prymitywnych ZALEŻNOŚCI do Obiektów Parametrów
      • 14.3.3. Rejestrowanie obiektów za pomocą bloków kodu
    • 14.4. Praca z licznymi komponentami
      • 14.4.1. Wybieranie spośród licznych kandydatów
      • 14.4.2. Podłączanie sekwencji
      • 14.4.3. Podłączanie Dekoratorów
      • 14.4.4. Podłączanie Kompozytów
      • 14.4.5. Sekwencje są strumieniami
  • 15 . Kontener DI Microsoft.Extensions. DependencyInjection
    • 15.1. Wprowadzenie do Microsoft.Extensions.DependencyInjection
      • 15.1.1. Rozwiązywanie obiektów
      • 15.1.2. Konfigurowanie ServcieCollection
    • 15.2. Zarządzanie cyklem życia
      • 15.2.1. Konfigurowanie STYLÓW ŻYCIA
      • 15.2.2. Zwalnianie komponentów
    • 15.3. Rejestrowanie trudnych API
      • 15.3.1. Konfigurowanie prymitywnych ZALEŻNOŚCI
      • 15.3.2. Wyciąganie prymitywnych ZALEŻNOŚCI do Obiektów Parametru
      • 15.3.3. Rejestrowanie obiektów za pomocą bloków kodu
    • 15.4. Praca z licznymi komponentami
      • 15.4.1. Wybieranie wśród licznych kandydatów
      • 15.4.2. Podłączanie sekwencji
      • 15.4.3. Podłączanie Dekoratorów
      • 15.4.4. Podłączanie Kompozytów
  • słowniczek terminologii
  • literatura
    • Pozycje drukowane
    • Pozycje online
    • Inne źródła
• Przypisy

pokaż cały spis treści

ukryj recenzje