Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Microsoft Visual Studio 2005.
Ksiêga eksperta
Autor: Lars Powers, Mike Snell
T³umaczenie: Tomasz Walczak, Maria Chaniewska
ISBN: 83-246-0837-0
Tytu³ orygina³u:
Microsoft Visual Studio 2005 Unleashed
Format: B5, stron: oko³o 848
oprawa twarda
Zwiêksz swoj¹ produktywnoœæ dziêki Visual Studio 2005 oraz Team System
• Kompletny przegl¹d œrodowiska
• Nowoœci w Visual Studio 2005
• Praca zespo³owa w Team System
Microsoft nie zaprzestaje wysi³ków, doskonal¹c narzêdzia do tworzenia programów
dla platformy .NET. Visual Studio 2005 to nastêpny krok w tym kierunku. Nowe
w³aœciwoœci pozwalaj¹ jeszcze bardziej zwiêkszyæ wydajnoœæ programistów, poprawiæ
komfort ich pracy i zautomatyzowaæ wykonywanie ¿mudnych zadañ, a wersja Team
System umo¿liwia wspó³pracê ca³ych zespo³ów projektowych, w³¹czaj¹c w to
mened¿erów projektu, architektów, programistów, testerów czy administratorów.
Wieloœæ mo¿liwoœci i funkcji œrodowiska Visual Studio 2005 sprawia, ¿e nawet
doœwiadczonym programistom przyda siê wszechstronne Ÿród³o wiedzy.
Ksi¹¿ka „Microsoft Visual Studio 2005. Ksiêga eksperta” to podrêcznik, w którym
wyczerpuj¹co omówiono to rozbudowane œrodowisko. Dziêki niemu poznasz elementy
interfejsu u¿ytkownika potrzebne do utworzenia aplikacji od pocz¹tku do koñca
- od przygotowywania projektu, poprzez pisanie i modyfikowanie kodu, a¿ po
diagnozowanie i testowanie programu. Nauczysz siê korzystaæ z nowych funkcji
Visual Studio 2005 umo¿liwiaj¹cych miêdzy innymi automatyzacjê testów, wydajn¹
refaktoryzacjê czy wi¹zanie danych bez koniecznoœci pisania kodu, co przyczyni siê
do wzrostu Twej produktywnoœci. Dowiesz siê tak¿e, jak u¿ywaæ narzêdzi wersji Team
System pozwalaj¹cych na sprawn¹ wspó³pracê wielu osób pracuj¹cych przy tworzeniu
oprogramowania.
• Przegl¹d okien projektowych i edytorów
• Praca z projektami i rozwi¹zaniami
• Diagnozowanie kodu
• Obs³uga baz danych
• Refaktoryzacja kodu
• Pisanie kreatorów, makr i dodatków
• Tworzenie aplikacji sieciowych w ASP.NET
• Pisanie i konsumowanie us³ug sieciowych
• Automatyzacja testów
• Zarz¹dzanie zmianami i kontrola wersji
• Wspó³praca zespo³owa
• Spo³ecznoœæ programistów .NET
Ta ksi¹¿ka to nieoceniona pomoc dla wszystkich u¿ytkowników Visual Studio 2005.
Spis treści
O autorach ..................................................................................................15
Wprowadzenie ............................................................................................17
Część I Wprowadzenie do Visual Studio 2005 i .NET ..........................21
Rozdział 1. Krótki przegląd Visual Studio 2005 .........................................23
Kilka przydatnych usprawnień ............................................................................................................ 23
Projektowanie, pisanie i przeglądanie kodu .................................................................................. 24
Edycja i diagnozowanie kodu ........................................................................................................ 32
Współdzielenie (i wykorzystywanie) kodu w społeczności programistów ................................... 37
Uwzględnianie potrzeb różnych klientów ..................................................................................... 38
Połączenie z danymi ...................................................................................................................... 43
Automatyzacja testów aplikacji ..................................................................................................... 45
Przegląd wersji ..................................................................................................................................... 46
Wersje Express .............................................................................................................................. 47
Wersja Standard ............................................................................................................................. 48
Wersja Professional ....................................................................................................................... 48
Visual Studio Team System .......................................................................................................... 49
Podsumowanie ..................................................................................................................................... 53
Rozdział 2. Krótki przegląd środowiska IDE ..............................................55
Instalacja .............................................................................................................................................. 55
Wybór języka ................................................................................................................................. 55
Instalowanie narzędzi do kontroli kodu źródłowego ..................................................................... 56
Konfigurowanie środowiska programistycznego .......................................................................... 57
Strona startowa ..................................................................................................................................... 59
Opcje uruchomieniowe .................................................................................................................. 60
Pierwszy projekt ................................................................................................................................... 60
Pasek menu .......................................................................................................................................... 61
Liczne paski narzędzi ........................................................................................................................... 66
Standardowy pasek narzędzi ......................................................................................................... 66
Okno narzędzi ...................................................................................................................................... 68
Graficzne okna projektowe .................................................................................................................. 69
Edytory tekstu ...................................................................................................................................... 70
Edytory kodu ................................................................................................................................. 70
Dostosowywanie edytorów ............................................................................................................ 73
Solution Explorer ................................................................................................................................. 74
Okno Properties ................................................................................................................................... 74
6
Microsoft Visual Studio 2005. Księga eksperta
Zarządzanie wieloma oknami środowiska IDE ....................................................................................75
Przyczepianie .................................................................................................................................75
Dokowanie .....................................................................................................................................76
Podsumowanie ......................................................................................................................................78
Rozdział 3. Rozszerzenia platformy i języków .NET w wersji 2005 ........... 79
Rozszerzenia wspólne dla różnych języków .NET ...............................................................................79
Typy ogólne ....................................................................................................................................80
Typy dopuszczające wartość null....................................................................................................85
Typy (klasy) częściowe...................................................................................................................88
Właściwości z mieszanym poziomem dostępu ...............................................................................89
Wieloznaczne przestrzenie nazw ....................................................................................................89
Rozszerzenia języka Visual Basic .........................................................................................................90
Instrukcja Continue .........................................................................................................................91
Typy bez znaku ...............................................................................................................................91
Operator IsNot.................................................................................................................................91
Blok Using ......................................................................................................................................92
Dostęp do formularzy podobny jak w Visual Basic 6.....................................................................92
Jawne zerowe dolne ograniczenie w tablicach................................................................................92
Przeciążanie operatorów .................................................................................................................93
Niestandardowe zdarzenia ..............................................................................................................93
Rozszerzenia języka C#.........................................................................................................................93
Metody anonimowe.........................................................................................................................94
Klasy statyczne................................................................................................................................95
Używanie dwóch wersji tego samego podzespołu..........................................................................96
Podzespoły zaprzyjaźnione .............................................................................................................97
Rozszerzenia platformy .NET 2.0 .........................................................................................................98
Nowe właściwości w podstawowych technologiach ......................................................................99
Podsumowanie.....................................................................................................................................100
Część II Środowisko Visual Studio 2005 — szczegóły ......................101
Rozdział 4. Rozwiązania i projekty .......................................................... 103
Wprowadzenie do rozwiązań .............................................................................................................103
Tworzenie rozwiązania ................................................................................................................104
Korzystanie z rozwiązań ..............................................................................................................108
Zapoznawanie się z projektami ..........................................................................................................113
Tworzenie projektu ......................................................................................................................113
Używanie plików definicji projektu .............................................................................................116
Praca z projektami ........................................................................................................................121
Podsumowanie ....................................................................................................................................126
Rozdział 5. Przeglądarki i eksploratory ................................................... 129
Okno Solution Explorer ......................................................................................................................129
Ikony i wskazówki graficzne .......................................................................................................130
Zarządzanie rozwiązaniami ..........................................................................................................134
Zarządzanie projektami ................................................................................................................135
Okno Class View ................................................................................................................................135
Pasek narzędzi ..............................................................................................................................135
Pasek wyszukiwania .....................................................................................................................137
Spis treści
7
Panel obiektów ............................................................................................................................ 137
Panel składowych ........................................................................................................................ 139
Okno Server Explorer ........................................................................................................................ 140
Połączenia z danymi .................................................................................................................... 140
Komponenty serwera ................................................................................................................... 141
Okno Object Browser ........................................................................................................................ 145
Zmiana zasięgu ............................................................................................................................ 145
Przeglądanie obiektów ................................................................................................................. 146
Okno Performance Explorer .............................................................................................................. 148
Tworzenie sesji wydajności ......................................................................................................... 148
Konfigurowanie sesji ................................................................................................................... 149
Jednostki docelowe sesji .............................................................................................................. 153
Raporty ........................................................................................................................................ 154
Czytanie raportów dotyczących wydajności ............................................................................... 154
Okno Macro Explorer ........................................................................................................................ 160
Węzeł główny — Macros ............................................................................................................ 161
Projekty ........................................................................................................................................ 161
Moduły ......................................................................................................................................... 162
Makra ........................................................................................................................................... 162
Okno Document Outline .................................................................................................................... 162
Modyfikowanie elementów ......................................................................................................... 162
Podsumowanie ................................................................................................................................... 164
Rozdział 6. Wprowadzenie do edytorów i okien projektowych ...........165
Podstawy ............................................................................................................................................ 165
Edytor tekstu ................................................................................................................................ 166
Okna projektowe środowiska Visual Studio ............................................................................... 168
Pisanie kodu w edytorze .................................................................................................................... 168
Otwieranie edytora ...................................................................................................................... 169
Pisanie kodu ................................................................................................................................. 169
Budowa okna edytora kodu ......................................................................................................... 171
Narzędzia do nawigowania po kodzie ......................................................................................... 173
Przeszukiwanie dokumentów ...................................................................................................... 175
Diagnozowanie w edytorze kodu ................................................................................................ 183
Drukowanie kodu ........................................................................................................................ 186
Używanie okna Code Definition ................................................................................................. 187
Tworzenie i modyfikowanie dokumentów i szablonów XML .......................................................... 188
Tworzenie aplikacji bazujących na formularzach Windows ............................................................. 191
Dostosowywanie wyglądu formularza ........................................................................................ 192
Dodawanie kontrolek do formularza ........................................................................................... 193
Pisanie kodu ................................................................................................................................. 195
Tworzenie formularzy sieciowych ..................................................................................................... 198
Projektowanie aplikacji bazujących na formularzach sieciowych .............................................. 199
Tworzenie komponentów i kontrolek ................................................................................................ 203
Tworzenie nowego komponentu lub kontrolki ............................................................................ 204
Uwagi na temat pisania kodu komponentów ............................................................................... 205
Podsumowanie ................................................................................................................................... 206
8
Microsoft Visual Studio 2005. Księga eksperta
Rozdział 7. Korzystanie z narzędzi zwiększających produktywność ... 207
Podstawowe narzędzia pomocnicze edytorów kodu ..........................................................................209
Śledzenie zmian ...........................................................................................................................209
Wskazówki dotyczące problemów ...............................................................................................209
Aktywne odnośniki ......................................................................................................................210
Kolorowanie składni ....................................................................................................................211
Schematy i nawigacja .........................................................................................................................212
Schematy kodu .............................................................................................................................212
Nawigowanie po kodzie HTML ...................................................................................................214
Inteligentne znaczniki i operacje ........................................................................................................216
Okno projektowe HTML ..............................................................................................................216
Okno projektowe formularzy Windows .......................................................................................217
Edytor kodu ..................................................................................................................................217
Mechanizm IntelliSense .....................................................................................................................217
Uzupełnianie słów (Complete Word) ...........................................................................................218
Okno z informacjami podręcznymi (Quick Info) .........................................................................219
Okno z listą składowych (List Members) ....................................................................................220
Okno z informacjami o parametrach (Parameter Info) ................................................................220
Fragmenty kodu i kod szablonowy ..............................................................................................221
Dopasowywanie nawiasów ..........................................................................................................229
Dostosowywanie mechanizmu IntelliSense do własnych potrzeb ...............................................230
Okno Task List ...................................................................................................................................231
Zadania związane z komentarzami ..............................................................................................232
Zadania związane ze skrótami .....................................................................................................233
Zadania użytkownika ...................................................................................................................234
Podsumowanie ....................................................................................................................................234
Rozdział 8. Refaktoryzacja kodu ............................................................. 235
Podstawy refaktoryzacji w Visual Studio ...........................................................................................236
Uruchamianie narzędzi do refaktoryzacji ....................................................................................237
Podgląd zmian ..............................................................................................................................240
Zmienianie nazw ................................................................................................................................241
Uruchamianie operacji Rename ...................................................................................................242
Używanie okna dialogowego Rename .........................................................................................243
Pobieranie metod ................................................................................................................................244
Uruchamianie refaktoryzacji Extract Method ..............................................................................244
Pobieranie metod ..........................................................................................................................245
Generowanie szkieletu metody ....................................................................................................250
Pobieranie interfejsów ........................................................................................................................250
Uruchamianie refaktoryzacji Extract Interface ............................................................................250
Pobieranie interfejsów ..................................................................................................................251
Refaktoryzacja parametrów ................................................................................................................253
Usuwanie parametrów ..................................................................................................................253
Przekształcanie zmiennych lokalnych na parametry ....................................................................254
Zmiana kolejności parametrów ....................................................................................................256
Hermetyzacja pól ................................................................................................................................257
Uruchamianie refaktoryzacji Encapsulate Field ..........................................................................257
Okno dialogowe Encapsulate Field ..............................................................................................258
Podsumowanie ....................................................................................................................................259
Spis treści
9
Rozdział 9. Diagnozowanie w Visual Studio 2005 ...................................261
Podstawy diagnozowania ................................................................................................................... 261
Scenariusz .................................................................................................................................... 262
Wiele etapów diagnozowania ...................................................................................................... 262
Diagnozowanie aplikacji (samodzielne sprawdzanie) ................................................................. 263
Podsumowanie podstaw diagnozowania ..................................................................................... 272
Debuger środowiska Visual Studio .................................................................................................... 272
Menu i pasek narzędzi Debug ..................................................................................................... 272
Opcje diagnozowania .................................................................................................................. 276
Wkraczanie w kod, wychodzenie z niego i przeskakiwanie ........................................................ 277
Określanie warunków wstrzymania wykonywania kodu ............................................................ 282
Korzystanie z punktów śledzenia (When Hit…) ......................................................................... 289
Podglądanie danych w debugerze ................................................................................................ 291
Korzystanie z funkcji „zmień i kontynuuj” ................................................................................. 297
Zdalne diagnozowanie ................................................................................................................. 298
Podsumowanie ................................................................................................................................... 299
Rozdział 10. Obiektowy model automatyzacji środowiska
Visual Studio .........................................................................301
Przegląd obiektowego modelu automatyzacji ................................................................................... 302
Wersje modelu obiektowego ....................................................................................................... 302
Kategorie automatyzacji .............................................................................................................. 302
Obiekt główny DTE (DTE2) ....................................................................................................... 304
Obiekty Solution i Project .................................................................................................................. 306
Kontrolowanie projektów wchodzących w skład rozwiązania .................................................... 308
Dostęp do kodu projektu .............................................................................................................. 308
Okna ................................................................................................................................................... 309
Dostęp do okien ........................................................................................................................... 311
Interakcja z oknami ..................................................................................................................... 312
Okna tekstowe i panele ................................................................................................................ 315
Rodzaje okien narzędzi ................................................................................................................ 317
Okna połączone ........................................................................................................................... 325
Paski poleceń ..................................................................................................................................... 326
Dokumenty ......................................................................................................................................... 330
Dokumenty tekstowe ................................................................................................................... 330
Obiekty polecenia .............................................................................................................................. 341
Wykonywanie poleceń ................................................................................................................ 343
Dodawanie klawiszy skrótu ......................................................................................................... 343
Obiekty debugera ............................................................................................................................... 344
Zdarzenia automatyzacji .................................................................................................................... 345
Podsumowanie ................................................................................................................................... 346
Rozdział 11. Tworzenie makr, dodatków i kreatorów ............................347
Pisanie makr ....................................................................................................................................... 348
Rejestrowanie makr ..................................................................................................................... 348
Korzystanie z okna Macro Explorer ............................................................................................ 349
Używanie środowiska IDE Macros ............................................................................................. 350
Obsługa zdarzeń .......................................................................................................................... 357
Wywoływanie makr ..................................................................................................................... 363
10
Microsoft Visual Studio 2005. Księga eksperta
Tworzenie dodatków w Visual Studio ...............................................................................................366
Zarządzanie dodatkami ................................................................................................................367
Uruchamianie kreatora dodatków ................................................................................................368
Struktura dodatków ......................................................................................................................375
Przykładowy dodatek — paleta do wybierania kolorów .............................................................383
Tworzenie kreatorów dla środowiska Visual Studio ..........................................................................403
Analiza struktury kreatorów .........................................................................................................403
Tworzenie kreatorów typu Add New Item ...................................................................................406
Podsumowanie ....................................................................................................................................411
Rozdział 12. Społeczność .NET: wykorzystanie
i tworzenie współdzielonego kodu ................................ 413
Możliwości Visual Studio związane ze społecznością .......................................................................413
Strona startowa Visual Studio ......................................................................................................414
Menu Community ........................................................................................................................419
Wykrywanie i wykorzystanie współdzielonych zasobów ..................................................................430
Rodzaje współdzielonych zasobów ..............................................................................................430
Wyszukiwanie odpowiednich zasobów .......................................................................................431
Instalowanie i przechowywanie udostępnianych zasobów ..........................................................431
Własny wkład w społeczność .............................................................................................................433
Tworzenie udostępnianych elementów (szablonów projektów i elementów) .............................433
Tworzenie szablonów projektów .................................................................................................433
Tworzenie szablonów elementów ................................................................................................439
Tworzenie pakietów .....................................................................................................................440
Udostępnianie własnych rozwiązań .............................................................................................447
Podsumowanie ....................................................................................................................................448
Część III Visual Studio 2005 w praktyce ...........................................449
Rozdział 13. Tworzenie interfejsów użytkownika w ASP.NET .................. 451
Podstawy witryn w ASP.NET ............................................................................................................451
Tworzenie nowego projektu aplikacji sieciowej ..........................................................................452
Kontrolowanie właściwości i opcji projektu ................................................................................460
Tworzenie stron internetowych ....................................................................................................465
Projektowanie interfejsu użytkownika ...............................................................................................470
Określanie układu strony i położenia kontrolek ...........................................................................470
Tworzenie jednolitego wyglądu i zachowania .............................................................................472
Tworzenie UI konfigurowanego przez użytkownika ...................................................................482
Praca z kontrolkami ASP.NET ...........................................................................................................491
Udoskonalenia kontrolek ASP.NET ............................................................................................491
Nowe kontrolki wewnątrz ASP.NET ...........................................................................................492
Podsumowanie ....................................................................................................................................498
Rozdział 14. Budowanie formularzy Windows ........................................ 499
Podstawy projektowania formularzy ..................................................................................................499
Uwzględnianie użytkownika końcowego ....................................................................................500
Rola standardów UI ......................................................................................................................500
Planowanie interfejsu użytkownika .............................................................................................501
Tworzenie formularza ........................................................................................................................502
Typ projektu Windows Application .............................................................................................503
Właściwości i zdarzenia formularza ............................................................................................504
Spis treści
11
Dodawanie kontrolek i komponentów ............................................................................................... 506
Układ i pozycjonowanie kontrolek .............................................................................................. 507
Używanie kontenerów ................................................................................................................. 511
Wygląd i zachowanie kontrolek .................................................................................................. 515
Praca z kontrolkami ToolStrip ..................................................................................................... 516
Wyświetlanie danych ................................................................................................................... 523
Tworzenie własnych kontrolek .......................................................................................................... 527
Dziedziczenie z istniejącej kontrolki ........................................................................................... 527
Definiowanie kontrolki użytkownika .......................................................................................... 528
Tworzenie własnej kontrolki ....................................................................................................... 531
Podsumowanie ................................................................................................................................... 531
Rozdział 15. Praca z bazami danych ......................................................533
Tworzenie tabel i związków .............................................................................................................. 533
Tworzenie nowej bazy danych SQL Server ................................................................................ 534
Definiowanie tabel ....................................................................................................................... 535
Korzystanie z Database Diagram Designer ................................................................................. 537
Praca z poleceniami SQL ................................................................................................................... 541
Pisanie zapytań ............................................................................................................................ 541
Tworzenie widoków .................................................................................................................... 545
Programowanie procedur składowanych ..................................................................................... 545
Tworzenie wyzwalaczy ............................................................................................................... 549
Tworzenie funkcji definiowanych przez użytkownika ................................................................ 549
Korzystanie z projektów bazy danych ............................................................................................... 551
Tworzenie projektu bazy danych ................................................................................................. 551
Automatyczne generowanie skryptów ......................................................................................... 552
Wykonywanie skryptu ................................................................................................................. 553
Tworzenie obiektów bazy danych w kodzie zarządzanym ................................................................ 554
Rozpoczynanie projektu SQL Server .......................................................................................... 554
Tworzenie procedury składowanej w C# .................................................................................... 555
Wiązanie kontrolek z danymi ............................................................................................................ 557
Wprowadzenie do wiązania danych ............................................................................................ 557
Automatyczne generowanie związanych kontrolek Windows Forms ......................................... 559
Ręczne wiązanie kontrolek formularzy Windows ....................................................................... 564
Wiązanie danych z kontrolkami sieciowymi ............................................................................... 568
Podsumowanie ................................................................................................................................... 572
Rozdział 16. Usługi sieciowe i Visual Studio ............................................573
Definicja usług sieciowych ................................................................................................................ 574
Terminy dotyczące usług sieciowych .......................................................................................... 574
Komponenty projektu usługi sieciowej ............................................................................................. 575
Usługi sieciowe .NET .................................................................................................................. 575
Projekt ASP.NET Web Service ................................................................................................... 576
Pliki usługi sieciowej ................................................................................................................... 577
Programowanie usługi sieciowej ....................................................................................................... 578
Tworzenie usługi sieciowej ......................................................................................................... 578
Dostęp i wywoływanie usługi sieciowej ..................................................................................... 582
Konsumowanie usługi sieciowej ........................................................................................................ 588
Definiowanie referencji sieciowej ............................................................................................... 588
Wyświetlanie referencji sieciowej ............................................................................................... 590
Wywoływanie usługi sieciowej ................................................................................................... 590
12
Microsoft Visual Studio 2005. Księga eksperta
Zarządzanie wyjątkami usług sieciowych ..........................................................................................592
Tworzenie wyjątku usługi sieciowej ............................................................................................592
Obsługa wyjątków usług sieciowych ...........................................................................................593
Podsumowanie ....................................................................................................................................593
Część IV Visual Studio 2005 Team System ........................................595
Rozdział 17. Praca zespołowa i Visual Studio Team System ................. 597
Przegląd projektów tworzenia oprogramowania ................................................................................597
MSF Agile ....................................................................................................................................598
MSF dla CMMI ............................................................................................................................600
Wprowadzenie do Visual Studio Team System .................................................................................601
Visual Studio Team Architect ......................................................................................................603
Visual Studio Team Developer ....................................................................................................603
Visual Studio Team Test ..............................................................................................................605
Team Foundation Server ..............................................................................................................606
Podsumowanie ....................................................................................................................................608
Rozdział 18. Zarządzanie i praca z projektami zespołowymi ............... 611
Anatomia Team Foundation Server ....................................................................................................611
Warstwa aplikacji .........................................................................................................................612
Warstwa danych ...........................................................................................................................614
Bezpieczeństwo ............................................................................................................................615
Zarządzanie projektem zespołowym ..................................................................................................617
Tworzenie nowego projektu zespołowego ...................................................................................618
Dodawanie użytkowników do zespołu projektu ..........................................................................621
Kontrolowanie struktury projektu i iteracji ..................................................................................626
Przyłączanie się do zespołu projektowego .........................................................................................628
Łączenie się z Team Foundation Server ......................................................................................628
Korzystanie z Team Explorer .......................................................................................................629
Korzystanie z portalu projektu .....................................................................................................629
Korzystanie z Microsoft Office ....................................................................................................631
Korzystanie z alarmów projektu ..................................................................................................633
Praca z raportami projektu ...........................................................................................................634
Podsumowanie ....................................................................................................................................636
Rozdział 19. Kontrola kodu źródłowego ................................................. 637
Podstawy systemu kontroli kodu źródłowego serwera Team Foundation .........................................638
Podstawowa architektura .............................................................................................................638
Uprawnienia w systemie zabezpieczeń ........................................................................................639
Pierwsze kroki w korzystaniu z kontroli kodu źródłowego serwera Team Foundation ......................640
Konfigurowanie środowiska Visual Studio .................................................................................641
Używanie okna Source Control Explorer ....................................................................................642
Zarządzanie obszarami roboczymi ...............................................................................................644
Dodawanie plików do systemu kontroli kodu źródłowego ..........................................................647
Modyfikowanie plików objętych kontrolą kodu źródłowego ............................................................648
Pobieranie plików z repozytorium kodu źródłowego ..................................................................648
Przesyłanie zmian .........................................................................................................................649
Wprowadzenie do zbiorów zmian ................................................................................................654
Odkładanie kodu ..........................................................................................................................655
Scalanie zmian .............................................................................................................................656
Spis treści
13
Rozgałęzianie i scalanie ..................................................................................................................... 659
Rozgałęzianie ............................................................................................................................... 660
Scalanie ........................................................................................................................................ 661
Podsumowanie ................................................................................................................................... 662
Rozdział 20. Śledzenie elementów roboczych .......................................663
Wprowadzenie do elementów roboczych ......................................................................................... 664
Funkcje elementów roboczych i SDLC ....................................................................................... 664
Wybieranie zestawu elementów roboczych dla własnego projektu ............................................ 664
Identyfikowanie wspólnych cech elementów roboczych ............................................................ 669
Zarządzanie elementami roboczymi za pomocą narzędzi Team Explorer ........................................ 678
Wprowadzenie do ról zespołowych ................................................................................................... 684
Wizja projektu ............................................................................................................................. 684
Menedżer projektu ....................................................................................................................... 685
Analityk biznesowy ..................................................................................................................... 692
Programista .................................................................................................................................. 694
Tester ........................................................................................................................................... 698
Dostosowywanie elementów roboczych do własnych potrzeb .......................................................... 699
Umieszczanie w procesie elementów roboczych ........................................................................ 700
Dostosowywanie istniejących elementów roboczych ................................................................. 705
Podsumowanie ................................................................................................................................... 707
Rozdział 21. Modelowanie .......................................................................709
Elementy Team Architect .................................................................................................................. 710
Szablony projektów ..................................................................................................................... 710
Szablony elementów .................................................................................................................... 711
Projektowanie aplikacji ...................................................................................................................... 711
Korzystanie ze schematów aplikacji ............................................................................................ 712
Definiowanie systemów ..................................................................................................................... 720
Schemat systemu ......................................................................................................................... 720
Definiowanie infrastruktury ............................................................................................................... 722
Schemat logicznego centrum danych .......................................................................................... 723
Wdrażanie aplikacji ........................................................................................................................... 731
Schemat wdrażania ...................................................................................................................... 732
Sprawdzanie poprawności wdrożenia ......................................................................................... 733
Raport dotyczący wdrożenia ....................................................................................................... 733
Implementowanie aplikacji ................................................................................................................ 735
Ustawianie właściwości implementacji ....................................................................................... 735
Generowanie projektów ............................................................................................................... 736
Graficzne tworzenie kodu .................................................................................................................. 736
Schematy klasy ............................................................................................................................ 737
Dodawanie elementów ................................................................................................................ 738
Definiowanie relacji między klasami .......................................................................................... 739
Definiowanie metod, właściwości, pól i zdarzeń ........................................................................ 742
Podsumowanie ................................................................................................................................... 743
Rozdział 22. Testowanie ............................................................................745
Tworzenie i konfigurowanie testów oraz zarządzanie nimi .............................................................. 746
Projekty testów ............................................................................................................................ 746
Elementy testów .......................................................................................................................... 748
14
Microsoft Visual Studio 2005. Księga eksperta
Menedżer testów ..........................................................................................................................749
Konfigurowanie testów ................................................................................................................750
Testy programistów ............................................................................................................................751
Przykładowy test jednostki ..........................................................................................................751
Pisanie efektywnych testów jednostek .........................................................................................752
Używanie klas i metod testów jednostek .....................................................................................753
Tworzenie testów jednostek .........................................................................................................754
Uruchamianie testów jednostek ...................................................................................................755
Analiza pokrycia kodu .................................................................................................................757
Testy sieciowe ....................................................................................................................................759
Rejestrowanie testów sieciowych ................................................................................................759
Zarządzanie żądaniami w testach aplikacji sieciowych ...............................................................761
Uruchamianie testów sieciowych i przeglądanie wyników .........................................................762
Dodawanie danych do testów sieciowych ....................................................................................762
Pobieranie wartości z testów sieciowych .....................................................................................768
Zasady sprawdzania poprawności w żądaniach ...........................................................................769
Testy obciążenia .................................................................................................................................771
Tworzenie testów obciążenia .......................................................................................................772
Przeglądanie i modyfikowanie testów obciążenia .......................................................................777
Uruchamianie testów obciążenia i wyświetlanie wyników .........................................................778
Ręczne testy ........................................................................................................................................779
Tworzenie testów ręcznych ..........................................................................................................779
Wykonywanie testów ręcznych ....................................................................................................779
Testy ogólne .......................................................................................................................................780
Testy uporządkowane .........................................................................................................................782
Tworzenie testów uporządkowanych ...........................................................................................782
Podsumowanie ....................................................................................................................................783
Rozdział 23. Team Foundation Build ........................................................ 785
Przegląd Team Foundation Build .......................................................................................................785
Architektura Team Foundation Build ..........................................................................................786
Tworzenie nowej wersji .....................................................................................................................789
Określanie informacji o nowej wersji ..........................................................................................789
Modyfikowanie typu wersji .........................................................................................................793
Funkcje MSBuild .........................................................................................................................797
Uruchamianie budowania ...................................................................................................................798
Szeregowanie wersji .....................................................................................................................798
Wywoływanie procesu budowania ..............................................................................................799
Monitorowanie i analizowanie wersji ................................................................................................800
Wprowadzenie do przeglądarki Team Build Browser .................................................................800
Raporty dotyczące wersji .............................................................................................................803
Podsumowanie ....................................................................................................................................804
Skorowidz ................................................................................................... 805
Rozdział 3.
Rozszerzenia platformy
i języków .NET w wersji 2005
Większa część niniejszej książki dotyczy głównie narzędzi IDE Visual Studio służących
poprawie produktywności. Uważamy jednak, że warto zapoznać się także z nowinkami
w językach .NET i samej platformie. Te elementy (IDE, języki i platforma) są udostęp-
niane przez Microsoft w jednym pakiecie. Z tego powodu wszelkie opisy dotyczące IDE
byłyby niepełne bez wzmianki o pozostałych produktach.
W rozdziale opisano nowinki w językach Visual Basic .NET i C#. Opisujemy także nie-
które z kluczowych poprawek w samej platformie. Zakładamy, że większość Czytelników
ma przynajmniej podstawową wiedzę na temat albo Visual Basic, albo któregoś ze starszych
języków bazujących na C, a także w miarę dobrze zna platformę .NET. Dlatego kon-
centrujemy się głównie na tych rozszerzeniach, dzięki którym .NET 2.0 stanowi krok
naprzód w porównaniu z poprzednimi wersjami.
Rozszerzenia wspólne
dla różnych języków .NET
Języki z rodziny .NET otrzymały sporo rozszerzeń w wyniku poprawek wprowadzonych
we wspólnym środowisku uruchomieniowym (ang. Common Language Runtime — CLR).
Choć niektóre z rozszerzeń są specyficzne dla poszczególnych języków, liczne istotne
usprawnienia w wersji 2005 dotyczą ich obu. Dlatego przedstawiamy je wspólnie wraz
z przykładowym kodem w obu tych językach. Ta grupa rozszerzeń języków .NET obej-
muje następujące kluczowe usprawnienia:
Typy ogólne.
Typy dopuszczające wartość "null".
Typy częściowe.
Właściwości o mieszanym poziomie dostępu.
Wieloznaczne przestrzenie nazw.
80
Część I
Wprowadzenie do Visual Studio 2005 i .NET
W następnych punktach szczegółowo opisujemy każdy z tych elementów. Przedstawiamy
przykłady w językach C# i Visual Basic, ponieważ powyższe nowinki dotyczą ich obu.
Rozszerzenia specyficzne dla każdego z tych języków opisane są w dalszej części rozdziału.
Typy ogólne
Typy ogólne (ang. generics) to bez wątpienia najważniejsza nowość w .NET 2.0, dlatego
żadna książka opisująca tę platformę nie byłaby kompletna bez opisu ich działania. Ty-
py ogólne początkowo mogą się wydawać skomplikowane, szczególnie jeśli zaczniesz
analizować kod zawierający dziwne nawiasy ostre w przypadku języka C# czy słowo
kluczowe
Of
w Visual Basic. Poniższe podpunkty zawierają definicję typów ogólnych,
wyjaśniają ich znaczenie oraz pokazują, jak używać ich w kodzie.
Definicja typów ogólnych
Działanie typów ogólnych jest stosunkowo proste. Czasem trzeba utworzyć obiekt (lub
zdefiniować parametr metody), jednak na etapie pisania kodu nie wiadomo, jakiego typu
będzie ten obiekt. Typ powinien być ogólny i umożliwiać osobie korzystającej z niego
określenie faktycznego typu obiektu.
Do rozwiązania tego problemu można użyć klasy
System.Object
— tak postępowali
programiści używający wersji starszych od 2.0. Jednak wyobraź sobie, że chcesz uniknąć
konieczności pakowania typów, sprawdzania ich w czasie wykonywania programu i jaw-
nego rzutowania w wielu miejscach kodu. Pozwala to zrozumieć, do czego mogą służyć
typy ogólne.
Zalety stosowania typów ogólnych najlepiej pokazać na przykładzie. Najprostszy to two-
rzenie klasy kolekcji zawierającej inne obiekty. Wyobraź sobie, że chcesz zapisać grupę
obiektów. Można to zrobić, dodając je do kolekcji
ArrayList
. Jednak kompilator i środo-
wisko uruchomieniowe mają informacje jedynie o tym, że przechowywana jest lista ja-
kichś obiektów. Może ona zawierać obiekty typu
Order
,
Customer
lub obu tych typów
(lub dowolnych innych). Jedyny sposób, aby dowiedzieć się, co przechowuje lista, to
napisać kod sprawdzający typ przechowywanych obiektów.
Oczywiście można obejść ten problem i napisać własną silnie typowaną listę. Choć takie
rozwiązanie jest możliwe, wymaga to żmudnego pisania niemal takiego samego kodu dla
każdego typu, który ma być przechowywany w kolekcji. Jedyną istotną różnicą w kodzie
jest typ obiektów, jakie lista może przechowywać. Ponadto wciąż trzeba rzutować obiekty,
ponieważ używana lista zawiera obiekty typu
System.Object
.
Teraz wyobraź sobie, że możesz napisać klasę, która umożliwia użytkownikom definio-
wanie typu. Można napisać jedną ogólną klasę listy, która zamiast zawierać obiekty typu
System.Object
, będzie zawierała obiekty typu użytego w miejscu definiowania tej klasy.
Umożliwia to określenie w kodzie wywołującym ogólną listę tego, czy na przykład ma
ona przechowywać obiekty typu
Order
lub
Customer
. Właśnie to umożliwiają typy ogólne.
Można myśleć o klasach ogólnych jako o szablonach klas.
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
81
Są dwa rodzaje elementów ogólnych: typy ogólne i metody ogólne. Typy ogólne to klasy,
których typ jest definiowany w miejscu tworzenia egzemplarza danej klasy. Metoda ogólna
ma przynajmniej jeden parametr o typie ogólnym. W tym przypadku w metodzie używany
jest ogólny parametr, ale jego typ jest określany dopiero w momencie wywołania metody.
Ponadto można zdefiniować różne ograniczenia związane z tworzeniem typów ogólnych.
W następnych podpunktach przedstawimy różne związane z nimi zagadnienia.
Zalety stosowania typów ogólnych
Teraz jasno widać niektóre z zalet stosowania typów ogólnych. Bez takich typów klasy
mające zarządzać różnymi typami muszą używać typu
System.Object
. Powoduje to
liczne problemy. Po pierwsze, nie ma możliwości nałożenia ograniczeń ani sprawdzenia
przez kompilator, co jest zapisywane w obiekcie. Istotne są wynikające z tego wnioski
— nie wiadomo, co znajduje się w kolekcji, jeśli nie można ograniczyć typu zapisywanych
w niej obiektów. Po drugie, używając obiektu, trzeba sprawdzić jego typ, a następnie zrzu-
tować z powrotem na oryginalny typ. Oczywiście powoduje to spadek wydajności. Po-
nadto jeśli programista używa typów skalarnych i zapisuje je w obiektach
System.Object
,
typy są pakowane. W momencie pobierania typu skalarnego trzeba go rozpakować. Także
to wymaga zbędnego kodu i niepotrzebnie pogarsza wydajność. Typy ogólne rozwiązują
wszystkie te problemy. Poniżej opisujemy, jak jest to możliwe.
W jaki sposób .NET obsługuje typy ogólne?
Kompilacja typu ogólnego, podobnie jak pozostałego kodu dla platformy .NET, powoduje
utworzenie kodu w języku pośrednim Microsoftu (ang. Microsoft Intermediate Language
— MSIL) oraz metadanych. Oczywiście w przypadku typów i metod ogólnych kompi-
lator generuje kod MSIL definiujący sposób ich stosowania.
Kiedy kod MSIL jest wykonywany po raz pierwszy, kompilator JIT (ang. just-in-time)
kompiluje go do kodu natywnego. Kiedy taki kompilator natrafi na typ ogólny, „wie”, że
w jego miejsce należy wstawić typ rzeczywisty i robi to. Ten proces nazywany jest two-
rzeniem egzemplarza typu ogólnego.
W następnych wywołaniach używany jest świeżo skompilowany typ kodu natywnego.
W rzeczywistości wszystkie typy referencyjne mogą współdzielić jeden egzemplarz typu
ogólnego, ponieważ w kodzie natywnym te referencje to po prostu wskaźniki na ten sam
obiekt. Oczywiście jeśli w procesie tworzenia egzemplarza typu ogólnego używany jest no-
wy typ skalarny, środowisko uruchomieniowe „w locie” utworzy nową kopię tego typu
ogólnego.
Dlatego korzystanie z typów ogólnych niesie zalety zarówno na etapie pisania kodu,
jak i w czasie jego wykonywania. W czasie wykonywania cały oryginalny kod jest prze-
kształcany na natywny, silnie typowany kod. Przyjrzyjmy się teraz, jak tworzyć typy ogólne.
82
Część I
Wprowadzenie do Visual Studio 2005 i .NET
Tworzenie typów ogólnych
Typy ogólne to klasy zawierające przynajmniej jeden element, którego typ należy określić
w czasie tworzenia obiektu (a nie na etapie tworzenia klasy). Aby zdefiniować typ
ogólny, należy najpierw zadeklarować klasę, a następnie zdefiniować dla niej parametry
typu. Parametr typu jest przekazywany do klasy w celu zdefiniowania rzeczywistego
typu dla typu ogólnego. Parametry typu działają podobnie do parametrów metod. Istotna
różnica polega na tym, że zamiast wartości lub referencji do obiektu przekazywany jest
typ używany w typie ogólnym.
Większość typów ogólnych służy do zarządzania kolekcjami obiektów lub listami
wiązanymi. Nie jest to jednak jedyne zastosowanie tych typów. Dowolna klasa
może być typem ogólnym.
Załóżmy, że programista chce napisać klasę
Fields
, która obsługuje pary nazwa-wartość,
podobnie jak robią to kolekcje
Hashtable
czy
Dictionary
. Można zadeklarować tę klasę
w następujący sposób:
C#:
public class Fields
VB:
Public Class Fields
Załóżmy ponadto, że ta klasa może używać różnych typów jako kluczy i wartości. Klasa
ma w ogólny sposób obsługiwać wiele typów, jednak po utworzeniu jej egzemplarza
należy je ograniczyć do tych, które zostały określone w procesie tworzenia tego egzem-
plarza. Aby dodać parametry typu do deklaracji klasy, należy użyć następującej składni:
C#:
public class Fields<keyType, valueType>
VB:
Public Class Fields(Of keyType, valueType)
W tym przypadku
keyType
i
valueType
to parametry typu, których można używać w resz-
cie kodu klasy zamiast typów, które zostaną określone w czasie tworzenia jej egzemplarza.
Można na przykład dodać do klasy metodę
Add
, której sygnatura wygląda tak:
C#:
public void Add(keyType key, valueType value)
VB:
Public Sub Add(key as keyType, value as valueType)
Stanowi to informację dla kompilatora o tym, że typu użytego do utworzenia klasy należy
także używać w tej metodzie. Aby korzystać z klasy, w kodzie trzeba najpierw utworzyć
jej egzemplarz i przekazać do niego argumenty typu. Argumenty typu to typy przekazy-
wane jako parametry typu, takie jak w poniższym kodzie:
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
83
C#:
Fields<int, Field> myFields = new Fields<int, Field>();
VB:
Dim myFields As New Fields(Of Integer, Field)
W tym przypadku nowy egzemplarz ogólnej klasy
Field
musi zawiera liczbę typu
int
(
Integer
) jako klucz i obiekt typu
Field
jako wartość. Wywołanie metody
Add
świeżo
utworzonego obiektu
Field
wygląda teraz tak:
C#:
myFields.Add(1, new Field());
VB:
myFields.Add(1, New Field())
Próba przekazania parametru innego typu wywoła błąd kompilacji, ponieważ wymagany
jest obiekt określonego typu.
Kiedy stosuje się typy ogólne, często do definiowania nazw typów używa się
pojedynczych liter (szczególnie widoczne jest to w języku C#). Nierzadko można
zobaczyć zapis typu
<T> lub <K>. Nie trzeba ograniczać się do stosowania takich
krótkich nazw. Zawsze lepiej jest używać nieco bardziej opisowego zapisu.
Tworzenie metod ogólnych
Przedstawiliśmy już parametry typów ogólnych. Te parametry typu definiują zmienne
o zasięgu klasy. Oznacza to, że zmienna definiująca typ ogólny jest dostępna w całej kla-
sie. Podobnie jak w przypadku każdej innej klasy, nie trzeba używać zmiennych o zasięgu
całej klasy. Czasem wystarczy zdefiniować elementy przekazywane do danej metody.
Elementy ogólne działają zawsze tak samo. Można zdefiniować je na poziomie klasy (co
już pokazaliśmy) lub na poziomie metody (co pokażemy wkrótce).
Metody ogólne dobrze nadają się do obsługi często używanych funkcji narzędziowych,
które wykonują operacje na różnych typach. Metody ogólne definiuje się poprzez określenie
przynajmniej jednego typu ogólnego po nazwie metody. Następnie można używać tych ty-
pów ogólnych na liście parametrów metody jako zwracanego typu oraz oczywiście w ciele
metody. Poniżej przedstawiona jest składnia służąca do definiowania metod ogólnych:
C#:
public void Save<instanceType>(instanceType type)
VB:
Public Sub Save(Of instanceType)(ByVal type As instanceType)
Aby wywołać tę ogólną metodę, trzeba zdefiniować w jej wywołaniu typ przekazywany
do metody. Załóżmy, że metoda
Save
zdefiniowana w poprzednim fragmencie kodu
84
Część I
Wprowadzenie do Visual Studio 2005 i .NET
znajduje się w klasie
Field
, a programista utworzył egzemplarz tej klasy i zapisał referen-
cję do niego w zmiennej
myField
. Poniższy kod przedstawia, jak można wywołać metodę
Save
, przekazując typ argumentu:
C#:
myField.Save<CustomerOrder>(new CustomerOrder());
VB:
myField.Save(Of CustomerOrder)(New CustomerOrder())
Warto pamiętać o kilku sprawach związanych z metodami ogólnymi. Po pierwsze, często
można pominąć parametr typu w miejscu wywołania metody ogólnej. Kompilator po-
trafi wykryć ten typ na podstawie przekazanych parametrów, dlatego parametr typu jest
opcjonalny. Jednak zwykle warto go określić, ponieważ dzięki temu kod jest bardziej
czytelny, a kompilator nie musi sprawdzać typu. Po drugie, metody ogólne można dekla-
rować jako statyczne (lub współdzielone). Po trzecie, można zdefiniować ograniczenia
dla metod (i klas) ogólnych, co opisano w następnym podpunkcie.
Specyficzne typy ogólne (ograniczenia)
Przy pierwszym napotkaniu metod ogólnych łatwo myśleć o nich jako o prostych narzę-
dziach ułatwiających przechowywanie danych. Na pierwszy rzut oka wydaje się, że cała
ta technika ma poważną wadę. Najlepiej można ją przedstawić za pomocą pytań, które
przychodzą do głowy: „Typy ogólne są świetne, ale co zrobić, jeśli chcemy wywołać
metodę lub właściwość ogólnego obiektu, którego typ jest z definicji nieznany?”. Ta
wada wydaje się ograniczać przydatność typów ogólnych. Jednak po dalszym zastanowieniu
się można zauważyć, że ograniczenia typów ogólnych pozwalają rozwiązać ten problem.
Ograniczenia typów ogólnych działają tak, jak wskazuje na to ich nazwa — pozwalają
zdefiniować ograniczenia dotyczące typów, których nadawca może używać do tworzenia
egzemplarza klasy ogólnej lub wywoływania jednej z metod ogólnych. Ograniczenia
typów ogólnych mają trzy odmiany:
Ograniczenia dotyczące dziedziczenia — pozwalają określić, że typ ogólny
musi implementować określone interfejsy lub dziedziczyć po danej klasie bazowej.
Ograniczenia dotyczące konstruktora domyślnego — pozwalają określić,
że typ ogólny musi udostępniać konstruktor bezargumentowy.
Ograniczenia dotyczące typu (referencyjne lub skalarne) — pozwalają
określić, że parametr typu musi być albo typem referencyjnym, albo skalarnym.
Używanie ograniczenia dotyczącego dziedziczenia umożliwia określenie jednego lub
kilku interfejsów (lub typów obiektu), które można przekazywać do klasy ogólnej. To po-
zwala rozwiązać opisany wcześniej problem. Jeśli zdefiniowana wcześniej ogólna klasa
Fields
ma umożliwiać wywoływanie metody lub właściwości ogólnego typu
valueType
(na przykład właściwości ułatwiającej sortowanie grup obiektów typu
Fields
), można
to wymusić, o ile dana metoda lub właściwość jest zdefiniowana w interfejsie lub klasie
bazowej określonej w ograniczeniu. Poniższy kod pokazuje, jak zdefiniować ograniczenie
dotyczące dziedziczenia:
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
85
Ograniczenie klasy w C#:
public class Field<keyType, valueType> where keyType : ISort
Ograniczenie klasy w VB:
Public Class Fields(Of keyType, valueType As ISort)
W powyższym kodzie klasa
Fields
zawiera definicje dwóch typów ogólnych,
valueType
i
keyType
, oraz ma ograniczenie związane z parametrem
keyType
. To ograniczenie polega
na tym, że
keyType
musi implementować interfejs
ISort
. Umożliwia to używanie metod
tego interfejsu w klasie
Fields
bez konieczności rzutowania.
Ograniczenia dotyczące dziedziczenia można definiować dla klas i metod ogólnych.
Można określić dowolną liczbę interfejsów, które typ ogólny ma implementować, ale
tylko jedną klasę bazową, po której ma dziedziczyć. Oczywiście można przekazać jako
typ ogólny obiekt, który dziedziczy po klasie bazowej określonej jako ograniczenie.
Jeśli programista przesłoni ogólną metodę w klasie bazowej, nie może dodać
(ani usunąć) ograniczenia z ogólnej metody. Uwzględniane są jedynie ograniczenia
zdefiniowane w klasie bazowej.
Przestrzeń nazw z kolekcjami ogólnymi
Wiesz już, jak utworzyć własną klasę ogólną. Platforma .NET udostępnia liczne klasy ogól-
ne, których można używać w aplikacjach. Przestrzeń nazw
System.Collections.Generics
definiuje liczne ogólne klasy kolekcji, które są zaprojektowane tak, aby współpracowały
z grupami obiektów określonego typu. Kolekcja ogólna to klasa kolekcji, która umożliwia
programiście określenie typu przechowywanego w kolekcji w miejscu jej deklaracji.
Visual Studio domyślnie dodaje referencję do przestrzeni nazw
System.Collections.
åGenerics do wszystkich plików z kodem języków Visual Basic i C#.
Klasy ogólne zdefiniowane w tej przestrzeni nazw różnią się zastosowaniami. Klasa
List
służy do obsługi prostych list i tablic obiektów. Dostępne są także klasy
SortedList
,
LinkedList
,
Queue
,
Stack
i kilka klas
Dictionary
. Dzięki tym klasom można korzystać
z wszystkich podstawowych operacji bez konieczności używania typizowanych klas
kolekcji. Ponadto w tej przestrzeni nazw zdefiniowanych jest wiele interfejsów, których
można używać do tworzenia własnych kolekcji ogólnych.
Typy dopuszczające wartość null
Większość programistów od czasu do czasu musi utworzyć w aplikacji zmienną i określić
jej domyślną wartość, zanim jeszcze wiadomo, jaką wartość ta zmienna powinna zawierać.
Wyobraź sobie, że programista utworzył klasę
Osoba
ze zmienną logiczną
JestKobieta
.
Jeśli na etapie tworzenia egzemplarza nie wiadomo, jaka jest płeć osoby, trzeba wybrać
domyślną wartość lub zaimplementować tę właściwość jako trójstanowe wyliczenie o war-
tościach
Mezczyzna
,
Kobieta
i
Nieznana
.
86
Część I
Wprowadzenie do Visual Studio 2005 i .NET
To ostatnie rozwiązanie może być niewygodne, szczególnie jeśli w bazie danych wartość
jest przechowywana jako zmienna logiczna. Można wymyślić podobne sytuacje. Wyobraź
sobie, że w programie znajduje się klasa
Test
zawierająca zmienną całkowitoliczbową
Ocena
. Jeśli nie wiadomo, jaka jest wartość tej zmiennej, jest ona inicjowana liczbą zero (0).
Ta wartość oczywiście nie reprezentuje rzeczywistej oceny. Następnie trzeba uwzględnić
ten fakt albo traktując zero jako magiczną liczbę, albo używając następnej zmiennej, na
przykład
OcenaJestUstawiona
.
Ten problem jest tym większy, że wszystkie współczesne bazy danych uwzględniają warto-
ści
null
(lub nieustawione). Często nie można użyć tej właściwości bez napisania dodat-
kowego kodu, który przekształca wartości w czasie transakcji wstawiania i pobierania
danych.
Typy dopuszczające wartość
null
w .NET 2.0 mają rozwiązać ten problem. Typ dopusz-
czający wartość
null
to specjalny typ skalarny, który może mieć wartość
null
. Inaczej
działają standardowe typy skalarne (
int
,
bool
,
double
i tak dalej), które po prostu nie są
inicjowane w momencie deklarowania. Z kolei dzięki typom dopuszczającym wartość
null
można tworzyć liczby całkowite, wartości logiczne, liczby zmiennoprzecinkowe
o podwójnej precyzji i inne, a następnie przypisać do nich wartość
null
. Nie trzeba już
zgadywać, czy zmienna została ustawiona (lub używać do tego specjalnego kodu). Zwal-
nia to też programistę z konieczności określania wartości domyślnej. W zamian można
zainicjować zmienną wartością
null
lub przypisać ją do zmiennej. Dzięki temu można
pisać kod bez domyślnych założeń. Ponadto typy dopuszczające wartość
null
rozwiązują
problem pobierania wartości
null
z bazy danych i umieszczania ich w niej. Przyjrzymy
się teraz, jak działają te typy.
Deklarowanie typów dopuszczających wartość null
Deklarowanie typów dopuszczających wartość
null
znacznie różni się między językami
C# i Visual Basic. Jednak w obu przypadkach deklarowana jest ta sama struktura typu
dopuszczającego wartość
null
platformy .NET (
System.Nullable
). Ta ogólna struktura
jest zdefiniowana przez typ używany w jej deklaracji. Na przykład jeśli programista defi-
niuje liczbę całkowitą dopuszczającą wartość
null
, ta ogólna struktura zwraca wersję liczby
całkowitej. Poniższe fragmenty kodu demonstrują, w jaki sposób typy dopuszczające
wartość
null
są deklarowane w językach C# i VB:
Typ dopuszczający wartość
null
w C#:
bool? hasChildren = null;
Typ dopuszczający wartość
null
w VB:
Dim hasChildren As Nullable(Of Boolean) = Nothing
Warto zauważyć, że w kodzie języka C# można użyć modyfikatora typu
?
do wskazania,
że typ bazowy należy traktować jako typ dopuszczający wartość
null
. Jest to po prostu
skrót. Pozwala to programistom używać standardowej składni tworzenia typów i dodać
znak zapytania, żeby przekształcić dany typ na dopuszczający wartość
null
. Z drugiej strony
w języku Visual Basic trzeba bardziej bezpośrednio zdefiniować klasę
Nullable
, używając
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
87
składni podobnej do typów ogólnych. Można także użyć podobnej składni w języku C#,
tak jak w poniższym przykładzie:
System.Nullable<bool> hasChildren = null;
Jedynie typy skalarne mogą dopuszczać wartość
null. Dlatego nie jest poprawne
tworzenie dopuszczających wartość
null łańcuchów znaków czy egzemplarzy klas
zdefiniowanych przez użytkownika. Można jednak tworzyć dopuszczające wartość
null egzemplarze struktur, ponieważ są one typami skalarnymi.
Używanie typów dopuszczających wartość null
Ogólna struktura
System.Nullable
zawiera dwie właściwości służące tylko do odczytu:
HasValue
i
Value
. Te właściwości umożliwiają wydajne korzystanie z typów dopuszczają-
cych wartość
null
. Właściwość
HasValue
to wartość logiczna, która określa, czy dany typ
dopuszczający wartość
null
ma nadaną wartość. Można użyć tej właściwości w instrukcji
If
, aby określić, czy do danej zmiennej została już przypisana wartość. Ponadto można
po prostu sprawdzić, czy zmienna ma wartość
null
(jedynie w C#). Poniżej przedstawiony
jest przykładowy kod:
HasValue
w C#:
if (hasChildren.HasValue) {...}
HasValue
w VB:
If hasChildren.HasValue Then
Sprawdzanie zmiennej w C# ze względu na wartość
null
:
if (hasChildren != null) {...}
Sprawdzanie zmiennej w VB ze względu na wartość
null
:
If hasChildren.Value <> Nothing Then
Właściwość
Value
zwraca wartość zawartą w strukturze dopuszczającej wartość
null
.
Wciąż można uzyskać dostęp do wartości tej zmiennej, wywołując ją bezpośrednio (bez
używania właściwości
Value
). Różnica polega na tym, że kiedy właściwość
HasValue
ma wartość
false
, próba wywołania właściwości
Value
spowoduje zgłoszenie wyjątku.
Z kolei bezpośrednia próba dostępu do zmiennej w warunku (
HasValue = false
) nie po-
woduje tego. Dlatego ważne jest ustalenie, jak powinien działać program, a następnie na-
leży używać tych opcji w odpowiedni sposób. Poniżej znajduje się przykład zastosowania
właściwości
Value
:
Właściwość
Value
w C#:
System.Nullable<bool> hasChildren = null;
Console.WriteLine(hasChildren); //
Nie jest zgłaszany wyjątek
if (hasChildren != null) {
Console.WriteLine(hasChildren.Value.ToString());
}
Console.WriteLine(hasChildren.Value); //
Zgłasza wyjątek InvalidOperationException
88
Część I
Wprowadzenie do Visual Studio 2005 i .NET
Właściwość
Value
w VB:
Dim hasChildren As Nullable(Of Boolean) = Nothing
Console.WriteLine(hasChildren) '
Nie jest zgłaszany wyjątek
If hasChildren.HasValue Then
Console.WriteLine(hasChildren.Value.ToString())
End If
Console.WriteLine(hasChildren.Value) '
Zgłasza wyjątek InvalidOperationException
W powyższych fragmentach kodu bezpośrednie wywołania zmiennej
hasChildren
nie po-
wodują zgłoszenia wyjątku. Jednak próba sprawdzania wartości właściwości
Value
w sytuacji, kiedy zmienna ma wartość
null
, spowoduje zgłoszenie przez platformę .NET
wyjątku
InvalidOperationException
.
Typy (klasy) częściowe
Typy częściowe to mechanizm służący do definiowania pojedynczych klas, struktur lub in-
terfejsów w kilku plikach. W rzeczywistości w czasie kompilacji kodu nie ma czegoś takiego
jak typ częściowy. Takie typy istnieją jedynie w czasie tworzenia aplikacji. Na etapie kom-
pilacji zawartość plików definiujących typ częściowy jest łączona w pojedynczą klasę.
Typy częściowe mają rozwiązywać dwa problemy. Po pierwsze, umożliwiają programistom
rozbijanie dużych klas na kilka plików. Pozwala to różnym członkom zespołu pracować
nad tą samą klasą bez konieczności korzystania z tego samego pliku (dzięki czemu uni-
ka się związanych z tym problemów z łączeniem kodu). Po drugie, pozwalają na od-
dzielenie kodu wygenerowanego przez narzędzia od kodu autorstwa programisty. Dzięki
temu plik z kodem programisty będzie przejrzysty (ponieważ jedynie on go pielęgnuje),
a na zapleczu narzędzie może generować inne elementy klasy. Programiści używający
Visual Studio 2005 natychmiast zauważą to, kiedy będą korzystać z formularzy Windows,
nakładek na usługi sieciowe, stron z kodem ukrytym ASP i podobnych narzędzi. Jeśli
korzystałeś z tych elementów w poprzednich wersjach .NET, szybko spostrzeżesz, że
w wersji 2005 w plikach nie ma wygenerowanego kodu, a klasa pisana przez programistę
jest oznaczona jako
partial
.
Używanie typów częściowych
Typy częściowe zarówno w C#, jak i w Visual Basic deklaruje się za pomocą słowa klu-
czowego
Partial
. Można stosować to słowo kluczowe do klas, struktur i interfejsów. Musi
ono być pierwszym słowem w deklaracji (przed
Class
,
Structure
czy
Interface
). Wska-
zanie, że typ jest częściowy, informuje kompilator o tym, że należy połączyć części tej
klasy w pojedynczym pliku .dll lub .exe.
Przy definiowaniu typów częściowych trzeba stosować się do kilku prostych wskazówek.
Po pierwsze, w deklaracji wszystkich typów o tej samej nazwie w tej samej przestrzeni
nazw musi znajdować się słowo kluczowe
Partial
. Nie można na przykład zadeklarować
klasy
Partial Public Person
w jednym pliku, a klasy
Public Person
w innym pliku tej
samej przestrzeni nazw — trzeba dodać słowo kluczowe
Partial
także do drugiej dekla-
racji. Po drugie, trzeba pamiętać, że wszystkie modyfikatory typu częściowego są łączone
w czasie kompilacji. Obejmuje to atrybuty klasy, komentarze XML i implementacje in-
terfejsu. Na przykład jeśli programista użył atrybutu
System.SerializableAttribute
dla
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
89
typu częściowego, ten atrybut zostanie zastosowany do tego typu w czasie jego łączenia
i kompilacji. Po trzecie, warto pamiętać, że wszystkie typy częściowe muszą zostać skom-
pilowane do tego samego podzespołu (inaczej pakietu, czyli pliku .dll lub .exe; ang. as-
sembly). Nie można skompilować typu częściowego obecnego w kilku podzespołach.
Właściwości z mieszanym poziomem dostępu
W poprzednich wersjach .NET można było określić poziom dostępu (publiczny, prywatny,
chroniony, wewnętrzny) jedynie dla całej właściwości. Jednak często potrzebna jest wła-
ściwość umożliwiająca publiczny odczyt (
get
), ale tylko wewnętrzny zapis (
set
). Jedy-
nym sensownym rozwiązaniem w poprzednich wersjach .NET było pominięcie metody
set
właściwości. Następnie trzeba było utworzyć nową metodę wewnętrzną służącą do
ustawiania wartości tej właściwości. Kod byłby łatwiejszy do napisania i zrozumienia,
gdyby możliwa była bardziej precyzyjna kontrola nad modyfikatorami dostępu w obrębie
właściwości.
.NET 2.0 daje kontrolę nad modyfikatorami dostępu metod
set
i
get
właściwości. Dla-
tego można oznaczyć właściwość jako publiczną, ale oznaczyć metodę
set
jako prywatną
lub chronioną. Poniżej znajduje się przykładowy kod:
Właściwość z mieszanym poziomem dostępu w C#:
private string _userId;
public string UserId {
get { return _userId; }
internal set { userId = value; }
}
Właściwość z mieszanym poziomem dostępu w VB:
Private _userId As String
Public Property UserId() As String
Get
Return _userId
End Get
Friend Set(ByVal value As String)
_userId = value
End Set
End Property
Wieloznaczne przestrzenie nazw
W przypadku dużych projektów mogą wystąpić konflikty przestrzeni nazw między sobą
oraz z platformą .NET (przestrzeń nazw
System
). Wcześniej nie można było rozwiązać
takich wieloznacznych referencji i na etapie kompilacji pojawiał się wyjątek.
.NET 2.0 umożliwia programistom zdefiniowanie własnej przestrzeni nazw
System
bez
blokowania dostępu do wersji platformy .NET. Załóżmy, że programista zdefiniował prze-
strzeń nazw
System
i nagle utracił możliwość dostępu do jej globalnej wersji. W języku C#
90
Część I
Wprowadzenie do Visual Studio 2005 i .NET
należy dodać wtedy słowo kluczowe
global
wraz z kwalifikatorem aliasu przestrzeni
nazw
::
, tak jak w poniższym wierszu:
global::System.Double myDouble;
W Visual Basic składnia jest podobna, ale używane słowo kluczowe to
Global
:
Dim myDouble As Global.System.Double
Ponadto można zdefiniować alias, kiedy używa się przestrzeni nazw lub importuje je.
Tego aliasu można następnie używać do wskazywania typów danej przestrzeni nazw.
Załóżmy, że wystąpił konflikt z przestrzenią nazw
System.IO
. Można wtedy zdefiniować
alias przy jej importowaniu:
C#
using IoAlias = System.IO;
VB
Imports IoAlias = System.IO
Następnie można używać typów za pomocą aliasu. Oczywiście Visual Studio udostępnia
pełną obsługę mechanizmu IntelliSense dla tych elementów. Poniżej znajduje się kod
przedstawiający sposób używania zdefiniowanego wcześniej aliasu. Warto zwrócić uwagę
na nową składnię języka C#, która umożliwia stosowanie operatora w postaci podwójnego
dwukropka:
Nowa składnia języka C#
IoAlias::FileInfo file;
Stara składnia języka C#
IoAlias.FileInfo file;
VB
Dim file as IoAlias.FileInfo
Rozszerzenia języka Visual Basic
Doświadczeni użytkownicy języka Visual Basic ucieszą się na wieść, że w Visual Stu-
dio 2005 została przywrócona właściwość zmień i kontynuuj! Jednak jest to funkcja śro-
dowiska IDE. W rzeczywistości wiele nowych cech IDE jest specyficznych dla języka.
W niniejszej książce chcemy opisać większość z nich (jeśli nie wszystkie). Rozszerzenia
IDE specyficzne dla języka Visual Basic obejmują poniższe właściwości:
Programowanie za pomocą skrótów
My
.
Właściwość zmień i kontynuuj.
Fragmenty kodu.
Rozszerzenia mechanizmu IntelliSense.
Modyfikowanie atrybutów w oknie Properties.
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
91
Poprawianie błędów i ostrzeżenia.
Asystent do obsługi wyjątków.
Dokumentacja XML.
Okno Document Outline.
Okno projektowe dla projektów.
Okno projektowe dla ustawień.
Okno projektowe dla zasobów.
Dzięki powyższym rozszerzeniem (a także innym) korzystanie z języka Visual Basic
jest bardzo wygodne. W następnych podpunktach skoncentrujemy się jednak na samym
języku. Wskażemy nowinki specyficzne dla Visual Basic, które są niezwykle atrakcyjne
w wersji 2005.
Instrukcja Continue
Nowa instrukcja
Continue
w języku VB umożliwia programistom przeskoczenie do na-
stępnej iteracji pętli. Instrukcji
Continue
można używać w pętlach
Do
,
For
i
While
. Jeśli
potrzebne jest skrócenie pętli i natychmiastowe przejście do następnej iteracji, wystarczy
użyć instrukcji
Continue For
/
Do
/
While
, tak jak w poniższym kodzie:
Sub ProcessCustomers(ByVal customers() As Customer)
Dim i As Integer
For i = 0 To customers.GetUpperBound(0)
If customers(i).HasTransactions = False Then Continue For
ProcessCustomer(customers(i))
Next
End Sub
Typy bez znaku
Programiści języka Visual Basic mogą teraz używać typów całkowitoliczbowych bez
znaku (
UShort
,
UInteger
i
ULong
). Ponadto najnowsza wersja Visual Basic udostępnia
dodatkowy typ ze znakiem,
SByte
. Te nowe typy umożliwiają programistom łatwiejsze
wywoływanie funkcji interfejsu API systemu Windows, które często zwracają typy bez
znaku. Jednak takie typy bez znaku nie są obsługiwane przez specyfikację wspólnego
języka (ang. Common Language Specification — CLS), dlatego jeśli programista napisze
kod bazujący na tych nowych typach, kod zgodny z CLS może z nim nie współpracować.
Operator IsNot
Nowy operator
IsNot
języka Visual Basic umożliwia programistom sprawdzenie, czy
dwa obiekty różnią się od siebie. Oczywiście można to było zrobić także w poprzednich
wersjach, łącząc instrukcje
Not
i
Is
, na przykład
If Not myCustomer Is Nothing
. Jednak te-
raz programiści mogą korzystać z prostszej składni operatora
IsNot
, takiej jak w poniższym
92
Część I
Wprowadzenie do Visual Studio 2005 i .NET
wierszu kodu. Warto zauważyć, że działanie tego wiersza jest takie samo, jak przestawionej
wcześniej instrukcji
Not...Is
.
If cust IsNot Nothing Then
Blok Using
Programiści języka Visual Basic, którzy używali przez pewien czas języka C#, bez wąt-
pienia ucieszą się z możliwości definiowania zasięgu obiektów za pomocą bloku
Using
.
Dzięki temu blokowi programiści języka C# mogą zagwarantować zwolnienie zasobów
w momencie zakończenia wykonywania danego bloku przez aplikację. Obecnie ta właści-
wość została dodana także do języka Visual Basic. Załóżmy, że programista chce nawiązać
połączenie z bazą danych. Teraz może to zrobić w bloku
Using
. Dzięki temu gdy program
z jakiegoś powodu zakończy wykonywanie tego bloku, obiekt zdefiniowany w instrukcji
Using
(obiekt połączenia SQL) zostanie usunięty w odpowiedni sposób. Poniższy kod ilu-
struje używanie tej nowej właściwości:
Using cnn As New System.Data.SqlClient.SqlConnection(cnnStr)
'
Tu kod używający połączenia z SQL
End Using
Dostęp do formularzy podobny jak w Visual Basic 6
Programiści znający wersję 6. języka Visual Basic (jeszcze sprzed platformy .NET) przy-
pomną sobie możliwość bezpośredniego dostępu do właściwości i metod formularza
poprzez jego nazwę. W poprzednich wersjach .NET programiści musieli utworzyć egzem-
plarz formularza, aby uzyskać dostęp do jego właściwości. W Visual Basic 8 ponownie
możliwy jest dostęp do składowych formularza poprzez jego nazwę.
Jawne zerowe dolne ograniczenie w tablicach
W starszych wersjach języka Visual Basic (sprzed .NET) programiści mogli określić górne
i dolne ograniczenie tablicy, używając słowa kluczowego
To
. Można było na przykład
zdefiniować tablicę rozpoczynającą się od 1, a kończącą na 10. Dzięki temu kod, w którym
używane były tablice, był bardzo czytelny. Jednak pojawienie się platformy .NET i specy-
fikacji CLS spowodowało, że dolne ograniczenie we wszystkich tablicach musiało być
równe zero (0). Oznacza to, że każda tablica platformy .NET musi rozpoczynać się od ele-
mentu zerowego. W Visual Basic 8 nie uległo to zmianie, znów można jednak określić,
że tablica rozpoczyna się od 0, a kończy na górnym ograniczeniu, co sprzyja czytelności
kodu. Dlatego można definiować tablice w poniższy sposób, jednak dolne ograniczenie
musi równać się zero (0):
Dim myIntArray(0 To 9) As Integer
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
93
Przeciążanie operatorów
Jeśli często piszesz biblioteki, w końcu natrafisz na klasę, w której będziesz musiał zdefi-
niować działanie operatorów dodawania (
+
), odejmowania (
–
), mnożenia (
*
), większości (
>
)
i innych. Jeśli na przykład trzeba obliczyć wynik dodawania dwóch wersji klasy za pomocą
operatora
+
, potrzebna jest definicja jego działania dla tej klasy. W poprzednich wersjach
języka Visual Basic nie można było utworzyć takiej definicji, jednak Visual Basic 8 umoż-
liwia to. Jest to tak zwane przeciążanie operatorów.
Do definiowania nowego operatora służy słowo kluczowe
Operator
(używane zamiast
Sub
lub
Function
), po którym następuje symbol przeciążanego operatora (
+
,
&
,
*
,
<>
i tak
dalej). Można następnie dodać ciało tej „funkcji” jak każdej innej. Może ona przyjmować
parametry i zwracać wartość. Jeśli programista chce umożliwić dodawanie do siebie
dwóch obiektów, może zdefiniować operator
+
przyjmujący te obiekty jako parametry
i zwracający trzeci obiekt jako wynik. Ilustruje to poniższy kod:
Public Operator +(ByVal obj1 As MyObject, ByVal obj2 As MyObject) As MyObject
'
Obliczanie wartości nowego obiektu i zwracanie go
End Operator
Niestandardowe zdarzenia
Programiści języka Visual Basic mają teraz kontrolę nad rejestrowaniem delegatów, po-
nieważ mogą używać zdarzeń zdefiniowanych przez użytkownika. Nowa wersja Visual
Basic obejmuje słowo kluczowe
Custom
, którego można używać przy definiowaniu zdarzeń.
Po użyciu tego słowa kluczowego do zadeklarowania zdarzenia trzeba zdefiniować ak-
cesory dla metod
AddHandler
,
RemoveHandler
i
RaiseEvent
. Te akcesory przesłaniają do-
myślne działanie zdarzenia kodem napisanym przez programistę. Jest to przydatne w sy-
tuacjach, kiedy wszystkie zdarzenia mają być uruchamiane asynchronicznie lub potrzebna
jest pełna kontrola nad tymi operacjami.
Rozszerzenia języka C#
W wersji 2005 język C# został rozszerzony o nowe możliwości. Opisaliśmy już kilka
wspólnych nowinek, takich jak typy ogólne i dopuszczające wartość
null
. Ponadto pro-
gramiści języka C# mają dostęp do nowych właściwości środowiska IDE. Niektóre z tych
funkcji to:
Fragmenty kodu.
Refaktoryzacja.
Rozszerzenie mechanizmu IntelliSense.
Kreatory kodu.
Właściwości projektów.
94
Część I
Wprowadzenie do Visual Studio 2005 i .NET
W niniejszej książce opiszemy te właściwości. Jednak w tym miejscu skoncentrujemy się
na specyficznych rozszerzeniach języka C# w wersji 2005.
Więcej informacji dotyczących języka C# i omawianych tu zagadnień znajduje się
w udostępnianym przez Microsoft dokumencie „C# Language Specification 2.0”.
Ten dokument można pobrać ze strony http://msdn.microsoft.com/library/
default.asp?url=/library/en-us/dnvs05/html/cs3spec.asp. Pod tym samym adresem
znajduje się kompletny przegląd języka C# oraz zestaw samouczków. Ponadto gotowa
jest już specyfikacja języka C# 3.0, która jest dostępna do przeglądu i recenzji.
Metody anonimowe
Pojęcie metody anonimowe może przy pierwszym napotkaniu wydawać się nieco skom-
plikowane. Są to jednak po prostu nienazwane bloki kodu (nie metody) przekazywane
bezpośrednio do delegata. Po pierwsze, ta właściwość jest dostępna tylko w języku C#.
Po drugie, jest przydatna tylko wtedy, kiedy nie są potrzebne wszystkie możliwości, jakie
dają delegaty — nie trzeba używać wielu jednostek nasłuchujących ani nie jest potrzebna
możliwość kontroli tego, jakie jednostki nasłuchują (poprzez ich dodawanie i usuwanie).
Metody anonimowe najłatwiej jest zrozumieć, porównując je ze standardowym sposobem
używania delegatów. Aby użyć delegatów w poprzednich wersjach języka C#, trzeba było
napisać metodę wywoływaną przez tego delegata, a następnie powiązać ją z delegatem.
Przyjrzyjmy się na przykład sposobowi łączenia kodu ze zdarzeniem
Click
przycisku
(
System.Windows.Forms.Button
). Po pierwsze, zdarzenie
Click
to
System.EventHandler
(lub delegat). Trzeba upewnić się, że kod metody jest powiązany z delegatem. Załóżmy,
że kod znajduje się w metodzie, która wygląda następująco:
private void button1_Click(object sender, EventArgs e) {
label1.Text = "textBox.Text";
}
Następnie należy powiązać metodę z delegatem. Oczywiście Visual Studio wykonuje na
zapleczu wszystkie potrzebne operacje. Można jednak samodzielnie napisać służący do
tego kod. Ponadto Visual Studio obsługuje jedynie wiązanie delegatów kontrolek interfej-
su użytkownika (zdarzeń) z metodami. Programista odpowiada za wiązanie wszystkich
pozostałych delegatów — zarówno tych niestandardowych, jak i będących częścią platfor-
my. Poniższy kod pokazuje, w jaki sposób Visual Studio wiąże metodę
button1_Click
ze zdarzeniem
Click
klasy
Button
:
this.button1.Click += new System.EventHandler(this.button1_Click);
Jak widać, trzeba napisać metodę z kodem oraz powiązać ją z delegatem. Przyjrzyjmy
się teraz, jakie możliwości dają metody anonimowe. Jak już wspomnieliśmy, można
przekazać kod bezpośrednio do delegata. Dlatego można dodać poniższy wiersz kodu
do konstruktora formularza (po wywołaniu metody
InitializeComponents
):
this.button1.Click += delegate {
label1.Text = "Do widzenia";
};
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
95
Jak widać w powyższym kodzie, używanie metod anonimowych wiąże się z używaniem
słowa kluczowego
delegate
. Oczywiście delegaty mogą przyjmować parametry, dlatego
po słowie
delegate
można umieścić opcjonalną listę parametrów (nie ma jej w powyż-
szym kodzie). Na końcu znajduje się lista instrukcji (blok kodu). To ten kod, ograniczony
nawiasami klamrowymi, jest przekazywany do delegata anonimowo (bez nazwy metody).
Metoda anonimowa ma dostęp do zmiennych znajdujących się w zasięgu w miejscu
tworzenia takiej metody. Te zmienne to tak zwane zmienne zewnętrzne metody
anonimowej (dla odróżnienia od zmiennych wewnętrznych, które są definiowane
wewnątrz metody). Jeśli zmienna zewnętrzna jest używana w metodzie anonimowej,
zostaje przez nią przechwycona. Czas życia takiej przechwyconej zmiennej jest zależny
od usunięcia przez mechanizm przywracania pamięci delegata, a nie samej metody.
Ten punkt stanowi jedynie krótkie wprowadzenie do metod anonimowych. Umożliwiają
one pisanie dość złożonego kodu (który może być mało czytelny). Jak łatwo się domyślić,
przekazywanie wierszy kodu jako parametrów wymaga starannego namysłu, jeśli chce
się uniknąć problemów.
Klasy statyczne
Nowa wersja platformy .NET zapewnia obsługę klas statycznych. Klasa statyczna to taka,
w której każda składowa jest zadeklarowana jako składowa statyczna (w przeciwień-
stwie do składowych egzemplarza). Użytkownicy tej klasy nie muszą tworzyć jej egzem-
plarzy. Platforma gwarantuje nawet, że nie można utworzyć egzemplarza klasy statycz-
nej. Platforma .NET udostępnia wiele takich klas, jednak język Visual Basic na razie ich
nie obsługuje. Robi to jednak język C#. Dlatego to tu przedstawiamy przykładowy kod
bazujący na klasach statycznych.
W języku Visual Basic można utworzyć coś podobnego do klas statycznych, tworząc
klasę o prywatnym konstruktorze. Ponadto należy oznaczyć wszystkie składowe tej
klasy jako
Shared. Wadą takiego rozwiązania jest brak obsługi tego mechanizmu
przez kompilator czy brak możliwości używania konstruktora statycznego.
Definiowanie klas statycznych
Klasy statyczne tworzy się poprzez dodanie słowa kluczowego
Static
do deklaracji
klasy, tak jak w poniższym wierszu kodu:
static class ProjectProperties { ...
Jak już wspomnieliśmy, nie można tworzyć egzemplarzy klasy, która została zadeklaro-
wana jako statyczna. Trzeba jednak pamiętać o zadeklarowaniu wszystkich jej składo-
wych jako statycznych (kompilator nie zakłada, że są właśnie takie). Jednak kompilator
może sprawdzić w klasie statycznej, czy przypadkowo nie znalazła się w niej składowa
egzemplarza. Próba umieszczenia zmiennej niestatycznej w klasie statycznej wywoła błąd
kompilacji. Dotyczy to zarówno składowych publicznych, jak i prywatnych. Listing 3.1
przedstawia prostą klasę statyczną i jej składowe.
96
Część I
Wprowadzenie do Visual Studio 2005 i .NET
Listing 3.1. Klasa statyczna
namespace StaticClasses {
static class ProjectProperties {
static string _projectName;
static ProjectProperties() {
_projectName = "JakiśNowyProjekt";
}
public static string Name {
get { return _projectName; }
}
public static DateTime GetDueDate() {
//
Pobiera datę planowanego oddania projektu
DateTime dueDate = DateTime.Now.AddDays(10);
return dueDate;
}
}
}
Klasy statyczne są automatycznie oznaczane jako zamknięte. Oznacza to, że nie
można dziedziczyć po klasach statycznych.
Konstruktory i klasy statyczne
Nie można utworzyć konstruktora dla klasy statycznej. Jednak jeśli potrzebna jest funkcja
podobna do konstruktora (na przykład do ustawiania początkowych wartości), można
napisać tak zwany konstruktor statyczny. Listing 3.1 przedstawia przykładowy konstruktor
statyczny o nazwie
ProjectProperties
. Warto zauważyć, że inicjuje on wartość składowej
statycznej
_projectName
.
Środowisko CLR platformy .NET wczytuje klasy statyczne automatycznie w czasie wczy-
tywania zawierających je przestrzeni nazw. Ponadto w momencie wywołania składowej
statycznej środowisko CLR automatycznie wywołuje konstruktor statyczny. W celu wy-
wołania tego specjalnego konstruktora nie trzeba tworzyć egzemplarza klasy statycznej
(nie jest to nawet możliwe).
Używanie dwóch wersji tego samego podzespołu
Programiści czasem potrzebują właściwości starszej wersji komponentu, a jednocześnie
chcą używać jego najnowszej wersji. Często jest to wynikiem zmian wprowadzanych
w komponentach bez uwzględnienia zgodności wstecz. W takich przypadkach możliwości
są ograniczone do całkowitego przerzucenia się na nowy komponent lub pozostania
przy starszej wersji. Język C# umożliwia trzecie rozwiązanie — używanie obu wersji za
pomocą zewnętrznego aliasu podzespołu.
Podstawowym problemem związanym z korzystaniem z wielu wersji tego samego podze-
społu jest rozwiązywanie konfliktów między nazwami składowych znajdujących się w tej
samej przestrzeni nazw. Załóżmy, że programista używa podzespołu generującego wy-
kresy. Odpowiedzialna jest za to klasa
Chart
działająca w przestrzeni nazw
Charting
.
Kiedy zostanie udostępniona następna wersja podzespołu, programista będzie chciał za-
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
97
chować cały istniejący kod, jednak w nowym kodzie będzie chciał używać najnowszej
wersji. W języku C# można to zrobić, wykonując kilka operacji.
Po pierwsze, trzeba zdefiniować alias nowego podzespołu. W tym celu należy użyć okna
Properties dla wybranej referencji. Rysunek 3.1 pokazuje, jak ustawić taki alias. Warto za-
uważyć, że ustawiany jest alias dla drugiej wersji podzespołu (
ChartV2
). Gwarantuje to, że
wywołania do klasy
Charting.Chart
wciąż będą kierowane do pierwszej wersji (
ChartV1
).
Rysunek 3.1.
Definiowanie aliasu
Następnie w pliku z kodem, który ma używać nowej wersji podzespołu, trzeba zdefi-
niować zewnętrzny alias. W tym celu należy przejść do początku pliku (przed instrukcje
Using
) i wpisać instrukcję rozpoczynającą się od słowa kluczowego
extern
. Poniższy
wiersz pokazuje, jaki kod należy umieścić na początku pliku, aby używać drugiej wersji
komponentu
Charting
:
extern alias ChartV2;
Do używania składowych nowej wersji podzespołu służy operator
::
(podobnie jak w przy-
padku innych, podobnych aliasów języka C#), tak jak w poniższym wierszu kodu:
ChartV2::Charting.Chart.GenerateChart();
Podzespoły zaprzyjaźnione
Język C# 2.0 umożliwia połączenie podzespołów ze względu na dostęp do wewnętrznych
mechanizmów. Oznacza to, że można zdefiniować wewnętrzne składowe, ale udostępnić
je zewnętrznym podzespołom. Ta możliwość jest przydatna, jeśli zamierzasz rozbić pod-
zespół na kilka plików fizycznych, ale wciąż chcesz, aby ich elementy były dostępne we
wszystkich podzespołach.
98
Część I
Wprowadzenie do Visual Studio 2005 i .NET
Podzespoły zaprzyjaźnione nie umożliwiają dostępu do składowych prywatnych.
Do oznaczania podzespołów udostępniających swe wewnętrzne składowe zaprzyjaźnionym
podzespołom służy nowy atrybut,
InternalsVisibleToAttribute
. Ten atrybut jest sto-
sowany na poziomie podzespołu. Do tego atrybutu należy przekazać nazwę oraz znacznik
klucza publicznego zewnętrznego podzespołu. Kompilator będzie traktował te podze-
społy jako zaprzyjaźnione. Podzespół zawierający atrybut
InternalsVisibleToAttribute
udostępnia swe wewnętrzne składowe drugiemu podzespołowi (ale już nie na odwrót).
Można uzyskać ten sam efekt, używając opcji kompilatora ustawianych w wierszu poleceń.
Podzespoły zaprzyjaźnione, jak to często bywa, mają pewne wady. Zdefiniowanie podze-
społu jako zaprzyjaźnionego z innym podzespołem powoduje ich ścisłe powiązanie. Takie
podzespoły muszą współwystępować, aby były przydatne. Oznacza to, że nie stanowią
już odrębnych jednostek. Może to spowodować nieład, a takimi podzespołami trudniej jest
zarządzać. Często lepiej jest nie korzystać z tej właściwości dopóty, dopóki nie zajdzie
istotna potrzeba.
Rozszerzenia platformy .NET 2.0
Ponieważ w platformie .NET wprowadzono tak wiele nowinek, nie warto rozpoczynać ich
opisu w tym miejscu. Oczywiście postaramy się przedstawić je w następnych rozdziałach.
Chcemy jednak wyróżnić kilka kluczowych rozszerzeń, które sprawiają, że nowa wersja
platformy .NET to poważny krok naprzód. Poniżej przedstawiamy niektóre z tych nowości:
Obsługa systemów 64-bitowych — teraz można kompilować aplikacje .NET
przeznaczone dla 64-bitowych wersji systemów operacyjnych. Obejmuje
to obsługę systemów natywnych oraz zgodność z emulatorem WOW64
(umożliwia uruchamianie 32-bitowych aplikacji w systemach 64-bitowych).
Obsługa ACL — programiści używający .NET mogą teraz korzystać z listy
kontroli dostępu (ang. Access Control List — ACL) do zarządzania z poziomu
kodu uprawnieniami do zasobów. W przestrzeni nazw
IO
(i innych) znajdują się
nowe klasy, które pomagają użytkownikiem nadawać uprawnienia do plików
i wykonywać inne operacje.
Strumienie uwierzytelnione — nowa klasa
NegotiateStream
umożliwia
bezpieczne (zaszyfrowane przy użyciu SSL) uwierzytelnianie między klientem
a serwerem (jednostką nasłuchującą) w czasie przesyłania informacji w sieci.
Dzięki tej klasie można bezpiecznie przesyłać dane uwierzytelniające klienta
poprzez personifikację lub delegację. Ponadto nowa klasa
SslStream
umożliwia
szyfrowanie danych w czasie ich przesyłania.
Data Protection API (DPAPI) — w .NET 2.0 zmieniła się obsługa interfejsu
DPAPI. Obecnie obejmuje ona możliwość szyfrowania po stronie serwera hasła
i łańcuchów znaków połączenia. Programiści mogli używać tych opcji także
w poprzednich wersji .NET, pobierając specjalną nakładkę. W wersji 2.0
dostęp do tego interfejsu jest wbudowany w platformę.
Rozdział 3.
Rozszerzenia platformy i języków .NET w wersji 2005
99
Wykrywanie zmian w sieci — aplikacja może teraz otrzymywać
powiadomienia o utracie połączenia z siecią. Dzięki klasie
NetworkChange
programiści wiedzą, kiedy komputer, na którym działa aplikacja, utracił
bezprzewodowe połączenie lub zmienił adres IP.
Obsługa protokołu FTP — przestrzeń nazw
System.Net
udostępnia obecnie
klasy służące do obsługi protokołu FTP. Programiści mogą używać klas
WebRequest
,
WebResponse
i
WebClient
do przesyłania oraz pobierania plików
poprzez ten protokół.
Rozszerzenia dotyczące globalizacji — nowa wersja platformy umożliwia
programistom definiowanie własnych niestandardowych ustawień lokalnych.
Daje to niezwykłą elastyczność w zakresie obsługi w aplikacjach informacji
dotyczących kultury. Ponadto platforma .NET 2.0 zapewnia ulepszoną obsługę
Unicode.
Większa kontrola nad pamięcią podręczną — programiści mogą teraz
używać przestrzeni nazw
System.Net.Cache
do programowej kontroli pamięci
podręcznej.
Obsługa szeregowych urządzeń wejścia-wyjścia — w przestrzeni nazw
System.IO
znajduje się nowa klasa
SerialPort
. Ta klasa umożliwia
programistom używanie urządzeń, które łączą się z portami szeregowymi
komputera.
Rozszerzona obsługa protokołu SMTP — przestrzeń nazw
System.Net.Mail
umożliwia programistom przesyłanie listów elektronicznych za pomocą
serwera SMTP.
Transakcje — programiści używający .NET mogą teraz korzystać z nowej
przestrzeni nazw
System.Transactions
, która umożliwia klasom utworzonym
dla platformy .NET łatwe uczestniczenie w transakcjach rozproszonych.
Do obsługi transakcji służy koordynator transakcji rozproszonych Microsoftu
(ang. Microsoft Distributed Transaction Coordinator — MSDTC).
Nowe właściwości w podstawowych technologiach
ADO.NET, ASP.NET i formularze Windows zostały rozbudowane w wersji 2005. Każda
z tych technologii mogłaby być tematem odrębnej książki. Na przykład ADO.NET ob-
sługuje obecnie typy definiowane przez użytkownika (ang. User-Defined Type — UDT)
i asynchroniczne operacje w bazie danych. Zarówno ASP, jak i formularze Windows
udostępniają wiele nowych kontrolek (oraz rozbudowane wersje starych). W obu tych tech-
nologiach możliwe jest wiązanie danych bez konieczności pisania kodu. Radzimy do-
kładnie zapoznać się z tymi zagadnieniami i przyjrzeć się wielu nowym właściwościom
w zakresie tych technologii.
100
Część I
Wprowadzenie do Visual Studio 2005 i .NET
Podsumowanie
W tym rozdziale przedstawiliśmy podstawowe rozszerzenia języka .NET, które są klu-
czowe dla programistów, ponieważ ułatwiają szybsze pisanie lepszego kodu. Nowinki
takie jak typy ogólne pomagają zapewnić bezpieczeństwo typów w kolekcjach, co po-
zwala zmniejszyć liczbę błędów. Typy dopuszczające wartość
null
pozwalają pisać kod
bez konieczności przypisywania wartości niezainicjowanym zmiennym i obsługi „ma-
gicznych liczb”. Te i podobne nowości wprowadzone w językach C# i Visual Basic
przyczyniają się do ewolucji omawianego zestawu narzędzi i zwiększają produktywność
programistów.
Na zakończenie rozdziału pokrótce opisaliśmy niektóre z nowych elementów platformy
.NET. Dostępnych jest mnóstwo nowinek. Platforma staje się tak rozbudowana, że progra-
miści (i książki) często są wyspecjalizowani w danym obszarze. Radzimy przejrzeć listę
rozszerzeń, a następnie kontynuować eksplorację w zakresie interesującej Cię dziedziny.