Programowanie komponentowe. + CD

Programowanie komponentowe + CD

SPIS TREŚCI

Przedmowa .......................................................................................................... 7

CZĘŚĆ 1 - KOMPONENTY PROGRAMOWE

1. Wprowadzenie ................................................................................................. 9

1.1. Koncepcja komponentu programowego ................................................ 9

1.2. Programowanie komponentowe vs obiektowe .................................... 10

2. Technologie komponentowe.......................................................................... 11

2.1. Technologie oparte na języku Java: JavaBeans, EJB .......................... 11

2.2. Technologie CORBA, CCM ................................................................ 13

2.3. Technologie COM, COM+, DCOM .................................................... 15

2.4. Technologia komponentowa w .NET .................................................. 16

Materiały źródłowe: ........................................................................................... 16

CZĘŚĆ 2 - TECHNOLOGIA J AVA B EANS TM

3. Komponent Bean ........................................................................................... 17

3.1. Czym jest komponent Bean ? .............................................................. 17

3.2. Definiowanie komponentu Bean ......................................................... 18

3.3. Właściwości i akcesory........................................................................ 23

3.3.1. Właściwości proste ..................................................................... 23

3.3.2. Właściwości logiczne ................................................................. 24

3.3.3. Właściwości indeksowane .......................................................... 25

3.3.4. Właściwości związane i ograniczone ......................................... 26

3.4. Generowanie i obsługa zdarzeń ........................................................... 26

3.4.1. Delegacyjny model obsługi zdarzeń ........................................... 26

3.4.2. Zdarzenia .................................................................................... 29

3.4.3. Rejestracja słuchaczy ................................................................. 34

3.5. Przykład definiowania i użycia komponentu Counter ......................... 40

3.6. Serializacja komponentów ................................................................... 464

3.7. Pakowanie komponentów .................................................................... 50

3.8. Podsumowanie ..................................................................................... 50

4. Komponent w trybie projektowania .............................................................. 53

4.1. Komponent Bean w graficznym środowisku programistycznym ........ 53

4.2. Mechanizm refleksji ............................................................................ 54

4.3. Introspekcja ......................................................................................... 58

4.4. Edytory właściwości ............................................................................ 66

4.5. Konfigurator komponentu (Customizer) ............................................. 75

5. Wzorce programowe i konwencje programistyczne ...................................... 85

5.1. Wzorce programowe ............................................................................ 85

5.2. Konwencje programistyczne ............................................................... 87

6. Ćwiczenia ...................................................................................................... 89

6.1. Ćwiczenie 1: przycisk zamykający ...................................................... 89

6.2. Ćwiczenie 2: przycisk +/- .................................................................... 94

Materiały źródłowe: ........................................................................................... 99

CZĘŚĆ 3 - KOMPONENTY .NET

7. Środowisko programistyczne .NET ............................................................. 101

7.1. Struktura platformy .NET .................................................................. 101

7.2. Wspólne środowisko uruchomieniowe CLR ..................................... 102

7.3. Biblioteki klas .................................................................................... 104

8. Programowanie w C++/CLI ........................................................................ 105

8.1. Kod zarządzany i niezarządzany ....................................................... 106

8.2. Klasa referencyjna ............................................................................. 107

8.3. Klasa wartości .................................................................................... 108

8.4. Interfejsy ............................................................................................ 109

8.4.1. Deklaracja interfejsu ................................................................. 110

8.4.2. Implementacja interfejsu .......................................................... 111

8.5. Destruktory i finalizatory. .................................................................. 113

9. Właściwości ................................................................................................. 119

9.1. Definiowanie właściwości ................................................................. 119

9.2. Akcesory (funkcje dostępowe) .......................................................... 120

9.3. Właściwości proste ............................................................................ 122

9.4. Właściwości indeksowane ................................................................. 123

9.5. Właściwości statyczne ....................................................................... 126

10. Delegacyjny model obsługi zdarzeń .......................................................... 129

10.1. Koncepcja delegacyjnego modelu obsługi zdarzeń ........................... 129

10.2. Delegat ............................................................................................... 130

10.3. Zdarzenia ........................................................................................... 135

10.4. Delegaty i zdarzenia w bibliotekach .Net .......................................... 139

11. Definiowanie komponentu ........................................................................ 145

11.1. Infrastruktura komponentowa w .NET .............................................. 145

11.2. Przykład implementacji programowej interfejsów ............................ 149

11.3. Kontrolki ............................................................................................ 155

11.4. Podzespoły i mechanizm refleksji ..................................................... 163

12. Komponenty w trybie projektowania ........................................................ 171

12.1. Atrybuty ............................................................................................. 173

12.2. Konwertery typu ................................................................................ 176

12.3. Wizualne edytory ............................................................................... 183

12.4. Designery ........................................................................................... 191

12.4.1. Środowisko do projektowania GUI .......................................... 191

12.4.2. Definiowanie designera ............................................................ 194

12.5. Podsumowanie ................................................................................... 204

13. Ćwiczenia .................................................................................................. 205

13.1. Ćwiczenie 1: przycisk zamykający .................................................... 205

13.2. Ćwiczenie 2: przycisk +/- .................................................................. 208

Materiały źródłowe: ......................................................................................... 213

CZĘŚĆ 4 - TECHNOLOGIA COM

14. Architektura i elementy składowe technologii COM ................................ 215

14.1. Wprowadzenie ................................................................................... 215

14.2. Identyfikator GUID ........................................................................... 218

14.3. Interfejsy COM .................................................................................. 220

14.4. Cykl życia komponentu COM ........................................................... 221

14.5. Łańcuchy w technologii COM........................................................... 222

15. Używanie komponentów COM ................................................................. 225

15.1. Obsługa błędów ................................................................................. 225

15.2. Biblioteka COM ................................................................................ 225

15.3. Schemat tworzenia i użycia obiektu COM ........................................ 226

15.4. Przykład użycia komponentu ActiveDesktop ..................................... 228

15.5. Przykład użycia komponentu ShellLink ............................................. 229

16. Współpraca komponentów COM i .NET .................................................. 235

16.1. Wprowadzenie ................................................................................... 235

16.2. Używanie komponentów COM w aplikacjach .NET ........................ 236

Materiały źródłowe: ......................................................................................... 242

Skorowidz ........................................................................................................ 243

Programowanie komponentowe + cd