E-book details

Projektowanie frameworków w .NET. Wytyczne, konwencje, idiomy i wzorce. Wydanie III

Projektowanie frameworków w .NET. Wytyczne, konwencje, idiomy i wzorce. Wydanie III

Krzysztof Cwalina, Jeremy Barton, Brad Abrams

Ebook

Projektant frameworka tworzy dla innych programistów. To odpowiedzialne zadanie: celem jest zapewnienie większości potrzebnych elementów, które po dostosowaniu i połączeniu mają stać się aplikacją. Dobrze zaprojektowany framework pozwala na wygodną i efektywną pracę. Jest prosty, łatwy do rozwijania i dobrze integruje się z innymi narzędziami programistycznymi, językami czy modelami aplikacji. Projektant musi więc dobrze się orientować w zasadach tworzenia interfejsów API, bibliotek i innych komponentów wielokrotnego użytku.

Ta książka jest trzecim, przejrzanym i zaktualizowanym wydaniem znakomitego wprowadzenia do programowania komponentów i ich bibliotek na platformie .NET. Położono w niej nacisk na zagadnienia projektowe bezpośrednio wiążące się z programowalnością frameworka. Przedstawione wytyczne, wypracowane przez lata rozwijania platformy .NET, wynikają z doświadczenia i wiedzy projektantów i ekspertów branżowych. Uwzględniają też innowacje w zakresie projektowania interfejsów API oraz programowania asynchronicznego i uproszczonego dostępu do pamięci. Poszczególne wytyczne zostały uporządkowane, wyjaśnione i bogato skomentowane. Dzięki temu można w pełni wykorzystać najlepsze wzorce języka C# 8, a także platform .NET Framework 4.8 i .NET Core.

W książce:

  • Najważniejsze zasady projektowania nowoczesnych frameworków
  • Typowe dla frameworków wzorce projektowe
  • Wytyczne w zakresie nazw, typów, rozszerzalności i wyjątków
  • Projektowanie skalowalnych bibliotek działających w chmurze
  • Nowe techniki programowania asynchronicznego z wykorzystaniem typów Task i ValueTask
  • Dostęp do pamięci za pomocą typów Memory i Span

Najlepsze wzorce tworzenia frameworków i bibliotek: poznaj i stosuj!


Spis rysunków 13

Spis tabel 15

Przedmowa 17

Przedmowa do wydania drugiego 19

Przedmowa do wydania pierwszego 21

Wstęp 23

Podziękowania 27

O autorach 29

O komentatorach 31

1. Wprowadzenie 37

  • 1.1. Walory dobrze zaprojektowanego frameworka 38
    • 1.1.1. Dobrze zaprojektowane frameworki są proste 38
    • 1.1.2. Dobrze zaprojektowane frameworki muszą kosztować 39
    • 1.1.3. Dobrze zaprojektowane frameworki są pełne kompromisów 40
    • 1.1.4. Dobrze zaprojektowane frameworki zawierają zapożyczenia z przeszłości 41
    • 1.1.5. Dobrze zaprojektowane frameworki można rozwijać 41
    • 1.1.6. Dobrze zaprojektowane frameworki można integrować 42
    • 1.1.7. Dobrze zaprojektowane frameworki są spójne 42

2. Podstawy projektowania frameworków 43

  • 2.1. Progresywne frameworki 45
  • 2.2. Podstawowe zasady projektowania frameworków 48
    • 2.2.1. Zasada projektowania opartego na scenariuszach 48
    • 2.2.2. Zasada niskiego progu wejścia 54
    • 2.2.3. Zasada samodokumentujących się modeli obiektów 59
    • 2.2.4. Zasada architektury warstwowej 64
  • Podsumowanie 66

3. Wytyczne dla nazw 67

  • 3.1. Konwencje dotyczące wielkości liter 67
    • 3.1.1. Reguły stosowania wielkich liter w identyfikatorach 68
    • 3.1.2. Wielkie litery w akronimach 70
    • 3.1.3. Wielkie litery w wyrazach złożonych i często używanych zwrotach 72
    • 3.1.4. Rozróżnianie wielkości znaków 74
  • 3.2. Ogólne konwencje nazewnicze 75
    • 3.2.1. Dobór słów 75
    • 3.2.2. Używanie skrótów i akronimów 77
    • 3.2.3. Unikanie nazw specyficznych dla języków 78
    • 3.2.4. Nazewnictwo nowych wersji istniejących interfejsów API 79
  • 3.3. Nazwy zestawów, bibliotek DLL i pakietów 81
  • 3.4. Nazwy przestrzeni nazw 83
    • 3.4.1. Przestrzenie nazw i konflikty nazw typów 84
  • 3.5. Nazwy klas, struktur i interfejsów 86
    • 3.5.1. Nazwy uogólnionych parametrów typowych 88
    • 3.5.2. Nazwy zwykłych typów 89
    • 3.5.3. Nazewnictwo wyliczeń 90
  • 3.6. Nazwy składowych typów 91
    • 3.6.1. Nazwy metod 91
    • 3.6.2. Nazwy właściwości 92
    • 3.6.3. Nazwy zdarzeń 93
    • 3.6.4. Nazwy pól 94
  • 3.7. Nazwy parametrów 95
    • 3.7.1. Nazwy parametrów przeciążonych operatorów 95
  • 3.8. Nazewnictwo zasobów 96
  • Podsumowanie 96

4. Wytyczne dotyczące projektowania typów 97

  • 4.1. Typy i przestrzenie nazw 99
  • 4.2. Wybór między klasą a strukturą 102
  • 4.3. Wybór między klasą a interfejsem 105
  • 4.4. Projektowanie klas abstrakcyjnych 111
  • 4.5. Projektowanie klas statycznych 112
  • 4.6. Projektowanie interfejsów 113
  • 4.7. Projektowanie struktur 115
  • 4.8. Projektowanie wyliczeń 119
    • 4.8.1. Projektowanie wyliczeń znacznikowych 125
    • 4.8.2. Dodawanie wartości do wyliczeń 128
  • 4.9. Typy zagnieżdżone 130
  • 4.10. Typy a metadane zestawów 132
  • 4.11. Silnie typowane ciągi 133
  • Podsumowanie 136

5. Projektowanie składowych 137

  • 5.1. Ogólne wytyczne dotyczące projektowania składowych 137
    • 5.1.1. Przeciążanie składowych 137
    • 5.1.2. Jawne implementowanie składowych interfejsu 147
    • 5.1.3. Wybór między właściwościami a metodami 150
  • 5.2. Projektowanie właściwości 154
    • 5.2.1. Projektowanie właściwości indeksowanych 157
    • 5.2.2. Zdarzenia powiadamiania o zmianach właściwości 159
  • 5.3. Projektowanie konstruktorów 160
    • 5.3.1. Wytyczne dla konstruktorów typów 166
  • 5.4. Projektowanie zdarzeń 168
  • 5.5. Projektowanie pól 172
  • 5.6. Metody rozszerzające 175
  • 5.7. Przeciążanie operatorów 181
    • 5.7.1. Przeciążanie operatora == 185
    • 5.7.2. Operatory konwersji 185
    • 5.7.3. Operatory nierówności 186
  • 5.8. Projektowanie parametrów 188
    • 5.8.1. Wybór między parametrami typu wyliczeniowego i logicznego 190
    • 5.8.2. Sprawdzanie poprawności argumentów 192
    • 5.8.3. Przekazywanie parametrów 195
    • 5.8.4. Składowe ze zmienną liczbą parametrów 198
    • 5.8.5. Parametry wskaźnikowe 201
  • 5.9. Używanie krotek w sygnaturach składowych 202
  • Podsumowanie 207

6. Projektowanie pod kątem rozszerzalności 209

  • 6.1. Mechanizmy rozszerzalności 209
    • 6.1.1. Klasy niezapieczętowane 209
    • 6.1.2. Składowe chronione 211
    • 6.1.3. Zdarzenia i wywołania zwrotne 212
    • 6.1.4. Składowe wirtualne 217
    • 6.1.5. Abstrakcje (typy i interfejsy abstrakcyjne) 219
  • 6.2. Klasy bazowe 220
  • 6.3. Pieczętowanie 222
  • Podsumowanie 224

7. Wyjątki 225

  • 7.1. Zgłaszanie wyjątków 229
  • 7.2. Wybór odpowiedniego typu zgłaszanego wyjątku 234
    • 7.2.1. Opracowywanie komunikatu o błędzie 236
    • 7.2.2. Obsługa wyjątków 237
    • 7.2.3. Opakowywanie wyjątków 242
  • 7.3. Korzystanie ze standardowych typów wyjątków 244
    • 7.3.1. Exception i SystemException 244
    • 7.3.2. ApplicationException 244
    • 7.3.3. InvalidOperationException 244
    • 7.3.4. ArgumentException, ArgumentNullException i ArgumentOutOfRangeException 245
    • 7.3.5. NullReferenceException, IndexOutOfRangeException i AccessViolationException 246
    • 7.3.6. StackOverflowException 246
    • 7.3.7. OutOfMemoryException 246
    • 7.3.8. ComException, SEHException i ExecutionEngineException 247
    • 7.3.9. OperationCanceledException i TaskCanceledException 247
    • 7.3.10. FormatException 248
    • 7.3.11. PlatformNotSupportedException 248
  • 7.4. Projektowanie własnych wyjątków 248
  • 7.5. Wyjątki a wydajność 249
    • 7.5.1. Wzorzec Tester-Wykonawca 250
    • 7.5.2. Wzorzec Try 251
  • Podsumowanie 254

8. Wytyczne dotyczące użytkowania 255

  • 8.1. Tablice 255
  • 8.2. Atrybuty 258
  • 8.3. Kolekcje 260
    • 8.3.1. Kolekcje jako parametry 262
    • 8.3.2. Kolekcje jako właściwości i wartości zwracane 263
    • 8.3.3. Wybór między tablicą a kolekcją 266
    • 8.3.4. Implementowanie kolekcji niestandardowych 267
  • 8.4. DateTime i DateTimeOffset 269
  • 8.5. ICloneable 271
  • 8.6. IComparablei IEquatable 271
  • 8.7. IDisposable 273
  • 8.8. Nullable 273
  • 8.9. Object 274
    • 8.9.1. Object.Equals 274
    • 8.9.2. Object.GetHashCode 276
    • 8.9.3. Object.ToString 277
  • 8.10. Serializacja 279
  • 8.11. Uri 281
    • 8.11.1. Wytyczne implementacyjne dotyczące typu System.Uri 282
  • 8.12. Użycie przestrzeni nazw System.Xml 282
  • 8.13. Operatory równości 283
    • 8.13.1. Operatory równości w typach wartościowych 285
    • 8.13.2. Operatory równości w typach referencyjnych 286

9. Typowe wzorce projektowe 287

  • 9.1. Komponenty agregujące 287
    • 9.1.1. Projektowanie komponentowe 289
    • 9.1.2. Typy sfaktoryzowane 291
    • 9.1.3. Wytyczne dotyczące komponentów agregujących 292
  • 9.2. Wzorce asynchroniczne 294
    • 9.2.1. Wybór między wzorcami asynchronicznymi 295
    • 9.2.2. Wzorzec asynchroniczny oparty na zadaniach 296
    • 9.2.3. Typy zwracane z metod asynchronicznych 301
    • 9.2.4. Tworzenie asynchronicznego wariantu istniejącej metody synchronicznej 304
    • 9.2.5. Wytyczne implementacyjne mające na celu zachowanie spójności wzorca asynchronicznego 306
    • 9.2.6. Klasyczny wzorzec asynchroniczny 311
    • 9.2.7. Wzorzec asynchroniczny oparty na zdarzeniach 311
    • 9.2.8. IAsyncDisposable 312
    • 9.2.9. IAsyncEnumerable 312
  • 9.3. Właściwości zależnościowe 314
    • 9.3.1. Projektowanie właściwości zależnościowych 315
    • 9.3.2. Projektowanie dołączanych właściwości zależnościowych 317
    • 9.3.3. Sprawdzanie poprawności właściwości zależnościowych 318
    • 9.3.4. Powiadomienia o zmianach właściwości zależnościowych 318
    • 9.3.5. Koercja wartości właściwości zależnościowej 319
  • 9.4. Wzorzec Dispose 320
    • 9.4.1. Podstawowy wzorzec Dispose 322
    • 9.4.2. Typy finalizowalne 328
    • 9.4.3. Operacje z określonym zakresem 331
    • 9.4.4. IAsyncDisposable 334
  • 9.5. Fabryki 337
  • 9.6. Obsługa LINQ 341
    • 9.6.1. Omówienie mechanizmu LINQ 341
    • 9.6.2. Sposoby implementowania obsługi technologii LINQ 342
    • 9.6.3. Obsługa technologii LINQ za pośrednictwem interfejsu IEnumerable 342
    • 9.6.4. Obsługa LINQ za pośrednictwem interfejsu IQueryable 343
    • 9.6.5. Obsługa technologii LINQ za pośrednictwem wzorca Query 344
  • 9.7. Wzorzec funkcji opcjonalnych 347
  • 9.8. Kowariancja i kontrawariancja 350
    • 9.8.1. Kontrawariancja 352
    • 9.8.2. Kowariancja 354
    • 9.8.3. Wzorzec symulowanej kowariancji 356
  • 9.9. Metoda szablonowa 359
  • 9.10. Limity czasu 361
  • 9.11. Odczytywanie typów z kodu XAML 362
  • 9.12. Operacje na buforach 364
    • 9.12.1. Operacje transformacji danych 375
    • 9.12.2. Zapisywanie w buforze danych o stałej lub wstępnie określonej wielkości 380
    • 9.12.3. Zapisywanie w buforze danych z użyciem wzorca Try-Write 381
    • 9.12.4. Częściowe zapisy do buforów i wyliczenie OperationStatus 385
  • 9.13. A na koniec... 389

A Konwencje stylu programowania w C# 391

  • A.1. Ogólne konwencje stylu 392
    • A.1.1. Użycie nawiasów klamrowych 392
    • A.1.2. Użycie spacji 394
    • A.1.3. Użycie wcięć 395
    • A.1.4. Odstępy w pionie 397
    • A.1.5. Modyfikatory składowych 397
    • A.1.6. Inne 399
  • A.2. Konwencje nazewnicze 403
  • A.3. Komentarze 404
  • A.4. Organizacja plików 405

B Przestarzałe wytyczne 407

  • B.3. Przestarzałe wytyczne dotyczące nazewnictwa 408
    • B.3.8. Nazewnictwo zasobów 408
  • B.4. Przestarzałe wytyczne dotyczące projektowania typów 408
    • B.4.1. Typy i przestrzenie nazw 408
  • B.5. Przestarzałe wytyczne dotyczące projektowania składowych 410
    • B.5.4. Projektowanie zdarzeń 410
  • B.7. Przestarzałe wytyczne dotyczące wyjątków 411
    • B.7.4. Projektowanie wyjątków niestandardowych 411
  • B.8. Przestarzałe wytyczne dotyczące użytkowania 412
    • B.8.10. Serializacja 412
  • B.9. Przestarzałe wytyczne dotyczące typowych wzorców projektowych 419
    • B.9.2. Wzorce asynchroniczne 419
    • B.9.4. Wzorzec Dispose 429

C Przykład specyfikacji API 435

D Zmiany powodujące niezgodność 441

  • D.1. Modyfikowanie zestawów 442
    • D.1.1. Zmiana nazwy zestawu 442
  • D.2. Dodawanie przestrzeni nazw 443
    • D.2.1. Dodawanie przestrzeni nazw powodującej konflikt z istniejącym typem 443
  • D.3. Modyfikowanie przestrzeni nazw 443
    • D.3.1. Zmiana nazwy przestrzeni nazw lub wielkości jej liter 443
  • D.4. Przenoszenie typów 443
    • D.4.1. Przenoszenie typu za pośrednictwem atrybutu [TypeForwardedTo] 443
    • D.4.2. Przenoszenie typu bez użycia atrybutu [TypeForwardedTo] 444
  • D.5. Usuwanie typów 444
    • D.5.1. Usuwanie typów 444
  • D.6. Modyfikowanie typów 445
    • D.6.1. Zapieczętowanie typu niezapieczętowanego 445
    • D.6.2. Odpieczętowanie typu zapieczętowanego 445
    • D.6.3. Zmiana wielkości liter w nazwie typu 445
    • D.6.4. Zmiana nazwy typu 446
    • D.6.5. Zmiana przestrzeni nazw typu 446
    • D.6.6. Dodawanie do struktury modyfikatora readonly 446
    • D.6.7. Usuwanie ze struktury modyfikatora readonly 447
    • D.6.8. Dodawanie interfejsu bazowego do istniejącego interfejsu 447
    • D.6.9. Dodawanie drugiej deklaracji uogólnionego interfejsu 447
    • D.6.10. Zmiana klasy na strukturę 448
    • D.6.11. Zmiana struktury na klasę 448
    • D.6.12. Zmiana struktury na typ ref struct 449
    • D.6.13. Zmiana typu ref struct na strukturę (bez słowa kluczowgo ref) 449
  • D.7. Dodawanie składowych 449
    • D.7.1. Maskowanie składowych typu bazowego za pomocą modyfikatora new 449
    • D.7.2. Dodawanie składowych abstrakcyjnych 450
    • D.7.3. Dodawanie składowych do typu niezapieczętowanego 450
    • D.7.4. Dodawanie składowej z modyfikatorem override do typu niezapieczętowanego 450
    • D.7.5. Dodawanie do struktury pierwszego pola typu referencyjnego 451
    • D.7.6. Dodawanie składowej do interfejsu 451
  • D.8. Przenoszenie składowych 452
    • D.8.1. Przenoszenie składowych do klasy bazowej 452
    • D.8.2. Przenoszenie składowych do interfejsu bazowego 452
    • D.8.3. Przenoszenie składowych do typu pochodnego 452
  • D.9. Usuwanie składowych 452
    • D.9.1. Usuwanie finalizatora z typu niezapieczętowanego 452
    • D.9.2. Usuwanie finalizatora z typu zapieczętowanego 453
    • D.9.3. Usuwanie składowej bez modyfikatora override 453
    • D.9.4. Usuwanie przesłonięcia składowej wirtualnej 453
    • D.9.5. Usuwanie przesłonięcia składowej abstrakcyjnej 454
    • D.9.6. Usuwanie lub zmiana nazwy pól prywatnych w typach serializowalnych 454
  • D.10. Przeciążanie składowych 454
    • D.10.1. Dodawanie pierwszego przeciążenia składowej 455
    • D.10.2. Dodawanie przeciążenia z alternatywnym parametrem typu referencyjnego 455
  • D.11. Zmiana sygnatur składowych 455
    • D.11.1. Zmiana nazwy parametru metody 455
    • D.11.2. Dodawanie lub usuwanie parametru metody 456
    • D.11.3. Zmiana typu parametru metody 456
    • D.11.4. Zmiana kolejności parametrów o różnych typach w metodzie 456
    • D.11.5. Zmiana kolejności parametrów tego samego typu w metodzie 457
    • D.11.6. Zmiana typu zwrotnego metody 457
    • D.11.7. Zmiana typu właściwości 458
    • D.11.8. Zmiana widoczności składowej z publicznej na dowolną inną 458
    • D.11.9. Zmiana widoczności składowej z chronionej na publiczną 458
    • D.11.10. Zmiana składowej wirtualnej (lub abstrakcyjnej) z chronionej na publiczną 458
    • D.11.11. Dodawanie lub usuwanie modyfikatora static 459
    • D.11.12. Rozpoczęcie przekazywania parametru przez referencję lub rezygnacja z tego 459
    • D.11.13. Zmiana stylu parametru referencyjnego 460
    • D.11.14. Nadawanie modyfikatora readonly metodzie struktury 460
    • D.11.15. Usuwanie modyfikatora readonly z metody struktury 460
    • D.11.16. Zmiana parametru z obowiązkowego na opcjonalny 460
    • D.11.17. Zmiana parametru z opcjonalnego na obowiązkowy 461
    • D.11.18. Zmiana wartości domyślnej parametru opcjonalnego 461
    • D.11.19. Zmiana wartości pola const 461
    • D.11.20. Zmiana składowej abstrakcyjnej na wirtualną 462
    • D.11.21. Zmiana składowej wirtualnej na abstrakcyjną 462
    • D.11.22. Zmiana składowej niewirtualnej na wirtualną 462
  • D.12. Zmiana działania 463
    • D.12.1. Zastępowanie wyjątków dotyczących błędów czasu wykonania wyjątkami odnoszącymi się do błędów użycia 463
    • D.12.2. Zastępowanie wyjątków dotyczących błędów użycia funkcjonalnym działaniem 463
    • D.12.3. Zmiana typu wartości zwracanych z metody 463
    • D.12.4. Zgłaszanie nowego typu wyjątku błędu 464
    • D.12.5. Zgłaszanie nowego typu wyjątku, odziedziczonego po dotychczas zgłaszanym typie 464
  • D.13. Ostatnia uwaga 464

Słowniczek 465

  • Title: Projektowanie frameworków w .NET. Wytyczne, konwencje, idiomy i wzorce. Wydanie III
  • Author: Krzysztof Cwalina, Jeremy Barton, Brad Abrams
  • Original title: Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (3rd Edition) (Addison-Wesley Microsoft Technology Series)
  • Translation: Krzysztof Bąbol
  • ISBN: 978-83-283-7607-6, 9788328376076
  • Date of issue: 2021-08-10
  • Format: Ebook
  • Item ID: prfra3
  • Publisher: Helion