Microsoft Visual Studio - Helionpdf.helion.pl/vs21ke/vs21ke.pdf · rozszerzenia środowiska IDE...

Idź do

• Spis treści• Przykładowy rozdział• Skorowidz

• Katalog online

• Dodaj do koszyka

• Zamów cennik

• Zamów informacjeo nowościach

• Fragmenty książekonline

Helion SAul. Kościuszki 1c44-100 Gliwicetel. 32 230 98 63e-mail: [email protected]© Helion 1991–2011

Katalog książek

Twój koszyk

Cennik i informacje

Czytelnia

Kontakt

• Zamów drukowanykatalog

Microsoft Visual Studio2010. Księga eksperta

Autorzy: Mike Snell, Lars Powers

Tłumaczenie: Tomasz Walczak

ISBN: 978-83-246-3029-5

Tytuł oryginału: Microsoft Visual Studio 2010 Unleashed

Format: 172×245, stron: 1264

Poznaj środowisko Visual Studio 2010 Professional i naucz się tworzyć mistrzowskie aplikacje• Jak wykorzystać technologię ASP.NET do tworzenia profesjonalnych witryn internetowych?

• Jak tworzyć aplikacje biznesowe oparte na pakiecie Office?

• Jak kompleksowo testować swój kod, zaprzęgając do pracy Visual Studio?

Visual Studio 2010 to najnowsza wersja środowiska programistycznego firmy Microsoft. Każdy

programista, który zdecyduje się wykorzystać bogaty zestaw zgromadzonych tu narzędzi, osiągnie

maksymalną produktywność w pracy i będzie mógł tworzyć kod działający w systemie Windows

oraz w sieci. Dodatkowo będzie mieć do dyspozycji technologię Silverlight i możliwość budowania

aplikacji w chmurze, z użyciem platformy Microsoftu – Azure. Nie koniec na tym. W Visual Studio

2010 pojawiły się kolejne innowacje. Znajdziesz tu nowy edytor kodu, oparty na platformie WPF,

rozszerzenia środowiska IDE związane z platformą MEF oraz możliwość pisania skryptów za pomocą

technologii Silverlight. Ponadto języki platformy .NET wzbogacono o obsługę programowania

dynamicznego. Pojawił się nowy język F#, służący do programowania funkcyjnego, oraz

mechanizmy usprawniające szybkie pisanie kodu wyższej jakości.

„Microsoft Visual Studio 2010. Księga eksperta” zawiera kompletne omówienie środowiska Visual

Studio 2010, a skoncentrowanie się na wersji Professional pozwoliło autorom na stworzenie opisu

bardziej szczegółowego niż kiedykolwiek wcześniej. Dzięki temu podręcznikowi nauczysz się

w pełni wykorzystywać możliwości platformy .NET, w tym technologii WPF (pozwalającej na

tworzenie bogatych klientów), technologii WCF (stworzonej do budowania dynamicznych rozwiązań

opartych na usługach) czy też technologii WF (umożliwiającej rozwijanie ustrukturyzowanych

programów na podstawie procesów biznesowych). Znajdziesz tu także omówienie nowych

narzędzi Microsoftu, przeznaczonych do testowania, instrumentacji aplikacji i analizowania kodu.

• Języki platformy .NET

• Przeglądarki i eksploratory

• Tworzenie projektów WPF

• Szablony XML

• Testowanie, refaktoryzacja i diagnozowanie kodu

• Platforma MEF

• Tworzenie aplikacji ASP.NET

• Bogate i inteligentne interfejsy użytkownika

• Złożone aplikacje internetowe

• Silverlight 4.0

• Aplikacje biznesowe oparte na pakiecie Office

• Technologia Windows Azure i aplikacje działające w chmurze

Wykorzystaj zdobytą wiedzę i zostań mistrzem programowania!

http://helion.pl

http://helion.pl/zamow_katalog.htm

http://helion.pl/katalog.htm

http://helion.pl/zakupy/add.cgi?id=vs21ke

http://helion.pl/emaile.cgi

http://helion.pl/cennik.htm

http://helion.pl/online.htm

mailto:[email protected]

http://helion.pl/ksiazki/vs21ke.htm

http://www.amazon.com/exec/obidos/ASIN/0672330814/helion-20

7

Spis treści

Spis treści

O autorach ................................................................................................. 21

Wprowadzenie .......................................................................................... 23Dla kogo przeznaczona jest ta książka? ................................................................................ 23Koncentracja na wersji Visual Studio Professional ............................................................ 24Materiały do pobrania ............................................................................................................. 25Jak zorganizowana jest książka? ............................................................................................. 25

Część I: Wprowadzenie do Visual Studio 2010 ............................................................... 25Część II: Szczegółowe omówienie środowiska IDE ......................................................... 25Część III: Tworzenie kodu i zarządzanie nim .................................................................. 25Część IV: Wzbogacanie środowiska Visual Studio ......................................................... 26Część V: Tworzenie aplikacji dla przedsiębiorstw ........................................................... 26

Konwencje używane w książce ............................................................................................... 26

Część I Wprowadzenie do Visual Studio 2010 .......................... 27

Rozdział 1. Krótki przegląd środowiska Visual Studio 2010 .................................... 29

Produkty z rodziny Visual Studio ......................................................................................... 31Wersje Express ...................................................................................................................... 32Wersja Professional .............................................................................................................. 33Wersja Premium ................................................................................................................... 34Wersja Ultimate .................................................................................................................... 34MSDN .................................................................................................................................... 35Powiązane narzędzia ............................................................................................................ 36

Języki, platformy i szablony aplikacji .................................................................................... 40Wybieranie języków programowania ................................................................................ 40Platformy .NET ..................................................................................................................... 42Wiele aspektów aplikacji dla platformy .NET .................................................................. 43

Tworzenie bogat(sz)ych interfejsów sieciowych ............................................................... 46Formularze Windows .......................................................................................................... 46Platforma WPF ..................................................................................................................... 47Rozwiązania oparte na pakiecie Office .............................................................................. 50

Tworzenie klientów sieciowych ............................................................................................. 53Budowanie witryn za pomocą technologii ASP.NET ..................................................... 54Wzbogacanie aplikacji za pomocą AJAX-a ...................................................................... 58Programowanie za pomocą technologii Silverlight ......................................................... 59

Programowanie pod kątem chmury ..................................................................................... 63Tworzenie aplikacji działających w chmurze ................................................................... 64Uruchamianie aplikacji w chmurze ................................................................................... 64Publikowanie aplikacji w chmurze .................................................................................... 66

8

Spis treści

Praca z danymi ......................................................................................................................... 67Projektowanie danych ......................................................................................................... 67Oddzielanie projektu danych od modelu źródła danych ............................................... 68Tworzenie aplikacji okresowo nawiązujących połączenie .............................................. 71

Tworzenie powiązanych rozwiązań opartych na usługach ................................................ 71Tworzenie aplikacji i procesów biznesowych ................................................................... 72Tworzenie i konsumowanie usług ..................................................................................... 74

Podsumowanie ......................................................................................................................... 76

Rozdział 2. Środowisko IDE Visual Studio ................................................................. 77

Instalowanie środowiska Visual Studio ................................................................................ 78Wybór języka ......................................................................................................................... 78Konfigurowanie środowiska programistycznego ............................................................ 79

Strona startowa ......................................................................................................................... 83Opcje uruchomieniowe ....................................................................................................... 84

Pierwszy projekt ....................................................................................................................... 85Wybieranie docelowego środowiska ................................................................................. 86

Poruszanie się po środowisku IDE ........................................................................................ 88Menu ...................................................................................................................................... 89Liczne paski narzędzi ........................................................................................................... 94Dostosowywanie pasków narzędzi .................................................................................... 95Solution Explorer .................................................................................................................. 97Edytory tekstu ....................................................................................................................... 98Graficzne okna projektowe ............................................................................................... 102

Okno narzędzi ........................................................................................................................ 103Okno Properties .................................................................................................................. 104

Zarządzanie wieloma oknami środowiska IDE ................................................................. 105Przyczepianie ...................................................................................................................... 105Dokowanie ........................................................................................................................... 106Poruszanie się między oknami środowiska .................................................................... 108Dostosowywanie czcionki ................................................................................................. 110

Podsumowanie ....................................................................................................................... 111

Rozdział 3. Języki platformy .NET ............................................................................. 113

Wprowadzenie do języków ................................................................................................... 114Programowanie obiektów ................................................................................................. 115Typy, zmienne i stałe ......................................................................................................... 129Operatory ............................................................................................................................. 133Podejmowanie decyzji i rozgałęzianie kodu ................................................................... 135Pętle ...................................................................................................................................... 138Praca z grupami elementów .............................................................................................. 141Programowanie z wykorzystaniem atrybutów ............................................................... 145Tworzenie i zgłaszanie zdarzeń ........................................................................................ 147

Mechanizmy języka ............................................................................................................... 150Wykrywanie typu zmiennej na podstawie przypisania ................................................ 151Tworzenie obiektów i ustawianie ich właściwości w jednym wierszu kodu .............. 153

9

Spis treści

Definiowanie kolekcji i inicjowanie ich wartości (nowość) ......................................... 155Tworzenie egzemplarzy nieistniejących klas .................................................................. 156Dodawanie metod do istniejących klas ........................................................................... 157Dodawanie logiki biznesowej do wygenerowanego kodu ............................................ 158Dostęp do danych i pobieranie ich za pomocą języków .NET .................................... 160Pisanie prostych funkcji anonimowych w kodzie ......................................................... 162Dzielenie podzespołów na wiele plików .......................................................................... 164Bezpośrednie korzystanie z elementów XML (tylko w języku Visual Basic) ............ 164Usuwanie nieużywanych argumentów z metod obsługi zdarzeń

(tylko w Visual Basic) ...................................................................................................... 166Automatyczne generowanie kodu do obsługi właściwości

(nowość w Visual Basic) ................................................................................................. 166Rezygnacja z podkreślenia przy kontynuowaniu wiersza w języku Visual Basic

(nowość) ............................................................................................................................ 167Korzystanie z dynamicznych obiektów i języków (nowość) ........................................ 167Kowariancja i kontrawariancja (nowość) ....................................................................... 173

Platforma .NET ...................................................................................................................... 175Podsumowanie ....................................................................................................................... 177

Część II Szczegółowe omówienie środowiska IDE .................. 179

Rozdział 4. Rozwiązania i projekty ........................................................................... 181Wprowadzenie do rozwiązań ............................................................................................... 182

Tworzenie rozwiązania ...................................................................................................... 183Korzystanie z rozwiązań .................................................................................................... 188

Zapoznawanie się z projektami ............................................................................................ 194Tworzenie projektu ............................................................................................................ 194Używanie plików definicji projektu ................................................................................. 198Praca z projektami .............................................................................................................. 203

Podsumowanie ....................................................................................................................... 209

Rozdział 5. Przeglądarki i eksploratory ................................................................... 211Okno Solution Explorer ........................................................................................................ 212

Ikony i wskazówki graficzne ............................................................................................. 213Zarządzanie rozwiązaniami .............................................................................................. 217Zarządzanie projektami ..................................................................................................... 218

Okno Class View .................................................................................................................... 219Pasek narzędzi ..................................................................................................................... 220Pasek wyszukiwania ........................................................................................................... 220Panel obiektów .................................................................................................................... 221Panel składowych ............................................................................................................... 222

Okno Server Explorer ............................................................................................................ 223Połączenia z danymi ........................................................................................................... 224Komponenty serwera ......................................................................................................... 225

Okno Object Browser ............................................................................................................ 229Zmiana zasięgu ................................................................................................................... 229Przeglądanie obiektów ....................................................................................................... 230

10

Spis treści

Okno Document Outline ...................................................................................................... 232Modyfikowanie elementów ............................................................................................... 233

Podsumowanie ....................................................................................................................... 234

Rozdział 6. Wprowadzenie do edytorów i okien projektowych ............................ 235

Podstawy ................................................................................................................................. 236Edytor tekstu ....................................................................................................................... 237Okna projektowe środowiska Visual Studio .................................................................. 240

Pisanie kodu w edytorze ....................................................................................................... 240Otwieranie edytora ............................................................................................................. 241Pisanie kodu ........................................................................................................................ 241Budowa okna edytora kodu .............................................................................................. 243Narzędzia do nawigowania po kodzie ............................................................................. 246Przeszukiwanie dokumentów ........................................................................................... 249Diagnozowanie w edytorze kodu ..................................................................................... 258Drukowanie kodu ............................................................................................................... 262Używanie okna Code Definition ...................................................................................... 262

Tworzenie i modyfikowanie dokumentów oraz szablonów XML .................................. 264Generowanie szablonów .................................................................................................... 265Projektowanie szablonów XML ....................................................................................... 265Edycja arkuszy stylów XSLT ............................................................................................. 269

Używanie kaskadowych arkuszy stylów ............................................................................. 270Dodawanie zasad stylów .................................................................................................... 271Definiowanie atrybutów arkuszy stylów ......................................................................... 271

Tworzenie aplikacji klienckich dla systemu Windows ..................................................... 271Tworzenie projektów aplikacji dla systemu Windows ................................................. 272Tworzenie projektów WPF ............................................................................................... 280

Tworzenie formularzy sieciowych ....................................................................................... 282Projektowanie aplikacji opartych na formularzach sieciowych .................................. 283

Tworzenie komponentów i kontrolek ................................................................................ 289Tworzenie nowego komponentu lub kontrolki ............................................................. 290Uwagi na temat pisania kodu komponentów ................................................................ 291

Tworzenie klas za pomocą okna Class Designer ............................................................... 293Tworzenie diagramu klasy ................................................................................................ 293Dodawanie elementów do diagramu ............................................................................... 294Definiowanie relacji między klasami ............................................................................... 296Definiowanie metod, właściwości, pól i zdarzeń ........................................................... 298

Podsumowanie ....................................................................................................................... 299

Rozdział 7. Społeczność .NET — interakcje w internecie ....................................... 301

Możliwości Visual Studio związane ze społecznością ...................................................... 302Strona startowa Visual Studio .......................................................................................... 303

Dostęp do systemu pomocy ................................................................................................. 312Zarządzanie ustawieniami systemu pomocy .................................................................. 312Zgłaszanie błędów i przesyłanie innych informacji zwrotnych ................................... 323Przykłady ............................................................................................................................. 326

11

Spis treści

Wykrywanie i wykorzystanie współużytkowanych zasobów .......................................... 328Rodzaje współużytkowanych zasobów ............................................................................ 328Wyszukiwanie odpowiednich zasobów ........................................................................... 328Instalowanie i przechowywanie udostępnianych zasobów .......................................... 330

Własny wkład w społeczność ............................................................................................... 332Pakiety startowe a szablony .............................................................................................. 333Tworzenie szablonów projektów ..................................................................................... 333Tworzenie szablonów elementów .................................................................................... 340Tworzenie pakietów w celu ich rozpowszechniania ..................................................... 341

Podsumowanie ....................................................................................................................... 356

Część III Tworzenie kodu i zarządzanie nim .............................. 359

Rozdział 8. Korzystanie z narzędzi zwiększających produktywność .................... 361

Podstawowe narzędzia pomocnicze edytorów tekstu ...................................................... 364Śledzenie zmian .................................................................................................................. 364Wskazówki dotyczące problemów ................................................................................... 364Aktywne odnośniki ............................................................................................................ 365Kolorowanie składni .......................................................................................................... 365

Schematy i nawigacja ............................................................................................................. 367Schematy kodu .................................................................................................................... 367Nawigowanie po znacznikach .......................................................................................... 370

Inteligentne znaczniki i operacje ......................................................................................... 372Okno projektowe HTML-a ............................................................................................... 372Okno projektowe formularzy Windows ......................................................................... 373Edytor kodu ......................................................................................................................... 373

Mechanizm IntelliSense ........................................................................................................ 375Uzupełnianie słów (Complete Word) ............................................................................. 375Okno z informacjami podręcznymi (Quick Info) ......................................................... 377Okno z listą składowych (List Members) ........................................................................ 378Okno z informacjami o parametrach (Parameter Info) ............................................... 379Porządkowanie instrukcji Using ...................................................................................... 380Fragmenty kodu i kod szablonowy .................................................................................. 380Dopasowywanie nawiasów ............................................................................................... 391Dostosowywanie mechanizmu IntelliSense do własnych potrzeb .............................. 392

Okno Task List ....................................................................................................................... 393Zadania związane z komentarzami .................................................................................. 394Zadania związane ze skrótami .......................................................................................... 395Zadania użytkownika ......................................................................................................... 396

Podsumowanie ....................................................................................................................... 396

Rozdział 9. Testowanie kodu .................................................................................... 397

Podstawy testów jednostek ................................................................................................... 399Tworzenie projektu testów ................................................................................................ 399Generowanie testów na podstawie istniejącego kodu ................................................... 402Pisanie testów jednostek .................................................................................................... 405

12

Spis treści

Uruchamianie testów jednostek ....................................................................................... 407Konfigurowanie opcji i ustawień testów ......................................................................... 409

Platforma testów jednostek .................................................................................................. 413Klasa TestContext ............................................................................................................... 413Klasy atrybutów testów ...................................................................................................... 415Operacje wykonywane przed testami jednostek i po nich ........................................... 418Klasy asercji ......................................................................................................................... 420Testowanie wyjątków ......................................................................................................... 422Tworzenie testów jednostek zależnych od danych ........................................................ 423

Pisanie testów jednostek działających w ASP.NET ........................................................... 428Definiowanie atrybutów środowiska ASP.NET ............................................................. 428Generowanie testów jednostek ASP.NET ....................................................................... 429Konfigurowanie hosta projektu testów ........................................................................... 430

Konfigurowanie atrybutów testów jednostek .................................................................... 431Definiowanie połączenia za pomocą okna dialogowego Properties ........................... 431

Tworzenie testów uporządkowanych ................................................................................. 433Organizowanie testów ........................................................................................................... 434

Okno Test View .................................................................................................................. 434Okno Test List Editor ........................................................................................................ 435

Podsumowanie ....................................................................................................................... 438

Rozdział 10. Refaktoryzacja kodu ............................................................................... 439Podstawy refaktoryzacji w Visual Studio ........................................................................... 441

Uruchamianie narzędzi do refaktoryzacji ....................................................................... 441Podgląd zmian .................................................................................................................... 445

Zmienianie nazw .................................................................................................................... 446Uruchamianie operacji Rename ....................................................................................... 447Używanie okna dialogowego Rename ............................................................................. 449

Wyodrębnianie metod .......................................................................................................... 450Uruchamianie refaktoryzacji Extract Method ............................................................... 451Wyodrębnianie metod ....................................................................................................... 451Generowanie szkieletu metody ........................................................................................ 457

Wyodrębnianie interfejsów .................................................................................................. 459Uruchamianie refaktoryzacji Extract Interface .............................................................. 459Wyodrębnianie interfejsów ............................................................................................... 459

Refaktoryzacja parametrów .................................................................................................. 462Usuwanie parametrów ....................................................................................................... 462Zmiana kolejności parametrów ........................................................................................ 463

Hermetyzacja pól ................................................................................................................... 465Uruchamianie refaktoryzacji Encapsulate Field ............................................................ 465Okno dialogowe Encapsulate Field .................................................................................. 465

Podsumowanie ....................................................................................................................... 466

Rozdział 11. Diagnozowanie kodu ............................................................................. 467

Podstawy diagnozowania ...................................................................................................... 468Scenariusz ............................................................................................................................ 469Wiele etapów diagnozowania ........................................................................................... 469

13

Spis treści

Diagnozowanie aplikacji (samodzielne sprawdzanie) .................................................. 470Podsumowanie podstaw diagnozowania ........................................................................ 481

Debuger środowiska Visual Studio ..................................................................................... 481Menu i pasek narzędzi Debug .......................................................................................... 482Opcje diagnozowania ......................................................................................................... 487Wkraczanie w kod, wychodzenie z niego i przeskakiwanie ......................................... 488Określanie warunków wstrzymania wykonywania kodu ............................................. 494Korzystanie z punktów śledzenia (opcja When Hit) ..................................................... 503Podglądanie danych w debugerze .................................................................................... 505Korzystanie z funkcji „zmień i kontynuuj” .................................................................... 511

Diagnozowanie zaawansowane ............................................................................................ 513Zdalne diagnozowanie ....................................................................................................... 513Diagnozowanie usług WCF .............................................................................................. 514Diagnozowanie aplikacji wielowątkowych ..................................................................... 515Diagnozowanie aplikacji równoległych .......................................................................... 520Diagnozowanie skryptów działających po stronie klienta ........................................... 526Diagnozowanie informacji o awarii (plików zrzutów) ................................................. 527

Podsumowanie ....................................................................................................................... 530

Rozdział 12. Wdrażanie kodu ...................................................................................... 533Przegląd sposobów wdrażania rozwiązań po stronie klienta .......................................... 534

Wprowadzenie do wdrażania metodą ClickOnce ......................................................... 534Wprowadzenie do wdrażania za pomocą instalatora systemu Windows .................. 535

Publikowanie projektów za pomocą technologii ClickOnce ........................................... 536Publikowanie projektów za pomocą instalatora systemu Windows .............................. 539

Edytor File System .............................................................................................................. 542Edytor Registry ................................................................................................................... 543Edytor File Types ................................................................................................................ 544Edytor User Interface ......................................................................................................... 545Edytor Custom Actions ..................................................................................................... 546Edytor Launch Conditions ................................................................................................ 546

Publikowanie witryn i aplikacji ASP.NET ......................................................................... 549Korzystanie z narzędzia Web Deployment Tool ........................................................... 550Korzystanie z narzędzia Copy Web Site Tool ................................................................ 554

Podsumowanie ....................................................................................................................... 556

Część IV Wzbogacanie środowiska Visual Studio ..................... 557

Rozdział 13. Wprowadzenie do obiektowego modelu automatyzacji .................... 559

Przegląd obiektowego modelu automatyzacji .......................................................................... 561Wersje modelu obiektowego ............................................................................................ 561Kategorie automatyzacji .................................................................................................... 563Obiekt główny DTE (DTE2) ............................................................................................. 564

Obiekty Solution i Project ..................................................................................................... 565Kontrolowanie projektów wchodzących w skład rozwiązania .................................... 568Dostęp do kodu projektu ................................................................................................... 569

14

Spis treści

Okna ......................................................................................................................................... 572Dostęp do okien .................................................................................................................. 572Interakcja z oknami ............................................................................................................ 573Okna tekstowe i panele ...................................................................................................... 576Rodzaje okien narzędzi ...................................................................................................... 578Okna połączone .................................................................................................................. 586

Paski poleceń .......................................................................................................................... 588Dokumenty ............................................................................................................................. 592

Dokumenty tekstowe ......................................................................................................... 593Obiekty polecenia .................................................................................................................. 604

Wykonywanie poleceń ....................................................................................................... 606Dodawanie klawiszy skrótu .............................................................................................. 607

Obiekty debugera ................................................................................................................... 608Zdarzenia automatyzacji ....................................................................................................... 608Podsumowanie ....................................................................................................................... 609

Rozdział 14. Tworzenie makr ...................................................................................... 611

Rejestrowanie makr ............................................................................................................... 613Korzystanie z okna Macro Explorer .................................................................................... 614Pisanie makr za pomocą środowiska IDE Macros .......................................................... 616

Projekty makr ...................................................................................................................... 617Pisanie makr ........................................................................................................................ 620Diagnozowanie ................................................................................................................... 623Obsługa zdarzeń ................................................................................................................. 623Wywoływanie makr ........................................................................................................... 629

Podsumowanie ....................................................................................................................... 633

Rozdział 15. Tworzenie dodatków i kreatorów ......................................................... 635

Tworzenie pierwszego projektu dodatku ........................................................................... 637Ustawianie parametrów dodatku ..................................................................................... 637

Struktura dodatków ............................................................................................................... 645Cykl życia dodatków .......................................................................................................... 645Reagowanie na polecenia .................................................................................................. 651Zarządzanie dodatkami ..................................................................................................... 653

Przykładowy dodatek — paleta do wybierania kolorów .................................................. 654Początkowe operacje .......................................................................................................... 655Tworzenie klasy kontrolki użytkownika ......................................................................... 655Dopracowywanie klasy Connect ...................................................................................... 659Udostępnianie ustawień dodatku ..................................................................................... 662

Tworzenie kreatorów dla środowiska Visual Studio ........................................................ 677Analiza struktury kreatorów ............................................................................................. 677Tworzenie kreatorów typu Add New Item ..................................................................... 680

Podsumowanie ....................................................................................................................... 686

Rozdział 16. Rozbudowywanie edytora kodu przy użyciu platformy MEF ............. 687

Problem z rozszerzaniem ...................................................................................................... 688Tworzenie dynamicznych aplikacji ................................................................................. 688

15

Spis treści

Architektura platformy MEF ............................................................................................... 689Reguły działania platformy MEF ..................................................................................... 689Korzystanie z platformy MEF ........................................................................................... 690

Edytor środowiska Visual Studio i platforma MEF .......................................................... 691Punkty dołączania rozszerzeń do edytora ...................................................................... 692Korzystanie z pakietu Visual Studio SDK ....................................................................... 693Korzystanie z menedżera rozszerzeń ............................................................................... 699

Tworzenie rozszerzenia edytora za pomocą platformy MEF .......................................... 701Podsumowanie ....................................................................................................................... 709

Część V Tworzenie aplikacji dla przedsiębiorstw .................... 711

Rozdział 17. Tworzenie aplikacji ASP.NET ................................................................. 713

Podstawy tworzenia witryn w ASP.NET ............................................................................ 715Tworzenie nowego projektu witryny lub aplikacji sieciowej ....................................... 715Kontrolowanie właściwości i opcji projektu ................................................................... 728Tworzenie stron internetowych ....................................................................................... 736

Projektowanie interfejsu użytkownika ............................................................................... 745Określanie układu strony i położenia kontrolek ........................................................... 746Tworzenie jednolitego wyglądu i zachowania ................................................................ 753Tworzenie UI konfigurowanego przez użytkownika .................................................... 775

Praca z kontrolkami ASP.NET ............................................................................................. 787Przegląd kontrolek ASP.NET ........................................................................................... 787Standardowe kontrolki ASP.NET .................................................................................... 790Kontrolki do sprawdzania poprawności ......................................................................... 792Kontrolki logowania .......................................................................................................... 794Kontrolki nawigacyjne witryny ........................................................................................ 797Kontrolki danych ................................................................................................................ 798Kontrolki użytkownika ...................................................................................................... 800

Tworzenie aplikacji ASP.NET MVC ................................................................................... 804Wprowadzenie do aplikacji ASP.NET MVC ................................................................. 804Tworzenie projektów MVC .............................................................................................. 808Dodawanie mechanizmów za pomocą ASP.NET MVC ............................................... 811

Podsumowanie ....................................................................................................................... 820

Rozdział 18. Tworzenie aplikacji opartych na formularzach Windows ................... 821

Podstawy projektowania formularzy .................................................................................. 822Uwzględnianie użytkownika końcowego ........................................................................ 823Rola standardów UI ........................................................................................................... 824Planowanie interfejsu użytkownika ................................................................................. 825

Tworzenie formularza ........................................................................................................... 826Typ projektu Windows Application ................................................................................ 826Właściwości i zdarzenia formularza ................................................................................ 827

Dodawanie kontrolek i komponentów ............................................................................... 830Układ i pozycjonowanie kontrolek .................................................................................. 831Używanie kontenerów ....................................................................................................... 836

16

Spis treści

Wygląd i zachowanie kontrolek ....................................................................................... 840Praca z kontrolkami ToolStrip ......................................................................................... 841Wyświetlanie danych ......................................................................................................... 849

Tworzenie własnych kontrolek ............................................................................................ 853Dziedziczenie po istniejącej kontrolce ............................................................................ 853Projektowanie kontrolki użytkownika ............................................................................ 854Tworzenie kontrolki niestandardowej ............................................................................ 857

Podsumowanie ....................................................................................................................... 857

Rozdział 19. Tworzenie bogatszych i bardziej inteligentnych

interfejsów użytkownika ....................................................................... 859Platforma Windows Presentation Foundation ...................................................................... 860

Model programowania ...................................................................................................... 863Wprowadzenie do okna projektowego WPF ........................................................................ 865

XAML i panele projektowe ............................................................................................... 866Programowanie z wykorzystaniem WPF ........................................................................... 871

Układ .................................................................................................................................... 871Style i szablony .................................................................................................................... 878Wiązanie danych ................................................................................................................ 881Zdarzenia przekazywane ................................................................................................... 883

Tworzenie prostej przeglądarki obrazów ........................................................................... 884Rozpoczynanie tworzenia układu .................................................................................... 885Zapisywanie obrazów ......................................................................................................... 891Wiązanie rysunków ............................................................................................................ 893Metody do obsługi zdarzeń związanych

z przyciskami i efekty do modyfikowania obrazu ....................................................... 894Wybór katalogu przy użyciu standardowego okna dialogowego ................................ 895

Podsumowanie ....................................................................................................................... 901

Rozdział 20. Tworzenie bogatych aplikacji internetowych ..................................... 903

Technologia ASP.NET Ajax i bogate interfejsy działającew różnych przeglądarkach ................................................................................................. 904Ajaksowe kontrolki w ASP.NET ...................................................................................... 905Tworzenie stron obsługujących częściową aktualizację ............................................... 907ASP.NET Ajax Library i Ajax Control Toolkit .............................................................. 915

Tworzenie wyjątkowych, bogatych interakcji opartychna przeglądarkach w systemie Windows ......................................................................... 921Niezależne aplikacje WPF a programy XBAP WPF ...................................................... 922Tworzenie aplikacji WPF uruchamianych w przeglądarce .......................................... 922Zagadnienia związane z zabezpieczeniami ..................................................................... 926Instalowanie aplikacji XBAP ............................................................................................. 929

Udostępnianie interaktywnych aplikacji w różnych systemach ..................................... 933Wprowadzenie do Silverlight ........................................................................................... 933Tworzenie aplikacji Silverlight ......................................................................................... 934Silverlight 4.0 ....................................................................................................................... 939

Podsumowanie ....................................................................................................................... 940

17

Spis treści

Rozdział 21. Praca z bazami danych ........................................................................... 941

Tworzenie tabel i związków .................................................................................................. 942Tworzenie nowej bazy danych SQL Server ..................................................................... 943Definiowanie tabel .............................................................................................................. 945Korzystanie z Database Diagram Designer .................................................................... 947

Praca z poleceniami w SQL-u .............................................................................................. 951Pisanie zapytań ................................................................................................................... 951Tworzenie widoków ........................................................................................................... 955Tworzenie procedur składowanych ................................................................................. 956Tworzenie wyzwalaczy ...................................................................................................... 960Tworzenie funkcji definiowanych przez użytkownika ................................................. 961

Używanie projektów baz danych ......................................................................................... 961Tworzenie projektu bazy danych ..................................................................................... 962Okno Schema View ............................................................................................................ 967Kompilowanie i wdrażanie ............................................................................................... 968Uwagi na temat mechanizmu DAC ................................................................................. 969

Tworzenie obiektów bazy danych w kodzie zarządzanym .............................................. 970Rozpoczynanie projektu SQL Server CLR ...................................................................... 970Tworzenie procedury składowanej w C# ........................................................................ 971

Wiązanie kontrolek z danymi .............................................................................................. 974Wprowadzenie do wiązania danych ................................................................................ 974Automatyczne generowanie związanych kontrolek Windows Forms ....................... 976Modyfikowanie zbiorów danych o określonym typie ................................................... 981Ręczne wiązanie kontrolek formularzy Windows ......................................................... 982Wiązanie danych w aplikacjach WPF ............................................................................. 986Wiązanie danych z kontrolkami sieciowymi .................................................................. 989

Odwzorowania obiektowo-relacyjne .................................................................................. 993Przegląd technologii LINQ ............................................................................................... 994Odwzorowywanie przy użyciu narzędzia O/R Designer .............................................. 996Kod LINQ ............................................................................................................................ 998Korzystanie z platformy Entity ....................................................................................... 1001Kierowanie zapytań do modelu EDM ........................................................................... 1006

Podsumowanie ..................................................................................................................... 1008

Rozdział 22. Aplikacje oparte na usługach .............................................................. 1011

Wprowadzenie do usług ..................................................................................................... 1012Dlaczego usługi sieciowe ASP.NET i WCF? ................................................................. 1014

Aplikacje oparte na usługach sieciowych ASP.NET ....................................................... 1015Szablon projektu ASP.NET Web Service ...................................................................... 1017Tworzenie usługi sieciowej ASP.NET ........................................................................... 1020Konsumowanie usługi sieciowej ASP.NET .................................................................. 1033Wyjątki w usługach sieciowych ASP.NET .................................................................... 1039

Aplikacje oparte na usługach WCF ................................................................................... 1041Szablon projektu WCF .................................................................................................... 1043Tworzenie usług WCF ..................................................................................................... 1045Konfigurowanie usług WCF ........................................................................................... 1050

18

Spis treści

Konsumowanie usługi WCF ........................................................................................... 1055Hosting i instalowanie usług WCF ................................................................................ 1058

Podsumowanie ..................................................................................................................... 1060

Rozdział 23. Dodawanie procesów do aplikacji ...................................................... 1061

Podstawy technologii Windows Workflow ..................................................................... 1063Składniki procesu ............................................................................................................. 1063Szablony projektów typu Workflow .............................................................................. 1065Okno projektowe procesów ............................................................................................ 1067Szablony elementów procesów ....................................................................................... 1068Podstawy tworzenia procesów ........................................................................................ 1069

Korzystanie z wbudowanych czynności procesów ......................................................... 1082Sterowanie przepływem ................................................................................................... 1083Czynności Runtime i Primitives ..................................................................................... 1084Czynności Error Handling .............................................................................................. 1086Czynności Collection ....................................................................................................... 1086Obsługa transakcji ............................................................................................................ 1087Zarządzanie komunikatami ............................................................................................ 1089Tworzenie procesów typu Flowchart ............................................................................ 1094

Tworzenie aplikacji do zarządzania procesem .............................................................. 1096Scenariusz — zgłoszenia dotyczące podróży ................................................................ 1096Szablony projektów aplikacji .......................................................................................... 1097Tworzenie bazy danych i biblioteki dostępu do danych ............................................. 1099Tworzenie usługi do obsługi rezerwacji w biurze podróży ........................................ 1104Tworzenie niestandardowej biblioteki czynności ........................................................ 1105Projektowanie procesu zgłaszania podróży .................................................................. 1107Tworzenie aplikacji klienckiej (formularze do zgłaszania i zatwierdzania

podróży) .......................................................................................................................... 1119Uruchamianie aplikacji do obsługi procesu zgłaszania podróży .............................. 1124

Podsumowanie ..................................................................................................................... 1127

Rozdział 24. Tworzenie aplikacji biznesowych opartych na pakiecie Office ........ 1129Przegląd rozszerzalnych funkcji pakietu Office .............................................................. 1131

Funkcje pakietu Office ..................................................................................................... 1131Typy projektów Office w Visual Studio ........................................................................ 1135

Tworzenie dodatków dla pakietu Office ........................................................................... 1136Modyfikowanie wstążki ................................................................................................... 1137Modyfikowanie panelu zadań ......................................................................................... 1141Tworzenie regionów formularzy aplikacji Outlook .................................................... 1144

Tworzenie rozszerzeń dokumentów Office ..................................................................... 1147Kontrolki kontenerowe ................................................................................................... 1147Tworzenie paneli operacji ............................................................................................... 1149Przechowywanie danych w pamięci podręcznej .......................................................... 1150Implementowanie własnych tagów inteligentnych ..................................................... 1153

Podsumowanie ..................................................................................................................... 1156

19

Spis treści

Rozdział 25. Aplikacje działające w chmurze i technologia Windows Azure ....... 1157

Podstawy platformy Azure ................................................................................................. 1158Korzyści, jakie daje platforma Azure ............................................................................. 1158Konfigurowanie środowiska programistycznego ........................................................ 1160Role w platformie Azure .................................................................................................. 1164Szablony projektów na platformę Azure ...................................................................... 1165Sposoby przechowywania danych w platformie Azure .............................................. 1167Aplikacja Hello Cloud ...................................................................................................... 1170

Rozwijanie i wdrażanie aplikacji na platformę Azure .................................................... 1174Scenariusz .......................................................................................................................... 1174Rozwijanie aplikacji .......................................................................................................... 1175Subskrypcja usług platformy Azure (zakładanie konta) ............................................. 1188Tworzenie konta do przechowywania danych ............................................................. 1190Tworzenie konta usług hosted service ........................................................................... 1194Przygotowywanie aplikacji do publikacji ...................................................................... 1196Publikowanie i wdrażanie aplikacji w chmurze ........................................................... 1199Przenoszenie do środowiska produkcyjnego ............................................................... 1204Następne kroki .................................................................................................................. 1205

Podsumowanie ..................................................................................................................... 1207

Skorowidz ............................................................................................. 1209

Rozdział 9.

Testowanie kodu

398

Część III Tworzenie kodu i zarządzanie nim

W tym rozdziale:

� Podstawy testów jednostek� Platforma testów jednostek� Pisanie testów jednostek działających w ASP.NET� Konfigurowanie atrybutów testów jednostek� Tworzenie testów uporządkowanych� Organizowanie testów

Programiści zawsze byli odpowiedzialni za testowanie kodu przed udostępnieniem go testeromlub użytkownikom. W przeszłości oznaczało to przejście przez każdy wiersz kodu w debugerze(włączając w to wszystkie warunki i błędy). W tym celu często trzeba było przygotować apli-kacje testowe z operacjami potrzebnymi do wykonania kodu. Przejście przez cały kod pozwa-lało dojść do celu, ale nie zawsze programistom chciało się to robić (i bardzo trudno było tosprawdzić). W praktyce całą tę operację często pomijano w czasie wprowadzania zmian w ko-dzie i jego aktualizacji. Opisany proces utrudniał ponadto ustalenie, czy zmiany w kodzie wpły-wają na inne części systemu, a także powodował przesyłanie testerom i użytkownikom wersjio niższej jakości, co zwiększało liczbę usterek oraz wydłużało czas potrzebny na przesyłaniekodu tam i z powrotem między programistami a testerami.

Ten mechanizm (i efekty jego stosowania) wskazywał na potrzebę automatyzacji testowaniajednostek. W efekcie powstały różne przeznaczone do tego platformy. Pierwszą taką platformą dla.NET była NUnit (nunit.org) — projekt o otwartym dostępie do kodu źródłowego działający dlawiększości języków .NET, który umożliwia pisanie kodu służącego do testowania innego kodu.Podobna platforma została wbudowana w Visual Studio 2005 i jest dostępna także w obecnej wersji.

Platforma testów jednostek w Visual Studio umożliwia kompilowanie testów wraz z aplikacją.Można też zdecydować się na zastosowanie programowania sterowanego testami i przygotowaćtesty przed rozpoczęciem pisania kodu. W każdym przypadku ustrukturyzowane podejście dotestów jednostek może doprowadzić do utworzenia pełnego zestawu testów współpracującegoz aplikacją.

Pełny zestaw testów może składać się na test regresji dla większości komponentów, a nawet dlacałego systemu. Daje to większą pewność przy wykonywaniu operacji, które wcześniej były bardzoryzykowne, na przykład przy wprowadzaniu poprawek w ostatniej chwili, dokonywaniu refak-toryzacji czy dodawaniu elementów tuż przed zakończeniem pracy. Przy wykonywaniu tych działańmożna wykorzystać pełny zestaw testów jednostek do sprawdzenia, jakie elementy (i czy w ogóle)zostały zepsute w wyniku wprowadzenia zmian.

W tym rozdziale opisano wiele narzędzi, technologii i technik przeprowadzania testów przezprogramistów. Dzięki tym informacjom można zacząć czerpać liczne korzyści ze zautomaty-zowanych testów dostępnych programistom. Prowadzą one do zmniejszenia liczby błędów,powstawania bardziej zrozumiałego kodu i większej pewności przy wprowadzaniu zmian w kodzie.

399

Rozdział 9. Testowanie kodu

Podstawy testów jednostekTesty jednostek w Visual Studio polegają na tworzeniu testów sprawdzających kod warstwaplikacji. Warstwy obejmują liczne klasy z obszaru logiki biznesowej i obsługi danych. Dosprawdzania interfejsu użytkownika służą zwykle inne metody automatycznego testowania. Sąone przeznaczone głównie dla testerów. Potrzebne do tego funkcje i produkty znajdują się w wersjiPremium środowiska Visual Studio, dlatego nie opisujemy ich w tym miejscu. W zamiankoncentrujemy się na tworzeniu kodu do testowania innego kodu. Oczywiście, zakładamy przytym, że programista w czasie rozwijania aplikacji stosuje prawidłowe techniki budowania architek-tury warstwowej. W tym podrozdziale omawiamy podstawy pisania testów jednostek. W dal-szych punktach szczegółowo opisujemy przedstawione tu zagadnienia.

Tworzenie projektu testów

Testy programistów trzeba umieszczać w projektach testów. Projekt zawiera odpowiedniereferencje do platformy testów jednostek i trzeba skonfigurować go tak, aby można go byłouruchomić za pomocą narzędzi testowych wbudowanych w Visual Studio. Istnieją dwa głównesposoby tworzenia projektów testów jednostek. Można przygotować projekt testów w środowi-sku IDE lub automatycznie wygenerować testy jednostek dla istniejącego kodu w nowym pro-jekcie testów. Zaczniemy od pierwszej z tych możliwości.

Szablon projektu testów

Nowy projekt testów w Visual Studio można utworzyć w oknie dialogowym New Project (File/New/Project). W oknie dialogowym należy przejść do węzła Test Projects w drzewie InstalledTemplates. Węzeł pokazano na rysunku 9.1. Warto zauważyć, że projekt testów można umie-ścić w nowym lub istniejącym rozwiązaniu. Zwykle testy projektów dodaje się do gotowychrozwiązań, ponieważ w testach trzeba umieścić referencje do projektów z rozwiązania.

Rysunek 9.1. W oknie dialogowym New Project można utworzyć nowy projekt testów dla rozwiązania

400


Dobre praktyki tworzenia projektów i klas testów

Należy ustalić reguły określające liczbę projektów testów tworzonych dla rozwiązania.Zwykle programiści tworzą jeden projekt testów dla każdego sprawdzanego projektu.Na przykład jeśli w jednym projekcie znajdują się obiekty biznesowe, a w innym usługizwiązane z danymi, można utworzyć dwa projekty testowe (po jednym dla każdegoprojektu głównego). Nie jest to jednak wymóg, a jedynie sposób na łatwe zrozumienieorganizacji kodu.

Podobne zasady dotyczą klas testów. Należy utworzyć jedną klasę testów dla każdejklasy ze sprawdzanego docelowego projektu. Jeśli programista tworzy projekt testówdla kodu logiki biznesowej obejmującego obiekty Customer i Order, powinien przy-gotować klasy CustomerTest i OrderTest. Nie jest to konieczne, ale prowadzi do do-brego, logicznego uporządkowania kodu.

Projekt testów

W czasie tworzenia nowego projektu testów Visual Studio dodaje referencje do platformy testówjednostek (Microsoft.VisualStudio.QualityTools.UnitTestFramework). Ponadto dodajedo rozwiązania dwa pliki (w katalogu Solution Items). Są to pliki z konfiguracją (ustawieniami)testów. Ich nazwy to Local.testsettings i TraceAndTestImpact.testsettings. W projekcie testówtworzona jest też klasa testów używana do pisania testów jednostek. Na rysunku 9.2 pokazanokażdy z tych elementów w oknie Solution Explorer. Poszczególne pliki omawiamy szczegółowow dalszych punktach.

Rysunek 9.2.Projekt testówi powiązane elementyw oknie SolutionExplorer

401


Do projektu można dodać nowe pliki testów. W tym celu należy kliknąć prawym przyciskiemmyszy projekt testów i wybrać opcję Add/New Test. Ponadto można użyć menu Project i otwo-rzyć okno dialogowe Add New Test widoczne na rysunku 9.3. W tym miejscu dostępne sąnastępujące opcje:

� Basic Unit Test. Ten szablon tworzy prostą klasę testów z pustą metodą testową. Używasię go zwykle przy tworzeniu testów od podstaw (bez korzystania z funkcji automa-tycznego generowania testów).

� Database Unit Test. Ten szablon służy do tworzenia testów jednostek wykonywa-nych na procedurach składowanych z bazy danych (do stosowania tej funkcji po-trzebna jest wersja Premium środowiska Visual Studio).

� Ordered Test. Ten szablon umożliwia utworzenie sekwencyjnej listy wspólnie wyko-nywanych testów (zobacz podrozdział „Tworzenie testów uporządkowanych” w dal-szej części rozdziału).

� Unit Test. Ten szablon tworzy pustą klasę testów jednostek korzystającą z obiektu dośledzenia kontekstu testów. Tego typu klasy testów jednostek są generowane auto-matycznie (zobacz punkt „Generowanie testów na podstawie istniejącego kodu”).

� Unit Test Wizard. Ten szablon uruchamia kreator Unit Test Wizard służący do au-tomatycznego generowania testów na podstawie istniejącego kodu rozwiązania (zo-bacz punkt „Generowanie testów na podstawie istniejącego kodu”).

Rysunek 9.3.Za pomocą oknadialogowego Add New Testmożna dodawać nowe testydo projektu testów

Menu Test

Menu Test można wykorzystać do uzyskania dostępu do wszystkich funkcji środowiska VisualStudio związanych z testami przeprowadzanymi przez programistów. Menu pozwala między in-nymi dodawać klasy testów jednostek do projektu testów (Test/New Test). Można go ponadto

402


używać do wczytywania informacji o wcześniejszych testach (Load Metadata File), urucha-miania testów (z diagnozowaniem lub bez), wybierania ustawień stosowanych w następnymprzebiegu testów, a także edytowania takich ustawień. Można też uzyskać dostęp do wieluokien służących do wyświetlania i organizowania testów w aplikacji. Na rysunku 9.4 pokazanoprzykład ilustrujący wiele funkcji omawianego menu.

Rysunek 9.4. Menu Test środowiska Visual Studio pozwala uzyskać dostęp do funkcji środowiska związanychz testami przeprowadzanymi przez programistów

Generowanie testów na podstawie istniejącego kodu

Visual Studio umożliwia też automatyzację procesu tworzenia testów jednostek. Można klik-nąć prawym przyciskiem myszy istniejącą klasę i wybrać z menu podręcznego opcję CreateUnit Tests. Inna możliwość to wybranie szablonu elementu Unit Test Wizard. Oba rozwiązaniapowodują utworzenie przez Visual Studio zestawu testów jednostek na podstawie kodu klasy.

403


Wygenerowany kod to dobry punkt wyjścia do rozwijania testów jednostek. Visual Studioanalizuje metody i właściwości klasy, na podstawie której programista chce wygenerować testy,oraz tworzy prawdziwe, możliwe do uruchomienia testy. Oczywiście, trzeba dokończyć każdytest przez dodanie odpowiednich wartości zmiennych i asercji, jednak kod wygenerowanyprzez narzędzia to dobry punkt wyjścia.

Przyjrzyjmy się przykładowi. Załóżmy, że programista używa obiektu Customer zawierającegostandardowe właściwości, takie jak Name, Address, Phone i Email. Może także zawierać innemetody, takie jak Save, Update czy Delete. Środowiska Visual Studio można użyć do wyge-nerowania nowych testów jednostek dla klasy. W tym celu należy albo wybrać opcję Unit TestWizard w oknie dialogowym Add New Test, albo kliknąć prawym przyciskiem myszy plikklasy i wybrać opcję Create Unit Tests.

W obu scenariuszach Visual Studio wyświetli okno dialogowe Create Unit Tests przedstawio-ne na rysunku 9.5. Widoczne są w nim typy dostępne w rozwiązaniu. W powyższym okniedialogowym można wybrać składowe, dla których trzeba wygenerować testy. Można też użyćustawienia Output project do określenia projektu testów, w którym mają znaleźć się wygene-rowane testy. Polega to na utworzeniu nowego projektu testów (w języku C# lub Visual Basic)albo na umieszczeniu kodu w istniejącym projekcie testów.

Rysunek 9.5.Można zezwolić środowiskuVisual Studio nawygenerowanie testówjednostek na podstawieistniejącego kodu

Przycisk Add Assembly w dolnej części okna dialogowego umożliwia wybranie podzespołu(pliku .dll) spoza projektu. Testy można wygenerować dla dowolnego podzespołu .NET.

404


Zarządzanie ustawieniami procesu generowania testów

Przycisk Settings pozwala otworzyć okno dialogowe, które służy do określania różnych ustawieńzwiązanych z generowaniem testów jednostek. Rysunek 9.6 przedstawia przykładowe informa-cje w tym oknie. Warto zauważyć, że można użyć tekstu makr ([File], [Class] i [Method])do poinformowania Visual Studio o tym, jak ma tworzyć nazwy generowanych plików, klas i metodtestów.

Rysunek 9.6.Można kontrolowaćsposób generowaniatestów jednostekprzez Visual Studio

Warto zwrócić uwagę na dodatkowe ustawienia w grupie General. Umożliwiają one ustawieniekażdego generowanego testu jako niejednoznacznego, umieszczenie komentarzy w wygenero-wanym kodzie i tak dalej.

UwagaKreator Create Unit Tests umożliwia wygenerowanie testów jed-nostek dla wszystkich projektów w rozwiązaniu. Zaznaczenie kla-sy i wygenerowanie testów powoduje dodanie w projekcie testówreferencji do projektu z testowanym kodem.

Wygenerowany kod testów

Visual Studio generuje testy dla wszystkich metod i właściwości obiektu zaznaczonych w okniedialogowym Create Unit Tests. Zastanówmy się na przykład nad właściwością Name. Listing9.1 przedstawia kod wygenerowany jako test jednostek tej właściwości (kod w języku VisualBasic wygląda podobnie). Test tworzy nowy obiekt typu Customer, a następnie próbuje usta-wić wartość właściwości Name docelowej zmiennej. Potem określany jest oczekiwany efekt. Tuwłaściwość Name jest typu string, dlatego kod testu tworzy zmienną o nazwie expected tegotypu. Definiuje też zmienną typu string o nazwie actual. Następnie przypisuje do właściwo-ści Customer.Name wartość zmiennej exptected i — po ustawieniu właściwości — wczytujewartość zmiennej actual. Na zakończenie za pomocą asercji Assert.AreEqual sprawdza,

405


czy właściwość została poprawnie ustawiona. Jest to prawidłowy test właściwości. Programi-sta musi jedynie podać poprawną wartość dla zmiennej exptected (punkt TODO) i usunąćwywołanie Assert.Inconclusive.

Listing 9.1. Przykładowy automatycznie wygenerowany test jednostek

[TestMethod()]public void NameTest() { Customer target = new Customer(); // TODO: Initialize to an appropriate value string expected = string.Empty; // TODO: Initialize to an appropriate value string actual; target.Name = expected; actual = target.Name; Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method.");}

Testowanie metod jest trochę bardziej pracochłonne. Jeśli metoda zwraca wartość, trzeba jąsprawdzić, aby się upewnić, że jest zgodna z oczekiwaniami. Jeżeli metoda nie zwraca wartości,trzeba napisać dodatkowy kod do sprawdzenia, czy działa prawidłowo. Na listingu 9.2 pokaza-no automatycznie wygenerowany test metody, która nie zwraca wartości. Oczywiście, jeśliwywołanie metody spowoduje błąd, test zakończy się niepowodzeniem. Można jednak napisaćdodatkowe testy i asercje.

Listing 9.2. Przykładowy automatycznie wygenerowany test jednostki

[TestMethod()]public void SaveTest() { Customer target = new Customer(); // TODO: Initialize to an appropriate value target.Save(); Assert.Inconclusive("A method that does not return a value cannot be �verified.");}

UwagaW czasie generowania kodu do testowania konstruktorów VisualStudio dodaje tekst ConstructorTest do nazwy klasy. Jeśli ist-nieje kilka konstruktorów, Visual Studio doda do nazw liczby, naprzykład CustomerConstructorTest1.

Pisanie testów jednostek

Możliwe, że Czytelnicy zaczynają się domyślać, jak wykorzystać automatycznie wygenerowanetesty jednostek. Przyjrzyjmy się pisaniu testów jednostek, aby lepiej je zrozumieć. Warto pa-miętać, że test jednostek to po prostu kod testu, który ma wywoływać kod aplikacji. W takimkodzie testu znajdują się założenia dotyczące tego, czy określone warunki są spełnione, czy

406


nie po wykonaniu kodu aplikacji. Test może powieść się lub nie w zależności od wyników tychzałożeń. Jeśli programista oczekuje, że warunek będzie spełniony, a tak się nie stanie, wtedy testkończy się niepowodzeniem.

Kiedy projekt i klasa testu są już gotowe, trzeba wykonać trzy operacje, aby utworzyć typowytest jednostki:

1. Dodać atrybut TestMethod do kodu testu. 2. Uruchomić badany kod, przekazując znane wartości w taki sposób, jak parametry. 3. Zastosować asercje do oceny wyników testów.

Przyjrzyjmy się bliżej praktycznemu przykładowi. Załóżmy, że programista korzysta z usługisieciowej zwracającej profil użytkownika z bazy danych. Ta usługa sieciowa przyjmuje jakoparametr identyfikator klienta. Sygnatura funkcji może wyglądać tak:

public Customer GetCustomerProfile(int customerId)

Można napisać prosty test wywołujący tę usługę i przekazujący znany identyfikator z bazy danych.Dobrym sposobem na testy jednostek baz danych jest sprawdzanie znanego stanu bazy. W teściemożna następnie sprawdzić nie tylko to, czy zwracane dane działają, ale także czy są poprawne.Na listingu 9.3 znajduje się przykładowy test.

Listing 9.3. Przykładowy test jednostek

[TestMethod()]public void GetCustomerProfileTest() { CustomerProfile cutProfileService = new CustomerProfile(); int customerId = 1234; Customer customer = cutProfileService.GetCustomerProfile(customerId); Assert.AreEqual(customer.Id, 1234);}

Warto zauważyć, że powyższy kod jest podobny do dowolnego kodu w języku C# (i VisualBasic). Aby oznaczyć metodę jako test, należy dodać atrybut TestMethod. W kodzie trzebautworzyć egzemplarz testowanego obiektu i wywołać sprawdzaną metodę. Jeśli wywołanie sięnie powiedzie (lub zostanie zgłoszony wyjątek), test zakończy się niepowodzeniem. Następniew teście znajduje się asercja, która pozwala sprawdzić, czy zwrócony obiekt odpowiada oczekiwa-nemu. Jeśli ta asercja okaże się fałszywa (przekazane do niej wartości nie są sobie równe), testzakończy się niepowodzeniem. Jeśli asercja będzie prawdziwa, test się powiedzie. Można dodaćkilka innych asercji, aby uzupełnić powyższy test (przez sprawdzenie innych znanych danych natemat klienta). Ponadto można utworzyć pewne dodatkowe testy sprawdzanej metody, naprzykład określające, co się stanie przy próbie pobrania danych nieistniejącego klienta.

Powyższy kod powinien pozwolić zrozumieć podstawy działania testów jednostek. W dalszejczęści rozdziału zajmiemy się nimi nieco bardziej szczegółowo.

407


Uruchamianie testów jednostek

Testy jednostek można uruchamiać w kilku miejscach środowiska Visual Studio. Dwa z nich topasek narzędzi Test Tools i menu Test. Obie możliwości związane są z podobnym zestawemopcji pokazanych na rysunku 9.7. W górnej części rysunku znajduje się pasek narzędzi TestTools. W dolnej części pokazano zestaw przycisków opcji, które można dodać do paska lubusunąć z niego. Lista ta pomaga zrozumieć znaczenie ikon paska narzędzi i poznać klawiszeskrótu służące do uruchamiania testów.

Rysunek 9.7.Menu Test umożliwiauruchamianie testówz debugerem lub bezniego

Testy można uruchamiać z debugerem lub bez. Pierwsza z tych opcji umożliwia włączeniedebugera, jeśli test zakończy się niepowodzeniem. Ta właściwość jest przydatna do używaniatestów do rozwiązywania problemów z kodem. Częściej stosuje się jednak drugie rozwiąza-nie, które pozwala po prostu uruchomić zestaw testów jednostek i sprawdzić wyniki. Testymożna uruchamiać wtedy w bieżącym kontekście lub w kontekście całego rozwiązania. Bieżącykontekst pozwala uruchomić dowolne wybrane teksty, przeprowadzić testy od lokalizacji kur-sora lub włączyć wszystkie testy danej klasy (jeżeli wyświetlany jest kod klasy, a nie testu).Czasem trudno określić, co jest bieżącym kontekstem dla środowiska Visual Studio. Wtedymożna albo uruchomić wszystkie testy z rozwiązania, albo przeprowadzić testy z poziomuokna Test View (zobacz podrozdział „Organizowanie testów”).

Uwaga

Przy uruchamianiu projektu testów wszystkie projekty, do którychdodano referencje, są rekompilowane razem z projektem testów.

Przeglądanie wyników testów

Po uruchomieniu testów wyniki można zobaczyć w oknie Test Results (zwykle zadokowane jestw dolnej części środowiska IDE). Okno umożliwia sprawdzenie, które testy zakończyły siępowodzeniem, a które nie. Rysunek 9.8 przedstawia liczne funkcje dostępne w tym oknie. Warto

408


Rysunek 9.8. Okno Test Results umożliwia wyświetlenie wyników przebiegów testów i ponowne uruchomieniewybranych testów

zwrócić uwagę na to, że dany przebieg testu kończy się niepowodzeniem, jeśli nie powiedzie sięprzynajmniej jeden test. W tym przypadku powiodło się 16 z 18 testów. Jednak niepowodzeniedwóch testów spowodowało, że cały test zakończył się porażką.

Okno Test Results udostępnia pasek narzędzi z wieloma opcjami i kontrolkami. Jedna z opcjiumożliwia wyświetlenie wyników wszystkich testów przeprowadzonych w czasie sesji środowi-ska Visual Studio. Pozwala to na wyświetlenie jednocześnie wyników wszystkich testów. Innaopcja umożliwia łatwe ponowne uruchomienie testów z danego przebiegu. Jeszcze inna służydo eksportowania wyników do pliku i udostępniania danych innym osobom (które mogązaimportować je za pomocą tego samego paska narzędzi). Można też dodać nowe kolumny dowyników testu, aby wyświetlić więcej danych i lepiej je uporządkować (dostępnych jest ponad20 kolumn).

Dwukrotne kliknięcie testu zakończonego powodzeniem powoduje wyświetlenie szczegółowychinformacji na jego temat. Strona ze szczegółami obejmuje nazwę testu, wyniki, czas trwaniatestu, a także godzinę jego rozpoczęcia i zakończenia. Po dwukrotnym kliknięciu testu zakoń-czonego niepowodzeniem programista zobaczy wiersz kodu sprawdzanej klasy, w którymwystąpił błąd. Aby zobaczyć szczegółowe informacje o takim teście, należy kliknąć go na liściewyników prawym przyciskiem myszy i wybrać opcję View Test Results Details. Na rysunku 9.9przedstawiono stronę ze szczegółowymi danymi na temat nieudanego testu. Warto zauważyć,że obejmują one komunikat o błędzie, ślad stosu i odnośnik do kodu, który spowodował błąd.

409


Rysunek 9.9. Można wyświetlić szczegółowe informacje o wynikach dowolnego testu (udanego lub nieudanego)

Wyświetlanie przebiegów testów

Visual Studio udostępnia też okno dialogowe Test Runs, służące do przeglądania przebiegówtestów z bieżącej sesji (i zaimportowanych). Okno można otworzyć za pomocą paska narzędziTest Tools lub z menu Test/Windows/Test Runs. Na rysunku 9.10 pokazano przykładową za-wartość omawianego okna dialogowego. Można dwukrotnie kliknąć dany przebieg, aby wczy-tać szczegółowe informacje o wynikach do okna Test Results.

Konfigurowanie opcji i ustawień testów

Visual Studio umożliwia kontrolowanie i dostosowywanie środowiska testowego. Służy dotego okno dialogowe Options. Ponadto w plikach konfiguracyjnych można kontrolować usta-wienia testów specyficznych dla rozwiązania. W tym punkcie opisujemy, jak stosować obietechniki konfigurowania do lepszego zarządzania środowiskiem testowym.

410


Rysunek 9.10. Okno dialogowe Test Runs umożliwia wyświetlenie wyników wszystkich przebiegów testówz bieżącej sesji środowiska Visual Studio

Opcje projektów testów

Można kontrolować sposób generowania projektów testów przez Visual Studio. Należy tozrobić w węźle Test Tools/Test Project w oknie dialogowym Options (Tools/Options). Na rysunku9.11 pokazano przykładową zawartość tego okna. Można tu określić język domyślny (VisualBasic lub C#) dla projektu testów stosowany przez Visual Studio przy tworzeniu lub genero-waniu nowego projektu tego typu. Warto zauważyć, że można zmienić domyślny język usta-wiony w środowisku IDE dla projektów testów.

Rysunek 9.11.Okno dialogoweOptions umożliwiadostosowaniedomyślnych ustawieńszablonów projektówtestów w Visual Studio

411


Opcje w węźle Test Project pozwalają też określić, które pliki należy domyślnie umieścić w projekcietestów w czasie jego tworzenia. To, jakie opcje są dostępne, zależy od języka. Można określićpliki podstawowych testów jednostek, testów jednostek baz danych, testów uporządkowanychlub testów jednostek (uruchamiany jest wtedy kreator Unit Test Wizard).

Zarządzanie wynikami testów

Visual Studio domyślnie przechowuje wyniki ostatnich 25 przebiegów testów. Po przekrocze-niu tego limitu środowisko przed zapisaniem wyników nowego przebiegu usunie informacjeo najstarszym. W oknie dialogowym Options (Tools/Options) można zwiększyć (lub zmniejszyć) tęwartość. Należy wybrać węzeł podrzędny Test Execution w węźle Test Tools, aby wyświetlićopcje widoczne na rysunku 9.12. Warto zwrócić uwagę na opcję Limit Number of Old TestRuns To (czyli ogranicz liczbę dawnych przebiegów testów do).

Rysunek 9.12.W okniedialogowymOptions możnaokreślić liczbęprzechowywanychprzebiegów testów

Kontrolowanie ustawień testów

Visual Studio udostępnia plik ustawień umożliwiający kontrolowanie wykonywania testów.W większości sytuacji można pozostawić domyślną zawartość pliku ustawień. Jednak nierazwarto zmodyfikować niektóre opcje, dotyczące na przykład uruchamiania skryptów instalacyj-nych w ramach testów, limitu czasu i tak dalej.

Pliki z ustawieniami testów można znaleźć na poziomie rozwiązania w oknie Solution Explorer(zobacz rysunek 9.2). Każdy plik ustawień testów ma rozszerzenie .testsettings. W dowolnym mo-mencie za pomocą opcji Test/Select Active Test Settings można określić, który plik .testsettingsma być aktywny. Na rysunku 9.13 pokazano, jak wybrać aktywny plik ustawień.

Pliki .testsettings w Visual Studio to zwykłe pliki XML z konfiguracją. Kod w języku XMLmożna bezpośrednio edytować. Visual Studio udostępnia jednak okno dialogowe do łatwiej-szego modyfikowania ustawień. Okno dialogowe Test Settings można uruchomić przez dwu-krotne kliknięcie pliku .testsettings. Na rysunku 9.14 pokazano to okno z wybranym węzłemTest Timeouts.

412


Rysunek 9.13. Za pomocą menu Test można wybrać aktywny plik z ustawieniami testów

Rysunek 9.14. Okno dialogowe Test Settings umożliwia zarządzanie ustawieniami związanymi z przeprowadzaniemtestów (w tym limitem czasu)

413


Zaznaczenie węzła po lewej stronie okna dialogowego Test Settings pozwala skonfigurowaćróżne ustawienia. Poniżej znajduje się przegląd opcji, którymi można zarządzać w każdymwęźle okna Test Settings:

� General. Zawiera opcje do określania nazwy pliku ustawień, udostępniania opisu, ge-nerowania nazw dla poszczególnych przebiegów testów (na rysunku 9.10 pokazanonazwy takich przebiegów).

� Deployment. Umożliwia określenie dodatkowych plików i katalogów instalowanychw ramach przeprowadzania testów. Domyślnie testowane podzespoły są automatycz-nie instalowane w katalogu bin testu. Pozwala to przed przeprowadzeniem testówzainstalować nowe elementy (na przykład bazy danych oparte na plikach).

� Setup and Cleanup Scripts. Umożliwia określenie skryptu uruchamianego przeduruchomieniem testów lub po ich zakończeniu (albo w obu sytuacjach). Różni się tood uruchamiania kodu przed testami klas. Tu można zdefiniować kod wykonywanyprzed dowolną grupą testów (lub po niej).

� Hosts. Umożliwia określenie hosta, na którym można przeprowadzić testy. Zwyklejest to host domyślny (środowisko Visual Studio). Ponadto można ustawić testy tak,aby działały na serwerze środowiska ASP.NET.

� Test Timeouts. Umożliwia określenie czasu oczekiwania środowiska Visual Studio(lub innego hosta) przed porzuceniem długo działających testów. Ponadto możnaoznaczyć zbyt długo trwające testy jako nieudane. Na rysunku 9.12 przedstawionoprzykładowe ustawienia w tym oknie dialogowym.

� Unit Test. Udostępnia zaawansowane opcje wczytywania dodatkowych podzespołówpotrzebnych do przeprowadzenia testów.

Platforma testów jednostekPlatforma testów jednostek to część środowiska Visual Studio, a nie platformy .NET. Systemtestowania jednostek w Visual Studio obejmuje: zestaw klas platformy, narzędzia i host, gdziewykonywane są testy. Przestrzeń nazw zawierająca klasy platformy testów jednostek to Microsoft.�VisualStudio.TestTools.UnitTesting. Dla programistów najważniejsze w tej prze-strzeni nazw są klasy atrybutów i klasa Assert. W tym podrozdziale omawiamy podstawowescenariusze korzystania z klas atrybutów i asercji (a także innych klas).

Klasa TestContext

Platforma testów jednostek obejmuje klasę służącą do przechowywania informacji związanychz wykonywaniem testów. Jest to klasa TestContext. Właściwości tej klasy służą do pobieraniadanych o działających testach. Informacje obejmują: ścieżkę do katalogu z testem, adres URLuruchamianego testu (jeśli są to testy jednostek ASP.NET) i informacje o wiązaniu danych (na

414


przykład połączenie z danymi lub obecny wiersz danych w wykonywanym teście). Wiadomo-ści na temat kontekstu testu są przechowywane we właściwościach omawianej klasy. Kluczowewłaściwości i ich zastosowania opisano w tabeli 9.1.

Tabela 9.1. Kluczowe właściwości klasy TestContext

Właściwość Opis

CurrentTestOutcome Umożliwia określenie wyniku ostatniego przeprowadzonego testu. Jest to przydatne

w metodach oznaczonych jako TestCleanup (zobacz punkt „Klasy atrybutów testów”).

DataConnection Umożliwia wyświetlenie łańcucha połączenia używanego w testach jednostek sterowanych

danymi (zobacz punkt „Tworzenie testów jednostek zależnych od danych”).

DataRow Umożliwia dostęp do kolumn w wierszu z danymi w czasie pracy z testami jednostek

zależnych od danych (zobacz punkt „Tworzenie testów jednostek zależnych od danych”).

RequestedPage Zapewnia dostęp do obiektu Page reprezentującego żądaną stronę w testach jednostek

ASP.NET (zobacz podrozdział „Pisanie testów jednostek działających w ASP.NET”).

TestDeploymentDir Umożliwia wyświetlenie ścieżki do katalogu, w którym testy są instalowane i uruchamiane.

Jest to przydatne, jeśli trzeba zapisywać lub wczytywać dane z pliku z tego katalogu.

TestLogsDir Umożliwia wyświetlenie ścieżki do katalogu, w którym zapisywane są wyniki testów.

TestName Umożliwia określenie nazwy obecnie przeprowadzanego testu.

Klasa TestContext domyślnie jest niedostępna w kodzie. Aby uzyskać do niej dostęp, naj-pierw trzeba zdefiniować właściwość o tej samej nazwie i typie w klasie testu (potrzebna wła-ściwość jest automatycznie tworzona w czasie generowania testów jednostek na podstawieistniejącego kodu). Platforma testów jednostek w momencie uruchamiania testów automatycz-nie tworzy egzemplarz klasy TestContext, a następnie sprawdza, czy w kodzie źródłowym znaj-duje się właściwość o tej nazwie. Jeśli ją znajdzie, przypisuje egzemplarz klasy TestContext dowłaściwości. Od tego momentu można korzystać z właściwości do pobierania informacji o kon-tekście przeprowadzanego testu. Poniższy kod pokazuje, jak zdefiniować właściwość TestContextw teście jednostek w języku C#:

public TestContext TestContext { get; set; }

Środowisko Visual Studio w czasie tworzenia obiektu typu TestContext generuje kompletnąwłaściwość. Poniżej pokazano kod właściwości wygenerowany przez Visual Studio:

private TestContext testContextInstance;

public TestContext TestContext { get { return testContextInstance; } set { testContextInstance = value; }}

415


UwagaNiektóre klasy atrybutów wymagają zdefiniowania parametru typuTestContext dla metod opatrzonych danym atrybutem. Dotyczyto na przykład atrybutu ClassInitialize (zobacz dalej). W takimscenariuszu platforma testów jednostek automatycznie przekazujeegzemplarz klasy TestContext do metody w momencie jej uru-chamiania.

Klasy atrybutów testów

Testy jednostek są uruchamiane przez Visual Studio za pomocą hosta do przeprowadzaniatestów jednostek. Host musi zbadać kod, znaleźć w nim testy jednostek i uruchomić je w od-powiedni sposób. Wykorzystuje do tego atrybuty. Przypomnijmy, że atrybuty służą do udo-stępniania metadanych na temat kodu. Inny kod (na przykład host testów jednostek) może wyko-rzystać mechanizm refleksji do określenia różnych informacji na temat uruchamianego kodu.

W dotychczasowych krótkich przykładach pokazaliśmy, że testy jednostek oznaczane są zapomocą klas atrybutów zdefiniowanych w przestrzeni nazw testów. Przykładowo, klasa testuma atrybut TestClass, a metodę testową należy oznaczyć atrybutem TestMethod. W tabeli9.2 pokazano listę najczęściej stosowanych klas atrybutów z przestrzeni nazw testów jednostek.

Tabela 9.2. Klasy atrybutów testów dostępne w Visual Studio

Test Opis

AssemblyCleanup Służy do definiowania metod, które należy uruchomić po wykonaniu przez platformę

wszystkich testów z danego podzespołu. Jest to przydatne, jeśli trzeba uporządkować

zasoby po wykonaniu wszystkich testów.

Warto zauważyć, że taki atrybut można przypisać tylko do jednej metody w podzespole.

AssemblyInitialize Służy do definiowania metod, które należy uruchomić przed uruchomieniem przez

platformę testów z danego podzespołu. Jest to przydatne, jeśli trzeba zainicjować

zasoby dla wszystkich testów z podzespołu.

Warto zauważyć, że taki atrybut można przypisać tylko do jednej metody w podzespole.

ClassCleanup Służy do określania metody, którą należy uruchomić jeden raz po wykonaniu wszystkichtestów z danej klasy testów. Jest to przydatne, jeśli trzeba zresetować stan systemu

(na przykład w bazie danych) po zakończeniu testów.

ClassInitialize Służy do określania metody, którą host powinien uruchomić jeden raz przed uruchomieniem

testów z danej klasy testów. Jest to przydatne, jeśli trzeba zresetować bazę danych lub

wykonać kod przygotowujący środowisko testowe.

Metoda musi przyjmować parametr typu TestContext.

DataSource Służy do udostępniania informacji o połączeniu w testach jednostek zależnych od danych

(„Tworzenie testów jednostek zależnych od danych”).

416


Tabela 9.2. Klasy atrybutów testów dostępne w Visual Studio — ciąg dalszy

Test Opis

DeploymentItem Służy do określania dodatkowych plików (.dll, .txt i innych), które trzeba zainstalować

w katalogu, gdzie przeprowadzane są testy.

ExpectedException Służy do określania, że zgodnie z oczekiwaniami kod metody testowej powinien zgłosić

wyjątek podanego typu. Działanie metod testowych tego rodzaju jest uważane za

prawidłowe, jeśli w czasie wykonywania testu pojawi się wyjątek odpowiedniego typu

(w przeciwnym razie test kończy się niepowodzeniem). Mechanizm ten jest przydatny

do testowania oczekiwanych warunków wystąpienia błędów w kodzie (zobacz punkt

„Testowanie wyjątków”).

HostType Używany do zastępowania domyślnego hosta testów (środowiska Visual Studio). Zwykle

nie trzeba stosować tego atrybutu. Jeśli jednak programista pisze testy uruchamiane

w procesie innego hosta (na przykład w środowisku ASP.NET), może wykorzystać ten

atrybut (wraz z atrybutami UrlToTest i AspNetDevelopmentServerHost).

Ignore Dodawany do metody testowej w celu określenia, że daną metodę należy pominąć,

jeśli stosowany jest host do przeprowadzania testów.

TestClass Służy do określania, że dana klasa jest klasą testów zawierającą jeden lub kilka testów

jednostek (metod testowych).

TestCleanup Służy do wskazywania metody, którą należy uruchomić jednokrotnie po wykonaniu

każdej metody testowej. Wskazaną metodę można wykorzystać do uruchomienia

operacji porządkujących po wykonaniu każdej metody testowej w danej klasie testów.

Porządkowanie na poziomie klasy można przeprowadzić za pomocą atrybutu

ClassCleanup.

TestInitialize Służy do określania, że daną metodę należy uruchomić jednokrotnie przed wykonaniem

każdej metody testowej. Jest to przydatne, jeśli trzeba zresetować stan systemu przed

wykonaniem każdej metody testowej w danej klasie testów. Jeśli programista chce tylko

zainicjować stan dla wszystkich metod z danej klasy testów, powinien użyć atrybutu

ClassInitialize.

TestProperty Służy do definiowania właściwości (pary nazwa – wartość) metody testowej. Informacje

zapisane we właściwości można wczytać w kodzie metody testowej.

TestMethod Służy do oznaczania metod w klasie testów jako testów jednostek. Metody testowe nie

mogą zwracać wartości (zwracają typ void). Powodzenie lub niepowodzenie zależy od

warunków błędów oraz asercji. Metody testowe nie mogą przyjmować parametrów,

ponieważ host nie potrafi przekazywać parametrów do metod. Istnieją jednak sposoby

na zasymulowanie przekazywania parametrów. Więcej informacji na ten temat zawiera

punkt „Tworzenie testów jednostek zależnych od danych”.

Timeout Służy do określania limitu czasu (w milisekundach) dla danej metody testowej. Jeśli test

będzie trwał dłużej, środowisko zatrzyma go i uzna za zakończony niepowodzeniem.

417


W tabeli 9.2 pokazano, że istnieje wiele klas atrybutów. Zapewniają one kontrolę nad testamijednostek. Jeśli programista pisze klasę testów dla obiektu Customer, może zdefiniować klasęCustomerTest. Na listingu 9.4 pokazano szkielet kilku testów z tej klasy. Zademonstrowanoteż liczne atrybuty stosowane w typowych klasach testów. Warto zwrócić uwagę na metody doinicjowania klasy testów i porządkowania zasobów po przeprowadzeniu testu.

Listing 9.4. Przykładowa klasa testów

using System;using BusinessDomain;using Microsoft.VisualStudio.TestTools.UnitTesting;using System.Data;using System.Collections.Generic;

namespace BusinessDomainUnitTests {

[TestClass()] public class CustomerTest {

public TestContext TestContext { get; set; }

[ClassInitialize()] public static void InitTests(TestContext testContext) { // Wywo�anie kodu resetuj�cego testow� baz� danych (Utilities.ResetTestDb();).

}

[ClassCleanup()] public static void CleanupPostTests() { // Wywo�anie kodu resetuj�cego testow� baz� danych (Utilities.ResetTestDb();).

}

[TestMethod()] public void CustomerConstructorTest() { // Testuje konstruktor domy�lny.

}

[TestMethod()] public void CustomerConstructorTest1() { // Testuje konstruktor przyjmuj�cy identyfikator klienta.

}

[TestMethod()] [DeploymentItem("BusinessDomain.dll")] public void DeleteTest() {

}

[TestMethod()] [DeploymentItem("BusinessDomain.dll")]

418


public void GetListTest() {

}

[TestMethod()] [DeploymentItem("BusinessDomain.dll")] [Timeout(5000)]

public void SaveTest() {

}

}

}

Następny krok polega na napisaniu kodu w każdej metodzie testowej. Kod powinien kierowaćwywołania do obiektu Customer i sprawdzać asercje związane z wynikami wywołań. Do two-rzenia asercji służy opisana dalej klasa Assert.

Operacje wykonywane przed testami jednostek i po nich

Dobrą praktyką przy tworzeniu testów jednostek jest pisanie ich dla znanego stanu systemu.Dotyczy to bazy danych, plików i innych elementów składających się na system. W ten sposóbprogramista może mieć pewność, że potrzebne elementy będą dostępne przy przeprowadzaniutestów. Oczywiście, same testy często naruszają stan. Testy usuwają dane, modyfikują je, do-dają nowe rekordy i wykonują podobne operacje. Wtedy potrzebna jest możliwość przywróce-nia stanu systemu przed wykonaniem testów (i [lub] po ich zakończeniu), aby zagwarantowaćstały stan na czas testów i umożliwić programistom uruchamianie ich za pomocą jednegokliknięcia (jest to następna dobra praktyka z obszaru testów jednostek).

Zwykle trzeba napisać kod utrzymujący stały stan systemu. Kod może kopiować znaną i po-prawną testową bazę danych do katalogu testów (można wykorzystać do tego także atrybutDeploymentItem), resetować bazę danych za pomocą instrukcji w SQL-u, realizować plangenerowania danych w celu utworzenia bazy, kopiować pliki lub sprawdzać inne instalowaneelementy.

Kod resetujący system jest specyficzny dla środowiska. Jednak aby zagwarantować wywołaniepotrzebnego kodu w czasie przeprowadzania testów, można zastosować kilka klas atrybutów:ClassInitialize i ClassCleanup lub TestInitialize i TestCleanup. Pierwsza parapowoduje wykonanie kodu na początku (i na końcu) przebiegu testów dla całej klasy testówjednostek. Druga para pozwala uruchomić kod przed wykonaniem każdego testu w danejklasie testów i po ich przeprowadzeniu.

Zwykle operacje inicjujące i porządkujące wywoływane są na poziomie klasy. Jeśli programistaużywa klasy Utilities z metodą resetującą bazę danych, może zagwarantować wywołaniemetody, oznaczając ją atrybutem ClassInitialize. Warto zauważyć, że metoda przyjmuje

419


obiekt TestContext przekazywany przez platformę testów jednostek. Dobrą praktyką jestponowne resetowanie systemu po wykonaniu testów jednostek. W poniższym kodzie pokazanodwie metody testów. Metody przygotowują testy i porządkują po nich.

[ClassInitialize()]public static void InitTests(TestContext testContext) { Utilities.ResetTestDb();}

[ClassCleanup()]public static void CleanupPostTests() { Utilities.ResetTestDb();}

Kontrolowanie operacji inicjujących

i porządkujących na poziomie wykonywania testów

Zdarza się, że operacje inicjujące i porządkujące trzeba uruchomić na poziomie wyższym niżklasa testów. Czasem przed uruchomieniem klas testów trzeba wywołać skrypty. Wtedy możnawykorzystać plik .testsettings (zobacz wcześniejszy punkt „Kontrolowanie ustawień testów”) dozdefiniowania skryptu wywoływanego przed uruchomieniem testów i po ich zakończeniu.

Na rysunku 9.15 pokazano węzeł Setup and Cleanup Scripts w oknie dialogowym Test Settings.W tym miejscu można zdefiniować skrypty inicjujące i porządkujące wywoływane przy uru-chamianiu dowolnych testów z rozwiązania.

Rysunek 9.15.Definiowanieskryptówinicjującychi porządkującychwywoływanychprzy wykonywaniudowolnych testówz rozwiązania

420


Klasy asercji

Przestrzeń nazw UnitTesting zawiera także typ statyczny Assert. Ten typ udostępnia licznemetody umożliwiające sprawdzenie, czy wynik testów jest zgodny z oczekiwaniami. Należywywołać statyczne metody i sprawdzić wartość warunku (true lub false). Jeśli waruneklogiczny nie jest spełniony, działanie asercji kończy się niepowodzeniem. Same asercje niezwracają wyników. Zamiast tego w czasie wykonywania programu automatycznie powiada-miają platformę testów jednostek o sukcesie lub niepowodzeniu.

Można na przykład napisać test jednostki wczytujący znany rekord z bazy danych. Następniemożna dodać asercję dotyczącą tego rekordu, aby udowodnić, że program potrafi pobrać danez bazy, prawidłowo wywołać odpowiednie zbiory danych i dotrzeć do konkretnego obiektu.Poniżej pokazano prostą asercję do sprawdzania, czy dwie zmienne mają tę samą wartość. Jeśliwartości są sobie równe (AreEqual), działanie asercji kończy się powodzeniem. Jeżeli wartości sąróżne, asercja zgłasza niepowodzenie, a platforma testów jednostek oznacza test jako nieudany.

Assert.AreEqual(cust.Id, customerId);

AreEqual to tylko jedna z wielu metod asercji dostępnych w klasie Assert. Większość metodasercji dotyczy jednego zagadnienia — porównywania dwóch wartości. W tabeli 9.3 przedsta-wiono bardziej kompletną listę metod.

Tabela 9.3. Asercje testów

Test Opis

AreEqual i AreNotEqual Służy do sprawdzania, czy dwie wartości są sobie równe, czy nie.

AreSame i AreNotSame Pozwala sprawdzić, czy dwa obiekty są tym samym obiektem, czy nie.

Fail Metoda Assert.Fail oznacza warunek jako niespełniony bez jego sprawdzania.Może to być przydatne przy wartościowaniu warunku za pomocą operacji logicznychi dojściu do miejsca w kodzie, gdzie operacje reprezentują test zakończonyniepowodzeniem.

Inconclusive Służy do oznaczania, że test nie zakończył się ani niepowodzeniem, ani powodzeniem(wynik jest niejednoznaczny).

IsInstanceOfTypei IsNotInstanceOfType

Pozwala sprawdzić, czy obiekt jest określonego typu, czy nie.

IsNull i IsNotNull Pozwala określić, czy obiekt zawiera referencję null, czy nie.

IsTrue i IsFalse Służy do sprawdzania, czy warunek jest spełniony, czy nie.

Każda metoda asercji ma kilka przeciążonych wersji. Umożliwiają one porównywanie różnychtypów danych — łańcuchów znaków, liczb, obiektów i kolekcji ogólnych. Ponadto dostępne sąwersje, które pozwalają po prostu zastosować asercję lub dodatkowo wyświetlić komunikat w sytu-acji, kiedy asercja nie jest spełniona. Na przykład poniżej zapisano tę samą asercję, co wcześniej,jednak ta wersja wyświetla komunikat o błędzie, jeśli warunek nie jest spełniony.

Assert.AreEqual(cust.Id, customerId, "Identyfikatory klienta s� ró�ne.");

421


Przyjrzyjmy się kilku przykładowym metodom, których szkielet pokazano na wcześniejszymlistingu (zobacz listing 9.4). Należy uzupełnić te metody przez napisanie kodu korzystającegoz klasy Customer, a następnie poczynić asercje na temat wyników. Listing 9.5 zawiera przykła-dowy test konstruktora klasy Customer. Warto zauważyć, że testujemy znany rekord danychprzez wczytanie egzemplarza klasy Customer na podstawie identyfikatora rekordu. Następniesprawdzamy wyniki w klasie Assert.

Listing 9.5. Przykładowy test jednostek ilustrujący korzystanie z klasy Assert

[TestMethod()]public void CustomerConstructorTest1() {

// Testuje konstruktor przyjmuj�cy identyfikator klienta.

int customerId = 1; // Testowanie danych klienta. Customer cust = new Customer(customerId);

// Sprawdzanie, czy dla testowego klienta zwrócono poprawne dane. // Sprawdzanie operacji ustawiania i wczytywania warto�ci w�a�ciwo�ci. Assert.AreEqual(cust.Id, customerId, "Identyfikatory klienta s� ró�ne.");

Assert.AreEqual(cust.Email, "[email protected]"); Assert.AreEqual(cust.Name, "Jan Programista"); Assert.AreEqual(cust.City, "Brzeg"); Assert.AreEqual(cust.PostalCode, "00000"); Assert.AreEqual(cust.RegionState, "DL"); Assert.AreEqual(cust.Address1, "ul. Microsoftu 100"); Assert.IsTrue(cust.Address2 == ""); Assert.IsTrue(cust.Phone == "");}

Klasa Assert zawiera też wersje metod AreEqual i AreNotEqual dla ogólnych typów danych.Wersje te umożliwiają sprawdzanie, czy dwa typy ogólne są takie same. Programista musiokreślić typ ogólny za pomocą standardowej składni, <T> [lub (of T) w języku Visual Basic],i przekazać dwie porównywane zmienne. Poniżej pokazano przykładowy kod:

Assert.AreEqual<Customer>(cust1, cust2);

Sprawdzanie kolekcji obiektów

Przestrzeń nazw UnitTesting obejmuje też klasę asercji CollectionAssert. Przy jej użyciumożna sprawdzić zawartość klas kolekcji. Można na przykład wywołać metodę Contains, abyustalić, czy dana kolekcja zawiera konkretny element (lub go nie zawiera). Metoda AllItems�AreInstancesOfType służy do sprawdzania, czy kolekcja zawiera egzemplarze tego samegotypu. Można też sprawdzić, czy dwie kolekcje są takie same (AreEqual i AreNotEqual) lubczy zawierają identyczne elementy, ale niekoniecznie w tej samej kolejności (AreEquivalenti AreNotEquivalent).

422


Sprawdzanie łańcuchów znaków

Klasa StringAssert zawiera metody służące do sprawdzania łańcuchów znaków i ich frag-mentów. Metoda Contains pozwala ustalić, czy łańcuch obejmuje określony podłańcuch.Metoda StartsWith umożliwia określenie, czy łańcuch rozpoczyna się od podanych znaków,a metoda EndsWith sprawdza końcową część łańcucha. Metody Matches i DoesNotMatch umoż-liwiają ustalenie, czy łańcuch znaków pasuje do zdefiniowanego wyrażenia.

Testowanie wyjątków

Testy jednostek należy pisać w taki sposób, aby ustalić, czy kod działa w oczekiwany sposóbzarówno w korzystnych, jak i niekorzystnych warunkach. Korzystne warunki można spraw-dzić w opisany wcześniej sposób za pomocą metod klasy Assert. Jednak często trzeba okre-ślić, czy kod zgłasza odpowiedni wyjątek w odpowiedzi na specyficzne wywołanie. Można wtedyzastosować atrybut ExpectedException do przetestowania określonych warunków wystąpieniabłędów.

Atrybut ExpectedException należy dodać do metody testowej. Atrybut przyjmuje jako pa-rametr typ oczekiwanego wyjątku. Jeśli wywołanie metody testowej spowoduje zgłoszeniewyjątku odpowiedniego typu, test zakończy się powodzeniem. Jeżeli wyjątek nie wystąpi lubbędzie miał niewłaściwy typ, test zakończy się niepowodzeniem.

Załóżmy, że programista chce sprawdzić, co stanie się przy próbie utworzenia nowego klientaprzy użyciu niepełnych danych. Może w tym celu napisać kod zgłaszający niestandardowywyjątek typu InvalidCustomerException i dodać do metody testowej następujący atrybut:

[TestMethod()][ExpectedException(typeof(InvalidCustomerException), "Nie zg�oszono wyj�tku InvalidCustomerException.")]public void NewCustomerTest() {

// Tworzenie nieprawid�owego nowego egzemplarza klasy Customer.}

Warto zauważyć, że jeśli powyższy kod nie zgłosi wyjątku, jako wynik testu przekazany zostaniekomunikat o błędzie ("Nie zg�oszono wyj�tku InvalidCustomerException."). Komu-nikat to opcjonalny parametr atrybutu ExpectedException.

Można łączyć asercje z atrybutem ExpectedException. Aby metoda testowa w takich warun-kach przeszła test, asercje muszą być spełnione, a metoda musi zgłosić wyjątek.

Uwaga

Zgłoszony wyjątek musi mieć dokładnie taki sam typ, jak oczeki-wany. Wyjątek nie może na przykład dziedziczyć po oczekiwa-nym. Wtedy test zakończy się niepowodzeniem.

423


Tworzenie testów jednostek zależnych od danych

Często lepiej jest napisać jeden test jednostek i uruchomić go wielokrotnie dla różnych warto-ści parametrów, niż przygotowywać wiele podobnych testów. Cechą dobrych testów jednostekjest pokrycie różnych warunków. Oczywiście, testy jednostek nie przyjmują parametrów.Utrudnia to przekazywanie danych do testów. Dlatego trzeba powiązać testy jednostek z danymi.Następnie można nakazać platformie testów jednostek uruchomienie testu dla każdego wierszadanych. Można też wykorzystać powiązane dane testowe w samym teście jednostek i wywołaćkod na wiele sposobów.

Łączenie się z danymi

Do wiązania testów jednostek z danymi testowymi służy klasa atrybutu DataSource z plat-formy testów jednostek. Klasa umożliwia bezpośrednie podanie łańcucha połączenia z danymitestowymi lub określenie nazwy łańcucha połączenia zapisanego w pliku konfiguracji projektu.Obie techniki pozwalają nawiązać połączenie z bazą danych (na przykład SQL Server lub Access),plikiem .csv (zwykle tworzonym w Notatniku lub Excelu) lub plikiem .xml.

Klasa atrybutu DataSource ma trzy wersje. Pierwsza przyjmuje jeden parametr, dataSource�SettingName. Wymaga to przekazania nazwy ustawień źródła danych zdefiniowanychw pliku konfiguracji. Druga wersja przyjmuje parametry connectionString i tableName.Należy wtedy przekazać poprawny łańcuch połączenia ze źródłem danych i określić nazwętabeli, którą system ma powiązać z testem jednostek. Ostatnia wersja przyjmuje parametryproviderInvariantName, connectionString, tableName i dataAccessMethod. Pierwszysłuży do określania typu dostawcy, na przykład dostawcy plików CSV, bazy SQL Server i takdalej. Drugi, łańcuch połączenia, zależy od wybranego dostawcy i określa sposób dostępu dodanych. Trzeci parametr to nazwa tabeli (lub pliku) z danymi. Czwarty, metoda dostępu dodanych, określa sposób powiązania danych z testem jednostek — sekwencyjny lub swobodny.

Załóżmy, że programista pisze test jednostek do sprawdzenia informacji o zamówieniach i koncieklienta. Może wczytać dane klienta, pobrać złożone zamówienia, określić przyznany kredyti sprawdzić obecny stan rachunku. Wszystkie te operacje dla danego klienta można wykonaćw jednym teście jednostek. Test można powiązać z wierszami danych testowych klienta, abysprawdzić poprawność kodu w różnych scenariuszach. Przyjmijmy, że dane testowe znajdują sięw pliku .csv w aplikacji testowej. Wtedy atrybut DataSource można dodać do metody testowejw następujący sposób:

[TestMethod(),DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\OrderTestData.csv", "OrderTestData#csv", DataAccessMethod.Sequential),DeploymentItem("BusinessDomainUnitTests\\OrderTestData.csv")]public void VerifyCustomerOrders() {

// Kod sprawdzaj�cy informacje o zamówieniach i koncie klienta.

}

424


Warto zauważyć, że w przykładowym kodzie pierwszy parametr atrybutu DataSource określadostawcę plików .csv. Następny parametr to łańcuch połączenia z plikiem danych. Trzeciparametr (OrderTestData#csv) informuje, że nazwa tabeli nie istnieje (użyto nazwy pliku).Ostatni parametr, wartość wyliczeniowa DataAccessMethod.Sequential, określa, że każdywiersz należy powiązać z testem jednostek w sposób sekwencyjny. Zwróćmy też uwagę na to,że dodano atrybut DeploymentItem, aby zagwarantować, że plik z danymi testowymi zostaniezainstalowany wraz z testem jednostek.

Nawiązywanie połączenia przy użyciu pliku konfiguracyjnego

W innym scenariuszu można przechowywać informacje o połączeniu w pliku konfiguracyjnym.Jest to przydatne, jeśli programista nie chce na trwałe zapisywać informacji w kodzie testówjednostek. Możliwe, że ta sama testowa baza danych jest wykorzystywana w wielu testach. W śro-dowisku programistycznym i testowym połączenie z bazą może wyglądać inaczej. Wtedy umiesz-czenie informacji o połączeniu w pliku konfiguracyjnym ułatwia zarządzanie nimi.

Pierwszy krok w tym podejściu polega na utworzeniu pliku konfiguracyjnego. W tym celuwystarczy dodać plik app.config do projektu testów jednostek (należy kliknąć plik projektuprawym przyciskiem myszy i wybrać opcję Add/New Item). Jedyna trudność to prawidłoweokreślenie formatu pliku konfiguracyjnego. Trzeba dodać sekcję konfiguracyjną specyficznądla narzędzi testowych środowiska Visual Studio. Warto zauważyć, że w sekcji należy wskazaćwersję 10. platformy testów jednostek. Oto przykładowy kod:

<configSections> <section name="microsoft.visualstudio.testtools"

type="Microsoft.VisualStudio.TestTools.UnitTesting.TestConfigurationSection,Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0,�Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /></configSections>

Następnie należy dodać sekcję z łańcuchem połączenia. Trzeba określić nazwę łańcucha i po-dać informacje o połączeniu oraz dostawcy danych. Tekst łańcucha zależy oczywiście od do-stawcy i rodzaju danych. Dla danych przechowywanych w plikach .xlsx, .csv i .xml oraz bazachAccess, Oracle i SQL potrzebne są specyficzne elementy w łańcuchu połączenia. W poniższymprzykładzie wykorzystano dostawcę OleDb do utworzenia łańcucha połączenia dla pliku .csv:

<connectionStrings> <add name="OrderTestDataCnn" connectionString="Provider=Microsoft.Jet.OLEDB.4.0; Data Source=|DataDirectory|TestData\; Extended Properties='text;HDR=Yes;FMT=Delimited'" providerName="System.Data.OleDb" /></connectionStrings>

Ostatni krok polega na utworzeniu sekcji źródła danych zagnieżdżonej w sekcji narzędzi testowych.Należy określić nazwę testowego źródła danych i wskazać łańcuch połączenia. Ponadto możnapodać metodę dostępu do danych (dostęp sekwencyjny lub swobodny) i nazwę tabeli (jeśli jestpotrzebna). Ostatecznie plik konfiguracyjny powinien wyglądać tak jak na listingu 9.6.

425


Listing 9.6. Przykładowy plik konfiguracyjny testu jednostek

<?xml version="1.0" encoding="utf-8" ?><configuration> <configSections> <section name="microsoft.visualstudio.testtools"

type="Microsoft.VisualStudio.TestTools.UnitTesting.TestConfigurationSection,Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0,�Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> </configSections> <connectionStrings> <add name="OrderTestDataCnn" connectionString="Provider=Microsoft.Jet.OLEDB.4.0; Data Source=|DataDirectory|TestData\; Extended Properties='text;HDR=Yes;FMT=Delimited'" providerName="System.Data.OleDb" /> </connectionStrings> <microsoft.visualstudio.testtools> <dataSources> <add name="OrderTestDataSource" connectionString="OrderTestDataCnn" dataTableName="OrderTestData#csv" dataAccessMethod="Sequential"/> </dataSources> </microsoft.visualstudio.testtools>

</configuration>

UwagaWarto zauważyć, że w jednym pliku konfiguracyjnym możnazdefiniować wiele łańcuchów połączeń (każdy z nich musi miećinną nazwę).

Następnie można wykorzystać skonfigurowane testowe źródło danych w metodzie testowej. W tymcelu wystarczy podać nazwę źródła danych w atrybucie DataSource metody testowej. Prowadzi todo zwiększenia przejrzystości kodu, ułatwia wielokrotne wykorzystanie łańcuchów połączeńi umożliwia centralne zarządzanie połączeniem, jeśli jest ono inne na poszczególnych komputerach.Poniżej pokazano, jak wykorzystać źródło danych:

[TestMethod(),DataSource("OrderTestDataSource"]public void VerifyCustomerOrders() {

// Kod sprawdzaj�cy informacje o zamówieniach i koncie klienta.

}

Warto zauważyć, że w tym przykładzie dane testowe znajdują się w pliku .csv o nazwie Order-TestData.csv. Plik dodano do katalogu TestData w projekcie testów. Katalog i plik są następnieprzenoszone do katalogu bin, w którym środowisko uruchamia testy. Dzieje się tak, ponieważ

426


łańcuch połączenia obejmuje fragment |DataDirectory|TestData\. Można też bezpośred-nio wymusić instalowanie plików, dodając atrybut DeploymentItem do metody testowej.

WskazówkaŁańcuchy połączeń dla testów jednostek można skonfigurować zapomocą okna dialogowego Properties. Zobacz na przykład punkt„Konfigurowanie atrybutów testów jednostek” w dalszej częścirozdziału.

Stosowanie danych testowych w asercjach

Dostęp do danych testowych powiązanych z metodami testowymi można uzyskać za pomocąobiektu kontekstu testu. Przypomnijmy, że jeśli programista ustawi właściwość typu TestContext(zobacz punkt „Klasa TestContext”), obiekt kontekstu zostanie udostępniony przez platformę.Metoda DataRow klasy TestContext pozwala pobrać wiersz powiązany z wykonywanymtestem. Do metody można przekazać nazwę pola lub indeks, aby pobrać dane z odpowiedniejkolumny. Zwykle należy ustawić zmienne dla wszystkich pól danych testowych. Następniemożna wykorzystać zmienne w asercjach w testach jednostek.

Na listingu 9.7 pokazano przykład zastosowania danych testowych (układ danych testowychprzedstawiono na rysunku 9.18 w dalszej części rozdziału). Warto zauważyć, że każdą kolumnętrzeba zrzutować lub przekształcić na odpowiedni typ danych. Następnie można napisać wła-ściwe asercje.

Listing 9.7. Przykładowy test jednostek, w którym wykorzystano powiązane dane

[TestMethod(),DataSource("OrderTestDataSource")]public void VerifyCustomerOrders() {

// Pobieranie warto�ci z wierszy danych. string email = (string)TestContext.DataRow["email"]; int numOrders = (int)TestContext.DataRow["num_orders_todate"]; double creditLimit = Convert.ToDouble(TestContext.DataRow["credit_limit"]); double accountBalance = �Convert.ToDouble(TestContext.DataRow["account_balance"]);

// Tworzenie obiektu Customer na podstawie adresu e-mail. Customer cust = new Customer(email);

// Sprawdzanie informacji o zamówieniach i koncie klienta. Assert.IsTrue(cust.OrderHistory.Count == numOrders, "Liczba zamówie� jest nieprawid�owa."); Assert.IsTrue(cust.Account.Balance == accountBalance, "Stan rachunku jest nieprawid�owy."); Assert.IsTrue(cust.Account.CreditLimit == creditLimit, "Limit debetu jest nieprawid�owy.");

427


Assert.IsTrue(cust.Account.CreditLimit > cust.Account.Balance, "Limit debetu musi by� mniejszy ni� stan rachunku.");

}

Uruchamianie testów zależnych od danych i wyświetlanie ich wyników

Testy jednostek zależne od danych można uruchamiać w taki sam sposób jak inne testy jedno-stek. Główna różnica polega na tym, że cały test jednostek kończy się niepowodzeniem, jeślitest zakończy się w ten sposób dla choćby jednego wiersza danych. Można dwukrotnie kliknąćwynik nieudanego testu, aby wyświetlić szczegółowe informacje na jego temat. Wyniki testówzależnych od danych pojawiają się w odrębnym okienku pod standardowymi wynikami testujednostek. Przykładowe dane pokazano na rysunku 9.16.

Rysunek 9.16. Wyniki testów jednostek zależnych od danych wyświetlane są pod standardowymi wynikami całegotestu jednostek

Warto zauważyć, że dla trzech z czterech wierszy testy jednostek zakończyły się powodzeniem.Można zobaczyć komunikat o błędzie (z asercji) dla wiersza, który spowodował błąd. Dwu-krotnie kliknięcie tego wiersza spowoduje wyświetlenie szczegółowych informacji o niepowo-dzeniu, w tym śladu stosu błędów i odnośnika do wiersza kodu, gdzie wystąpił problem.

428


Pisanie testów jednostek

działających w ASP.NETMożna wybrać, czy testy jednostek mają być przechowywane i uruchamiane w środowiskuASP.NET zamiast w domyślnym procesie hosta VSTest. Jest to przydatne przy pisaniu testówwspółdziałających z obiektami ASP.NET, takimi jak Page i Session. Czasem programistachce przetestować usługę sieciową lub inny kod aplikacji związany z interfejsem sieciowym.Można wtedy umieścić testy jednostek dla aplikacji ASP.NET na serwerze IIS lub na serwerześrodowiska Visual Studio. Takie rozwiązanie gwarantuje, że testy będą miały pełny dostęp dozmiennych środowiskowych ASP.NET.

Definiowanie atrybutów środowiska ASP.NET

Aby określić, że test jednostek ma działać w środowisku ASP.NET, należy dodać odpowiednieatrybuty do metody testowej. Liczne atrybuty znajdują się w przestrzeni nazw UnitTesting.Web.Dlatego należy najpierw dodać odpowiednią instrukcję using (imports w języku Visual Ba-sic) w górnej części pliku klasy testów, które mają działać w ASP.NET. Instrukcja powinnawyglądać tak:

using Microsoft.VisualStudio.TestTools.UnitTesting.Web;

Ponadto w aplikacji z testem jednostek należy dodać referencję do witryny. Umożliwi to do-stęp do stron witryny i innych klas, które mogą znajdować się w katalogu App_Code oraz in-nych miejscach.

Przy tworzeniu testów jednostek w ASP.NET używane są trzy główne atrybuty: UrlToTest,HostType i AspNetDevelopmentServerHost. Atrybut UrlToTest umożliwia określeniestrony, którą należy wywołać w czasie uruchamiania danego testu jednostek. Strona jest wy-woływana przez platformę testów, a dla testu jednostek dostępny jest kontekst żądania sieciowego(poprzez obiekt Page). W kodzie testu jednostek można korzystać ze środowiska ASP.NETw taki sam sposób, jak w pliku z kodem ukrytym strony internetowej.

Atrybut HostType umożliwia zmianę typu hosta na ASP.NET. W tym celu należy przekazaćdo atrybutu łańcuch znaków ASP.NET.

Przy korzystaniu z hosta w postaci serwera IIS wystarczy ustawić atrybuty UrlToTest i HostType.Jeśli jednak programista używa serwera ASP.NET Development (współdziałającego z VisualStudio), musi ponadto dodać atrybut AspNetDevelopmentServerHost. Jako parametr atry-butu należy przekazać ścieżkę do aplikacji sieciowej. Trzeba też podać nazwę głównego katalo-gu aplikacji sieciowej.

Na listingu 9.8 pokazano przykład zastosowania wszystkich trzech wymienionych atrybutówdo zdefiniowania testu jednostek ASP.NET działającego na lokalnym serwerze rozwojowym.

429


Listing 9.8. Test jednostek ASP.NET

[TestMethod()][HostType("ASP.NET")][AspNetDevelopmentServerHost("C:\\CODE\\Unleashed\\Contoso\\ContosoWeb", "/")][UrlToTest("http://localhost:55136/ShoppingCart.aspx")]public void AddShoppingCartItemTest() {

// Pobieranie ��danej strony. Page reqPage = TestContext.RequestedPage; Assert.IsTrue(reqPage.Title == "Koszyk zakupów", "Tytu� strony jest �niew�a�ciwy.");

// Rzutowanie na typ strony. ShoppingCartPage actualPage = (ShoppingCartPage)reqPage; Assert.IsNotNull(actualPage.Cart, "Na stronie nie ma koszyka.");

// Sprawdzanie poprawno�ci kodu do obs�ugi koszyka zakupów. actualPage.Cart.AddItem("Produkt 1", 1, 12.75); actualPage.Cart.AddItem("Produkt 2", 2, 26.95); Assert.IsTrue(actualPage.Cart.Items.Count == 2, "Liczba elementów jest �niew�a�ciwa."); Assert.AreEqual(actualPage.Cart.CalculateCartTotal(), 66.65);

}

Warto zauważyć, że referencje do obiektów ASP.NET pochodzą z właściwości RequestedPageobiektu TestContext. Właściwości tej można użyć do zrzutowania danych bezpośrednio na typżądanej strony (tu jest to typ ShoppingCartPage). Oczywiście, właściwość RequestedPage matyp System.Web.UI.Page, dlatego zapewnia dostęp do obiektów Server, Session, Request,Response i podobnych.

Generowanie testów jednostek ASP.NET

Za pomocą Visual Studio można automatycznie wygenerować testy jednostek ASP.NET. Czę-sto jest to zalecana metoda tworzenia testów, ponieważ przygotowuje projekt testów do pracyze środowiskiem ASP.NET i automatycznie konfiguruje atrybuty.

Testy jednostek ASP.NET generuje się w taki sam sposób, jak wszystkie inne testy jednostek.Najpierw należy otworzyć kod (plik z kodem ukrytym strony lub inny plik klasy). Następnietrzeba kliknąć prawym przyciskiem myszy kod i wybrać opcję Create Unit Tests. Spowoduje touruchomienie kreatora Create Unit Tests (zobacz rysunek 9.5). W tym miejscu można wybraćmetody, dla których kreator ma wygenerować testy. Obsługiwane są zdarzenia związane zestroną, kliknięcie przycisków i inne zdarzenia kontrolek. Można też napisać test jednostekwyszukujący kontrolki na stronie i sprawdzający ich zawartość.

430


Konfigurowanie hosta projektu testów

Programiści często tworzą dla witryny odrębny projekt testów jednostek. Projekt może doty-czyć testów powiązanych z funkcjami witryny. Można też utworzyć dodatkowe projekty testówdo sprawdzania innych bibliotek kodu. Tego typu podział ułatwia pisanie i przeprowadzanietestów jednostek.

Ponadto można skonfigurować ustawienia projektu testów specyficznie pod kątem hosta.Dzięki temu nie trzeba definiować licznych atrybutów ASP.NET w każdym teście jednostek.Zamiast tego można skonfigurować plik .testsettings w taki sposób, aby współdziałał ze specy-ficznym hostem. W tym celu należy kliknąć dwukrotnie plik .testsettings (Solution Items/Local.testsettings), co spowoduje wyświetlenie okna dialogowego Test Settings, widocznego narysunku 9.17.

Rysunek 9.17. Plik .testsettings można wykorzystać do skonfigurowania całego projektu testów, tak aby działałdla witryny ASP.NET

WskazówkaJeśli rozwiązanie zawiera wiele projektów testów jednostek, wartoutworzyć kilka wersji pliku .testsettings. Następnie można łatwoprzełączać się między konfiguracjami dla hostów ASP.NET i stan-dardowego (VSTest).

431


W oknie dialogowym należy otworzyć widoczny po lewej stronie węzeł Hosts, a następnieustawić wartość ASP.NET dla opcji Host type. Spowoduje to udostępnienie kilku dodatkowychopcji: URL to Test, Path to Web Site i Web Application Root. Każdą z tych opcji można ustawićna wartości domyślne dla całego projektu testów jednostek.

Konfigurowanie atrybutów

testów jednostekPokazaliśmy, że istnieje wiele atrybutów, które można zastosować do testów jednostek. Oczy-wiście, możliwe jest skonfigurowanie każdego z nich w edytorze kodu. Jednak Visual Studioudostępnia pewną pomoc w oknie dialogowym Properties. Można wybrać dany test jednostek,wyświetlić okno Properties, a następnie skonfigurować atrybuty stosowane do metody testowej.Visual Studio wygeneruje kod atrybutów dla metody testowej. Przyjrzyjmy się przykładowi.

Definiowanie połączenia

za pomocą okna dialogowego Properties

Pierwszym krokiem przy stosowaniu okna Properties do konfigurowania testów jednostek jestwybranie testu. Należy to zrobić w oknie Test View (Test/Windows/Test View). Następniemożna kliknąć prawym przyciskiem myszy test na liście i wybrać opcję Properties, aby wyświe-tlić okno Properties dla danego testu. Na rysunku 9.18 pokazano przykładowe dane.

Warto zauważyć, że w oknie Properties znajdują się właściwości wielu atrybutów, które możnazastosować do metody testowej. Zmiana wartości jednej z właściwości spowoduje wygenerowanieprzez środowisko Visual Studio atrybutu i kodu w pliku z kodem (między kodem i omawianymoknem następuje dwustronna synchronizacja).

Przykładowo, właściwość Data Connection String ułatwia zdefiniowanie atrybutu DataSource.Kliknięcie przycisku z wielokropkiem przy właściwości powoduje uruchomienia kreatora,dzięki któremu można zdefiniować łańcuch połączenia z bazą danych SQL, plikiem CSV lubplikiem XML (oczywiście, można nawiązać połączenie także z innymi źródłami danych, alewymaga to napisania własnego łańcucha połączenia). We wcześniejszym przykładzie używaliśmypliku CSV. Po zaznaczeniu opcji związanej z tym formatem można przejść do pliku CSV, a nawetpodejrzeć zapisane w nim dane. Na rysunku 9.19 pokazano przykładowy ekran kreatora. Po usta-wieniu wszystkich opcji kreator zaktualizuje kod, dodając atrybuty DataSource i DeploymentItem.Poniżej znajduje się uzyskany kod konfiguracyjny:

[TestMethod(), DeploymentItem("BusinessDomainUnitTests\\TestData\\OrderTestData.csv"), DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\OrderTestData.csv", "OrderTestData#csv", DataAccessMethod.Sequential)]public void VerifyCustomerOrders() { ...

432


Rysunek 9.18. Można zaznaczyć test w oknie Test View, a następnie skonfigurować jego atrybuty w oknie Properties

Rysunek 9.19.Testy jednostek możnapowiązać z testowymidanymi, w tymz prostym plikiem .csv

433


Tworzenie testów uporządkowanychVisual Studio umożliwia łączenie grup testów jednostek, określanie kolejności ich wykonywaniai traktowanie wyników w taki sposób, jakby uzyskano je dla pojedynczego testu. Może to byćprzydatne, jeśli programista chce napisać testy jednostek zależne od siebie. Można na przykładwstawić rekord w jednym teście i oczekiwać, że ten sam rekord będzie dostępny w dalszymteście. Oczywiście, jest to niezgodne z dobrymi praktykami testów jednostek — możliwe powinnobyć przeprowadzenie każdego testu niezależnie od pozostałych. Na szczęście można utworzyćtest uporządkowany, który łączy poszczególne testy jednostek w nowy, niezależny test.

Test uporządkowany można dodać do projektu testów, klikając projekt prawym przyciskiemmyszy i wybierając opcję Add/Ordered Test. Można też wybrać szablon Ordered Test w okniedialogowym Add New Test (zobacz rysunek 9.3).

Test uporządkowany to po prostu plik XML oparty na szablonie Ordered Test. Nie trzeba jed-nak ręcznie edytować kodu w języku XML. Środowisko Visual Studio udostępnia jako pomocokno projektowe dla testów uporządkowanych. Przykładową zawartość takiego okna pokazanona rysunku 9.20.

Rysunek 9.20. Do testu uporządkowanego można dodać istniejący test jednostek, aby utworzyć nowy test, w którymposzczególne testy uruchamiane są w określonej kolejności

434


Po lewej stronie okna dialogowego znajdują się wszystkie testy z rozwiązania. Można wyświe-tlić testy z wybranej listy (zobacz podrozdział „Organizowanie testów”). Po lewej stronie należyzaznaczyć poszczególne testy i użyć strzałki (>) w celu ich dodania do testu uporządkowanego.Skierowane w górę i w dół strzałki widoczne po prawej stronie służą do zmiany kolejnościprzeprowadzania testów.

Przy wykonywaniu testów uporządkowanych środowisko Visual Studio uruchamia każdy testjednostek w podanej kolejności. Jeśli którykolwiek test się nie powiedzie, cały test uporządkowanyzakończy się niepowodzeniem. Oczywiście, można wyświetlić szczegółowe informacje na temattestu uporządkowanego, aby zobaczyć, które testy zakończyły się sukcesem, a które — porażką.

Organizowanie testówWiększość projektów testów jednostek składa się z licznych testów — nieraz są ich setki. Po-nadto często w jednym rozwiązaniu znajduje się wiele projektów testów jednostek. Zarządzaniewszystkimi testami i uruchamianie tylko tych potrzebnych w danym momencie bywa trudne.Visual Studio udostępnia pewną pomoc w tym zakresie — okna Test View i Test List Editor.

Okno Test View

Okno Test View umożliwia wyświetlenie wszystkich testów w otwartym rozwiązaniu, zazna-czenie tych, którymi programista jest zainteresowany, i albo uruchomienie ich, albo zarządzaniewłaściwościami ich atrybutów.

Dostęp do okna Test View można uzyskać z menu Test (Test/Windows/Test View). Na rysunku9.21 pokazano przykładową zawartość okna. Warto zauważyć, że można zaznaczyć jeden lubkilka testów, kliknąć prawym przyciskiem myszy i uruchomić wybrane testy w jednym prze-biegu. Dzięki temu nie trzeba uruchamiać wszystkich testów jednostek, jeśli ważna jest tylkojedna metoda testowa (lub ich mała grupa).

W górnej części okna Test View znajduje się pasek narzędzi. Umożliwia on wyszukiwanietestów na podstawie słów kluczowych i modyfikowanie sposobów grupowania lub filtrowaniatestów. Sprawia to, że znalezienie testów jest łatwiejsze. Można na przykład zmienić wartośćopcji Group By na Class Name, aby wyświetlić wszystkie testy dla określonej klasy. Przykładoweustawienia pokazano na rysunku 9.22.

435


Rysunek 9.21. Okno Test View umożliwia łatwe zaznaczenie zbioru testów do uruchomienia

Rysunek 9.22.Można użyć opcjiGroup By, aby ułatwićsobie znalezienietestów jednostek

Okno Test List Editor

Visual Studio udostępnia też okno Test List Editor. Posiada ono podobne funkcje jak okno TestView. Umożliwia wyszukiwanie testów, grupowanie ich i uruchamianie zbiorów testów. Jednakw odróżnieniu od okna Test View pozwala także zapisywać zdefiniowane listy testów. W tensposób można utworzyć i ponownie wykorzystać listy, kiedy zajdzie potrzeba uruchomieniazbioru testów.

436


Dostęp do okna Test List Editor można uzyskać z menu Test (Test/Windows/Test List Editor).Pojawi się okno podobne do tego z rysunku 9.23. Po lewej stronie widnieją listy testów. Do-myślnie dostępne są opcje Lists of Tests, Tests Not in a List i All Loaded Tests. Jeśli programistawybierze listę z testami (na przykład All Loaded Tests), może albo uruchomić całą listę, albo użyćpól wyboru widocznych po prawej stronie okna do wybrania z listy testów do przeprowadzenia.

Rysunek 9.23. Można zaznaczyć testy w oknie Test List Editor i uruchomić je jako grupę

Okna Test List Editor można używać do tworzenia nowych list testów w celu zapisania testówregularnie wykonywanych w jednym zestawie. Aby utworzyć listę, należy kliknąć prawymprzyciskiem myszy pozycję Lists of Tests w oknie Test List Editor, a następnie wybrać opcjęNew Test List. Pojawi się okno dialogowe Create New Test List. W oknie można podać nazwęlisty testów i określić jej pozycję wśród innych list (zobacz rysunek 9.24).

Aby dodać test jednostek do nowej listy, można zastosować technikę przeciągania. Najpierwnależy wybrać listę All Loaded Tests w celu wyświetlenia wszystkich wczytanych testów. Na-stępnie trzeba zaznaczyć wszystkie testy, które mają znaleźć się na nowej liście. Wybrane testywystarczy przeciągnąć na nazwę niestandardowej listy widoczną po lewej stronie okna Test ListEditor. W ten sposób testy zostaną powiązane z nową listą. Na rysunku 9.25 pokazano kilkaprzykładowych niestandardowych list i testy z jednej z nich.

437


Rysunek 9.24.Można definiowaćnowe listy testów dowielokrotnego użytku

Rysunek 9.25. Można definiować niestandardowe listy testów i dodawać do nich testy jednostek

Po utworzeniu listy testów do przeprowadzenia można uruchomić je za pomocą paska narzędziaokna Test List Editor. W tym celu należy wybrać opcję Run Checked Tests (zobacz rysunek 9.23).

438


PodsumowanieW tym rozdziale pokazaliśmy, jak używać platformy testów jednostek do definiowania pro-jektów testów i jak za pomocą atrybutu TestClass tworzyć pliki klas testów. Każda metodatestowa powinna mieć atrybut TestMethod. Przy użyciu klasy atrybutu DataSource możnatworzyć testy jednostek powiązane z danymi.

Visual Studio umożliwia generowanie testów jednostek na podstawie istniejącego kodu. Udo-stępnia też w narzędziu Test View okno dialogowe Properties, aby ułatwić generowanie koduatrybutów testów.

Można tworzyć testy jednostek obsługiwane przez ASP.NET (na serwerze IIS lub serwerzerozwojowym środowiska Visual Studio). W testach jednostek ASP.NET wykorzystywany jestobiekt TestContext do uzyskania dostępu do informacji o środowisku ASP.NET, w tym o prze-twarzanej stronie, sesji i zmiennych serwera.

Pisanie testów jednostek może prowadzić do zmniejszenia liczby problemów w kodzie pro-dukcyjnym. Przygotowanie zestawu testów kodu ułatwia jego zrozumienie i zwiększa nieza-wodność. Ponadto programista może z większą pewnością wprowadzać zmiany, ponieważpotrafi określić, w jakim fragmencie kodu w wyniku modyfikacji pojawiły się usterki.

Skorowidz

!, 136!=, 135#End Region, 368#endregion, 368#region, 368#Region, 368$CALLER, 504$FUNCTION, 504&, 135, 136&&, 136.NET, 23, 175.NET Framework 4, 74.NET Framework Components, 831//HACK, 394//TODO, 394@Page, 769@Register, 804@WebService, 1018, 1019^, 136|, 136||, 136+, 135<%@ Page StylesheetTheme="" %>, 774<%@ Page Theme="" %>, 773<%@ Register %>, 804<%= %>, 165<>, 144<asp:Label>, 782<asp:WebPartZone>, 782<Author>, 386<Code>, 386, 388<CodeSnippet>, 386<CodeSnippets>, 386<Declarations>, 386<Default>, 386<Description>, 386<Function>, 386<Header>, 386<ID>, 386<Literal>, 386<Shortcut>, 386<Snippet>, 386<SnippetType>, 386

<SnippetTypes>, 386<Title>, 386<ToolTip>, 386<ZoneTemplate>, 782=, 135==, 135

A

Abstract, 121Access, 993Access board section 508, 734AccessDataSource, 800, 993Accessibility Validation, 289Accordion, 917Action, 175, 745, 1154ActionsPane.StackOrder, 1150ActionsPaneControl1, 1150Activate, 574Active Template Library, 41ActivePoint, 601ActiveWindow.Object.GetItem, 620Activity, 1068, 1077Activity Designer, 1068, 1069Activity Designer Library, 1066Activity Library, 1065ActivityXamlServices.Load(), 1080Add ASP.NET Folder, 725, 771Add Connection, 944Add Controler, 814Add Correlation Initializers, 1112Add Database Reference, 970Add New Data Source, 976Add New Item, 56, 189, 340, 680, 728, 737, 738, 758,

765, 827, 1018niestandardowe szablony, 341

Add New Project, 809, 1017, 1043Add New Stored Procedure, 956Add New Test, 403, 433Add New Trigger, 960Add New User Control, 290Add Reference, 86, 730, 731Add Related Tables, 948

1210

Skorowidz

Add Service Reference, 730, 1033, 1034, 1036Add Stored Procedure, 971Add Style Rule, 271, 758, 759, 760Add Task List Shortcut, 395Add User Control, 655Add View, 818Add Web Reference, 730, 1035Add-in, 51AddIn, 562Add-in Manager, 639, 653Add-in Wizard, 677AddNamedCommand2, 651AddToCollection<T>, 1087ADO.NET, 175ADO.NET Data Service, 728ADO.NET Entity Data Model, 69, 812, 1001adres URL, 807, 1016Advanced compile options, 207AggregateCatalog, 691AJAX, 53, 58, 904

kontrolki, 58UpdatePanel, 58UpdateProgress, 58

AJAX Client Behavior, 728AJAX Client Library, 728AJAX Control Library, 728Ajax Control Toolkit, 915

kontrolki, 917stosowanie kontrolek, 919

Ajax Extensions, 905, 907AJAX Master Page, 727AJAX-enabled WCF Service, 728aktualizacja częściowa, 907aktualizacja danych w modelu EDM, 1007aktualizacja lokalnego systemu pomocy, 313aktualizacja schematu bazy danych, 968aktywne odnośniki, 365AlwaysVisibleControlExtender, 917analiza kodu, 470Anchor, 834, 835anchoring, 833And, 136AndAlso, 136animacja, 862aplikacje, 43

aplikacje .NET, 43aplikacje AJAX, 58aplikacje Azure, 1170aplikacje biznesowe, 68, 71, 72aplikacje ClickOnce, 535

aplikacje klienckie, 1064aplikacje konsolowe, 242aplikacje LINQ to SQL, 996aplikacje MEF, 690aplikacje nadrzędne, 689aplikacje okresowo nawiązujące połączenie, 71aplikacje oparte na usługach sieciowych

ASP.NET, 1015aplikacje oparte na usługach WCF, 1041aplikacje rozproszone, 63aplikacje równoległe, 520aplikacje SharePoint, 45, 52aplikacje Web 2.0, 904aplikacje Web Form, 808, 809aplikacje wielowątkowe, 176, 515aplikacje WinForm, 44aplikacje XAML dla przeglądarek, 48, 922

aplikacje ASP.NET, 44, 54, 63, 714definiowanie sposobu kompilacji, 731diagnostyka, 736docelowa wersja platformy .NET, 733dodawanie referencji, 730dodawanie stron internetowych, 737dostępność, 733interfejs użytkownika, 746katalogi, 726kompilacja, 731kompozycje, 770opcje konfiguracyjne, 729pliki, 727położenie kontrolek, 747prekompilacja, 736projekt, 715projektowanie interfejsu użytkownika, 746referencje, 729serwer, 735Silverlight, 736skórki, 770strony wzorcowe, 765układ strony, 747wdrażanie, 549web.config, 55właściwości, 729zachowanie podczas ładowania strony, 735zgodność ze standardem dostępności stron

HTML, 735aplikacje ASP.NET MVC, 805, 917

AcceptVerbs, 816ActionResult, 815adres URL, 807

1211

Skorowidz

Application_Start, 819Content, 812Controllers, 811Create, 815dane, 805, 806definiowanie przekierowań adresów URL

do kontrolera, 819dodawanie mechanizmów, 812dodawanie rekordów do modelu, 815kodu interfejsu użytkownika, 806kontroler, 806, 807model, 805, 806model przetwarzania żądań, 807Models, 811projekt, 809przekierowanie adresów URL, 819RegisterRoutes, 819Scripts, 812struktura katalogów, 810szablon aplikacji, 805testowanie, 809tworzenie kontrolera, 814tworzenie modelu, 812tworzenie projektów, 809tworzenie widoku, 817UrlRoutingModule, 807uruchamianie aplikacji, 820View, 815ViewResult, 815Views, 811widok, 805, 806, 807zalety platformy ASP.NET MVC, 808żądania HTTP, 807

aplikacje do zarządzania procesem, 1062, 1096baza danych, 1099biblioteka dostępu do danych, 1100dodawanie usługi do utrwalania procesu, 1116dostęp do danych, 1108komunikacja z pamięcią trwałą, 1118pamięć trwała, 1117projekt, 1097projektowanie procesu, 1107, 1110tworzenie, 1096tworzenie aplikacji klienckiej, 1119tworzenie biblioteki czynności, 1105tworzenie niestandardowej czynności Code

Activity, 1106tworzenie niestandardowej czynności złożonej, 1105tworzenie pamięci trwałej, 1117tworzenie projektów, 1098

uruchamianie aplikacji do obsługi procesu, 1124usługa, 1104utrwalanie procesów, 1116

aplikacje działające w chmurze, 64, 1158instalacja usługi w chmurze, 66konfiguracja aplikacji o roli Web, 1186projekt, 64, 1175przenoszenie do środowiska produkcyjnego, 1204przygotowanie aplikacji do publikacji, 1196publikowanie aplikacji, 66, 1199rozwijanie aplikacji, 1175tworzenie, 1160, 1170tworzenie interfejsu o roli Web, 1180tworzenie modelu danych opartego na tabeli, 1175uruchamianie aplikacji, 64wdrażanie, 1188, 1199wdrażanie w środowisku testowym, 1200

aplikacje Office, 1135projekt, 1135

aplikacje sieciowe, 44, 54, 282, 715diagnozowanie, 470projekt, 715wiązanie danych, 989

aplikacje Silverlight, 44, 59, 736, 934interfejs użytkownika, 935kontrolki, 936MainPage.xaml, 935pokaz slajdów, 936projekt, 59, 934strona XAML, 935tworzenie, 60, 934, 935wybór rodzaju klienta, 61

aplikacje Windows, 46, 271dodawanie kontrolek do formularza, 273dostosowywanie wyglądu formularza, 273formularze, 273kontrolki, 273pisanie kodu, 277projekt, 46, 272, 826rozmieszczanie kontrolek, 275układ formularza, 46układ tabelaryczny, 275zdarzenia, 47

aplikacje WPF, 44, 865, 904, 922aplikacje przeznaczone do uruchamiania

w przeglądarkach, 922DataTemplate, 893dodawanie kontrolek, 282formularze, 281górne menu aplikacji, 887

1212

Skorowidz

aplikacje WPFkomponenty formularzy Windows, 861lista obrazów, 886ListBox, 886manipulowanie obrazami, 895metody do obsługi zdarzeń związanych, 894nawigowanie po znacznikach, 371pliki XAML, 280projekt, 280, 866przeglądarka obrazów, 888przyciski, 894rozmiar tabeli, 889tworzenie, 871, 884tworzenie układu, 885układ, 871, 885wiązanie danych, 986wiązanie rysunków, 893zapisywanie obrazów, 891

aplikacje XBAP, 922app.xaml, 924bezpieczeństwo, 926ClickOnce, 929diagnozowanie, 925formularze, 924instalacja, 929nawigowanie po witrynie, 928PageX.xaml, 924projekt, 923strony, 924tworzenie, 922typy MIME, 931uruchamianie, 925WindowX.xaml, 924zarządzanie zabezpieczeniami, 928

app.config, 1103App_Browsers, 727App_Code, 428, 717, 726, 1018App_Data, 716, 717, 726App_GlobalResources, 726App_LocalResources, 726App_Themes, 727, 771App_WebReferences, 726AppFabric, 1158, 1160, 1164Application, 863, 1017application fabric, 1158Application Type, 206Application.EnableVisualStyles, 840, 841Application_Start, 819Apply Style, 763Apply Styles, 287, 763

architektura ASP.NET MVC, 806architektura MVC, 714architektura platformy MEF, 689architektura platformy WPF, 861AreEqual, 420AreNotEqual, 420AreNotSame, 420AreSame, 420argumenty procesu, 1070, 1071arkusze stylów, 756, 758arkusze stylów XSLT, 264, 269Array, 142ArrayList, 143asercje, 404, 420

AreEqual, 420AreNotEqual, 420AreNotSame, 420AreSame, 420CollectionAssert, 421Fail, 420Inconclusive, 420IsFalse, 420IsInstanceOfType, 420IsNotInstanceOfType, 420IsNotNull, 420IsNull, 420IsTrue, 420sprawdzanie kolekcji obiektów, 421sprawdzanie łańcuchów znaków, 422stosowanie danych testowych, 426StringAssert, 422

asocjacja, 297ASP, 165ASP.NET, 44, 52, 54, 177, 282, 714, 922

cykl życia strony, 741członkostwo, 795interfejs konfigurowany przez użytkownika, 776interfejs użytkownika, 746katalogi, 725, 726kompozycje, 770kontrolki, 788kontrolki danych, 799kontrolki logowania, 795kontrolki nawigacyjne witryny, 798kontrolki użytkownika, 801kontrolki walidacyjne, 793, 794kontrolki Web Part, 776logowanie, 795mapa witryny, 798model zdarzeń, 741

1213

Skorowidz

MVC, 56, 57personalizacja interfejsów użytkownika, 776pliki, 727procedury obsługi zdarzeń, 744skórki, 770strony internetowe, 737strony wzorcowe, 765style, 754testy jednostek, 428uwierzytelnianie użytkowników, 796Web Part, 776wykresy, 800, 801zdarzenia, 741

ASP.NET Ajax, 904aktualizacja częściowa, 907ASP.NET MVC, 917kontrolki, 905odświeżanie częściowe, 912ScriptManager, 906ScriptManagerProxy, 906stronicowanie, 912Timer, 906UpdatePanel, 906, 908UpdateProgress, 906, 913wyświetlanie informacji o postępie pracy

serwera, 913wyświetlanie powiadomień, 913

ASP.NET Ajax Control Toolkit, 916ASP.NET Ajax Library, 915

kontrolki, 915ASP.NET Development Server, 719ASP.NET Empty Web Site, 1017ASP.NET Membership, 795ASP.NET MVC, 805

ASP.NET Ajax, 917ASP.NET MVC 2 Web Application, 809ASP.NET MVC 2 Web Role, 1167ASP.NET MVC Web Application, 57ASP.NET Non-Visual Controls, 779ASP.NET Reports Web Site, 717ASP.NET Web Application, 54ASP.NET Web Role, 64, 1167, 1170, 1175ASP.NET Web Service, 716ASP.NET Web Site, 283, 716ASPNETDB.MDF, 797AspNetDevelopmentServerHost, 428Assembly Name, 206AssemblyCatalog, 691AssemblyCleanup, 415AssemblyInitialize, 415

Assert, 420, 421AreEqual, 404, 420, 421AreNotEqual, 421Inconclusive, 405

Assign, 1085AssociatedUpdatePanelID, 913Asynchronous JavaScript and XML, 53, 904ATL, 41atrybuty, 145atrybuty deklaratywne, 145atrybuty testów jednostek, 431Attach Style Sheet, 761, 762Attach to Process, 483, 485, 514, 515Authenticode, 349AutoCompleteExtender, 917AutoGenerateDeleteButton, 992AutoGenerateEditButton, 992automatyczne formatowanie kodu, 101automatyczne generowanie kodu do obsługi

właściwości, 166automatyzacja, 560

kategorie automatyzacji, 563automatyzacja procesu kompilacji, 37automatyzacja procesu tworzenia testów jednostek, 402automatyzacja testowania jednostek, 398Autos, 485, 506AutoScaleDimensions, 835AutoScaleMode, 835, 836Azure, 65, 66, 1158

ADO.NET, 1177aplikacje, 1170aplikacje o roli Web, 1164, 1168aplikacje o roli Worker, 1164AppFabric, 1158, 1160, 1164ASP.NET, 1163DevFabric, 1159, 1161, 1170hosting, 1159instalacja pakietu SDK, 1160interfejs o roli Web, 1180klasy, 1178kolejki, 1168konfiguracja aplikacji o roli Web, 1186konfiguracja środowiska programistycznego, 1160obiekt źródła danych, 1183obiekty blob, 1168platforma programowania, 1159projekt, 1165, 1167przechowywanie danych, 1159, 1167przygotowanie aplikacji do publikacji, 1196publikowanie aplikacji, 1199

1214

Skorowidz

Azurerelacyjna baza danych, 1169role, 1164rozwijanie aplikacji, 1174, 1175serwer IIS, 1163SQL Azure, 1169subskrypcja usług, 1188tabele, 1168tworzenie interfejsu o roli Web, 1180tworzenie konta do przechowywania danych, 1190tworzenie konta usług hosted service, 1194tworzenie modelu danych opartego na tabeli, 1175tworzenie projektów, 1175wdrażanie aplikacji, 1174, 1188zakładanie konta, 1188zalety stosowania, 1158

Azure SDK, 1160

B

BackColor, 828, 840base, 122Basic Unit Test, 401baza danych, 67, 942, 1099

aktualizowanie schematu, 968budowanie związków tabel, 948definiowanie tabel, 945diagram, 947funkcje definiowane przez użytkownika, 961indeksy, 946klucze obce, 946kompilowanie, 968LINQ, 994łańcuch połączenia, 973obiekty bazy danych, 970odwzorowanie obiektowo-relacyjne, 993ograniczenia, 946procedury składowane, 956projekt, 961Schema View, 967skrypty SQL, 962SQL, 951SQL Server, 942tabele, 942tworzenie, 943tworzenie projektu, 962wdrażanie, 968wiązanie danych, 974widoki, 955wyzwalacze, 960

związki jeden do jednego, 950związki tabel, 948związki wiele do wielu, 950związki zwrotne, 950

bezpieczeństwo aplikacji XBAP, 926bezpośrednie korzystanie z elementów XML, 164BI, 1169biblioteka dostępu do danych, 1100biblioteka MSDN, 314BigInteger, 42Bin, 726Binding, 881Bindings, 607BitmapSource, 891, 893Blank Solution, 184, 1098błędy, 475bogate aplikacje internetowe, 904bogate interakcje oparte na przeglądarkach

w systemie Windows, 921bogaty interfejs użytkownika, 61Bookmark, 1149Bookmarks, 247Bookmarks Window, 247bool, 130Boolean, 130Bottom, 833break, 137, 138, 140Break All, 485, 491Break at Function, 483Breakpoint, 478, 495, 562Breakpoint Condition, 500, 501Breakpoint Hit Count, 503Breakpoint2, 562Breakpoints, 480, 482, 484, 496

dodawanie etykiet punktów przerwania, 499dostęp do punktu przerwania, 498Go To Source Code, 498pasek narzędzi, 496, 497przerywanie działania na podstawie warunków, 500ustawianie warunków punktu przerwania, 500zarządzanie etykietami punktów, 499zarządzanie punktami przerwania, 496, 498

Bring to Front, 752, 846bubbling event, 883budowanie luźno powiązanych aplikacji sieciowych, 56budowanie stylu CSS, 759budowanie związków tabel, 948Build, 91Build Configuration, 193Build events, 207

1215

Skorowidz

BuildDependencies, 562BuildDependency, 562BuildEvents, 562, 609BuildingBlockGalleryContentControl, 1149Business Intelligence, 1169BusinessEntities, 1025, 1045, 1047Button, 274, 792, 863byte, 130Byte, 130

C

C Runtime Library, 41C#, 115CA, 349CAB, 540Cached, 1152CachedAttribute, 1151CachedDataHostItem, 1153CachedDataItem, 1153CAL, 38Calendar, 792CalendarExtender, 918, 919Call Hierarchy, 248Call Stack, 476, 485, 519CallBase(), 388CancellationScope, 1089Canvas, 696, 871CascadingDropDown, 918case, 137, 138Case, 137, 138Case Else, 138CatalogZone, 779Catch, 146, 147CDbl, 132CE, 71CenterParent, 828CenterScreen, 828Cert2spc.exe, 349Certificate Creation Tool, 349certyfikaty Authenticode, 349CGI Web Role, 1167ChangePassword, 796CharLeft, 600CharRight, 600Chart, 800, 801CheckBox, 792chmurki, 841chmury obliczeniowe, 63, 1158Choose Data Source, 909

Choose Location, 719CInt, 132class, 115, 121, 122, 126Class, 115, 123Class Designer, 32, 94, 293

asocjacja, 297definiowanie metod, 298definiowanie pól, 298definiowanie zdarzeń, 298dziedziczenie, 296Inheritance, 296, 297interfejs, 296refaktoryzacja, 444tworzenie diagramu klasy, 293tworzenie klas, 293View Class Diagram, 294wyświetlanie składowych, 294

Class Details, 298, 299Class Name, 244Class View, 219, 448

Class View New Folder, 220Class View Settings, 220filtrowanie, 220panel obiektów, 221panel składowych, 222pasek narzędzi, 220pasek wyszukiwania, 220przyciski paska narzędzi, 220View Class Diagram, 220

ClassCleanup, 415, 418ClassInitialize, 415, 418ClassName(), 388Clear All DataTips, 483, 486Clear All DataTips Pinned to, 486ClearBookmarks, 594ClearCollection<T>, 1087ClickOnce, 208, 534, 929

lokalizacja katalogu instalacji, 538lokalizacja katalogu publikacji, 538publikowanie projektów, 536Publish Wizard, 536, 538sposoby wdrażania aplikacji, 535tworzenie pakietu instalacyjnego, 536wdrażanie za pomocą płyty CD, 535wdrażanie za pomocą serwera WWW, 535właściwości publikacji pakietu, 537wykonywanie za pomocą serwera WWW, 535

Client Access License, 38Close, 574cloud computing, 63

1216

Skorowidz

Cloud Service, 64CLR, 40clrversion, 335CLS, 40CMMI, 37Code Activity, 1068, 1069, 1075Code Definition, 262, 263Code DOM, 682Code Snippets Manager, 389CodeActivity, 1063, 1075, 1077CodeActivityContext, 1076CodeClass, 569CodeElement, 569CodeElement.Kind, 569CodeElements, 569, 570CodeModel, 569Collapse to Definitions, 369CollapseAll, 621CollapsiblePanelExtender, 917Collection, 1086CollectionAssert, 421CollectionBase, 143, 144Column.Width, 889COM, 640COM Components, 831ComboBoxContentControl, 1149Command, 562, 605

Bindings, 607składowe, 605

Command Window, 578, 583uruchamianie makra, 632

CommandBar, 588, 589, 590, 591składowe, 590

CommandBarControl, 589CommandBars, 591Commands, 562, 605, 651

AddNamedCommand, 607Raise, 606

Commands2, 562, 651CommandWindow, 562, 578, 583Common Language Runtime, 40Common Language Specification, 40Common Type System, 40CompareValidator, 794CompensableActivity, 1087, 1088, 1089Compensate, 1089CompensationHandler, 1088Compile options, 207Compiler conditions, 207Complete Word, 375

Component Class, 290Component Designer, 744component tray, 830CompositionContainer, 691Configuration, 562Configure Data Synchronization, 71Confirm, 1089ConfirmButtonExtender, 918, 921Connect, 640, 645, 659Console.ReadLine, 378Console.WriteLine, 242, 244const, 133Const, 133consume first, 377ContainerControl, 835ContentPlaceHolder, 766, 767, 768ContentResult, 808Context, 1017ContextParams, 678ContextToken, 231Continue, 485, 487, 493ContosoCSR, 539Control, 290, 830, 863Control Flow, 1083ControlTemplate, 879ControlToValidate, 793Convert, 133Copy, 94Copy to Output Directory, 352Copy Web Project, 216Copy Web Site Tool, 549, 554

połączenie z witryną, 555Remote Site, 556

CorrelationScope, 1090Create a New Binding, 1054Create a New Service Endpoint, 1051Create GUID, 661Create New SQL Server Database, 943Create New Test List, 436Create Schema, 265Create Transparent Windows Form, 382Create Unit Test Project, 809Create Unit Tests, 402, 403, 404, 429Create User Task, 396CreateEditPoint, 599CreateToolWindow2, 659, 660, 661CreateUserWizard, 796CRM, 1013CRT, 41

1217

Skorowidz

CSS, 270, 757Apply Styles, 763arkusze stylów, 756budowanie stylu, 759definiowanie stylów, 757dodawanie zasady stylu, 759hierarchia stylów, 757Manage Styles, 760modyfikacja stylów, 764narzędzia do tworzenia stylów, 756stosowanie stylów, 763style elementów, 755style wewnątrzwierszowe, 755style z poziomu strony, 755tworzenie arkusza stylów, 758właściwości stylu, 764zarządzanie stylami, 760zasady stylów, 755

CSS Outline, 758CSS Properties, 287, 764CssClass, 755, 763CTS, 40Current Page, 761CurrentSettings.vssettings, 82Custom Actions, 546custom control, 853Customer Feedback Options, 324Customize, 95Customize the Start Page, 84CustomValidator, 794Cut, 94Cut Line, 192cykl życia dodatków, 645cykl życia formularza Windows, 829cykl życia strony ASP.NET, 741, 742czcionki, 110części, 690, 695członkostwo ASP.NET, 795czynności procesów, 72, 1082

AddToCollection<T>, 1087Assign, 1085CancellationScope, 1089ClearCollection<T>, 1087CompensableActivity, 1089Compensate, 1089Confirm, 1089CorrelationScope, 1090Delay, 1085DoWhile, 1084ExistsInCollection<T>, 1087

Flowchart, 1095, 1114FlowDecision, 1095FlowSwitch<T>, 1095ForEach, 1084If, 1084InitializeCorrelation, 1090InvokeMethod, 1085Parallel, 1084ParallelForEach, 1084Persist, 1085Pick, 1084Receive, 1090, 1115ReceiveAndSendReply, 1090RemoveFromCollection<T>, 1087Rethrow, 1086Send, 1090SendAndReceiveReply, 1090Sequence, 1084Switch, 1084TerminateWorkflow, 1085Throw, 1086TransactedReceiveScope, 1090TransactionScope, 1089TryCatch, 1086While, 1084WriteLine, 1085

D

DAC, 969dane, 67dane hierarchiczne, 849dane tabelaryczne, 852dane XML, 164, 165Data, 92Data Source Configuration Wizard, 976, 977Data Sources, 978Data Tier Applications, 969Data/New Query, 952Database, 961Database Diagram Designer, 947, 949Database Unit Test, 401DataContext, 882DataGridView, 852, 978, 980, 990

dostosowanie edycji komórek, 983edycja komórek, 983modyfikacja zapytania dla źródła danych, 985typy komórek, 852wiązanie danych, 980, 983zmiana typu kolumny, 984źródła danych, 852

1218

Skorowidz

DataGridViewButtonColumn, 983DataGridViewColumn, 983DataGridViewComboBoxColumn, 983, 984DataList, 800, 808, 990DataPager, 800DataServiceContext, 1177DataSet, 161, 1151DataSet Designer, 981, 982, 984DataSource, 415, 423, 431DataTable, 161DataTemplate, 893DataTip, 508, 509DatePickerContentControl, 1149DateTimePicker, 980, 983Debug, 91, 470, 482

tryb diagnostyczny, 483tryb spoczynku, 482

DEBUG, 206Debug Location, 517Debug Source Files, 192Debug with Mixed, 528debuger, 207, 477, 481

aplikacje sieciowe, 489Break All, 491Breakpoints, 496Continue, 493Detach All, 493dołączanie do działającego procesu, 477kontynuowanie wykonywania kodu, 493kończenie sesji diagnostycznej, 493menu Debug w czasie sesji diagnostycznej, 484menu Debug w stanie spoczynku, 482obiektowy model automatyzacji, 608opcje diagnozowania, 487pasek narzędzi Debug, 486podglądanie danych, 505podglądanie zmiennych, 505podpowiedzi DataTip, 508przechodzenie przez kod, 491punkt śledzenia, 503rozpoczynanie sesji diagnostycznej, 489, 491Run To Cursor, 490sesja diagnostyczna, 483Start Debugging, 491Step Into, 489, 491Step Out, 493Step Over, 489, 491Terminate All, 493uruchamianie sesji diagnostycznych, 482ustawianie punktów przerwania, 494

ustawianie punktów przerwania funkcji, 495wartości zmiennych, 505warunki wstrzymania wykonywania kodu, 494wkraczanie w kod, 488, 489zarządzanie warunkami wstrzymania działania

programu, 496zmień i kontynuuj, 511

Debugger, 260, 562, 608Debugger.Break, 260Debugger2, 562Debugger3, 562Debugger4, 562Debugger5, 562DebuggerEvents, 562decimal, 130Decimal, 130default, 137Default namespace, 206Default.aspx, 716, 908, 931, 1170default.htm, 931default.html, 931definiowanie

aplikacje WinForm, 47atrybuty arkuszy stylów, 271atrybuty środowiska ASP.NET, 428interfejsy, 124klasy, 115kolekcje, 155metody, 117, 298plik VSContent, 345, 346pola, 298procedury obsługi zdarzenia, 829referencje sieciowe, 1033relacje między klasami, 296stałe, 133struktury, 126tabele, 945układ strony Web Part, 780właściwości, 298zdarzenia, 148, 298

deklaracjaprzestrzenie nazw, 127skórki, 772typy anonimowe, 156zmienne, 130

dekoracje, 693, 697projekt, 702

Delay, 1085Delay signing, 209delegaty, 147

1219

Skorowidz

DELETE, 955Delete All Breakpoints, 483DeleteQuery, 992dependency injection, 689Deploy SQL, 552DeploymentItem, 416, 431deserializacja, 1153Design, 55design schema, 68Detach All, 485, 493DetailsView, 800, 989development fabric, 1159Development Fabric, 64, 65, 1173Development Storage Service, 1173Development Tools Environment, 561DevFabric, 1159, 1161, 1170diagnozowanie, 258, 468, 481

analiza kodu, 470aplikacje sieciowe, 470aplikacje XBAP, 925Breakpoints, 480Call Stack, 476diagnozowanie błędów, 475diagnozowanie innych procesów, 476etapy, 469Exception Assistant, 476Exceptions, 474Immediate, 476kodowanie, 469kompilacja, 469kontynuowanie diagnozowania, 478kroczenie przez kod, 480Locals, 476makra, 623podglądanie zmiennych, 505procedury składowane, 958przegląd kodu, 470przerywanie w momencie wystąpienia błędu, 474rozwiązywanie problemów, 470Run To Cursor, 472samodzielne sprawdzanie, 470scenariusz, 469Show Next Statement, 478skrypty działające po stronie klienta, 526Start Without Debugging, 472Step Into, 480stos wywołań, 476testy jednostek, 470Thrown, 475uruchamianie aplikacji w trybie diagnozowania, 472

ustawianie punktów przerwania, 478wartości zmiennych, 476włączanie diagnozowania stron internetowych, 470zarządzanie zbiorem wyjątków, 474zdalne diagnozowanie, 513

diagnozowanie aplikacji równoległych, 520Parallel Stacks, 521Parallel Tasks, 525

diagnozowanie aplikacji wielowątkowych, 515Call Stack, 519Debug Location, 517oznaczanie wątków, 515przerywanie działania kodu po wejściu

do konkretnego wątku, 519Show Threads in Source, 516sprawdzanie poszczególnych wątków, 518Threads, 517wizualizacja wątków, 515wykrywanie wątków, 515zarządzanie diagnozowanymi procesami

i wątkami, 517diagnozowanie informacji o awarii, 527

Cache Symbols in This Directory, 530Debug with Mixed, 528, 530diagnozowanie z wykorzystaniem pliku zrzutu, 528pliki symboli, 529pliki zrzutów, 527Save Dump As, 527Set Symbol Paths, 528tworzenie zrzutów informacji diagnostycznych, 527

diagnozowanie usług WCF, 514dołączanie debugera do usług WCF, 515wkraczanie w kod usługi WCF, 514

diagram bazy danych, 947Diagram Designer, 950diagram klasy, 293

dodawanie elementów, 294wyświetlanie składowych, 294

DialogResult, 681Dim, 131direct event, 883DirectoryCatalog, 691DirectoryImageList, 896Disable All Breakpoints, 483, 486Disassembly, 485DISCO, 1016Disco.exe, 1030Discovery Document, 1016DispatcherObject, 863DisplayAfter, 913

1220

Skorowidz

DivideByZeroException, 146do…while, 140Do…While, 140Dock, 835DockPanel, 871, 872Document, 51, 562, 592, 594

składowe, 592Document Outline, 232, 371, 372

Collapse All, 234Expand All, 234modyfikacja elementów, 233Move Down in Container, 234Move into Next Container, 234Move Out of Current Container, 234Move Up in Container, 234pasek narzędzi, 234Type Name Display Style, 234

Document Type Definition, 264DocumentReader, 862Documents, 562, 592dodatki, 51, 636

Add-in Manager, 653aplikacja nadrzędna, 638COM, 640Connect, 640, 645, 659CreateToolWindow2, 659cykl życia, 645DTE.AddIns, 653IDTCommandTarget, 645IDTExtensibility2, 645, 646IDTToolsOptionsPage, 662, 663język, 638kod wygenerowany przez kreator dodatków, 640kreator dodatków, 637menedżer dodatków, 653obiektowy model automatyzacji, 653obsługa zdarzeń, 645okno About, 639OnAddInsUpdate, 647OnBeginShutdown, 647OnConnection, 648OnDisconnection, 650OnStartupComplete, 651opcje, 639opisywanie dodatków, 639paleta do wybierania kolorów, 654parametry dodatku, 637programowe zarządzanie dodatkami, 653projekt, 637przechwytywanie zdarzeń kontrolki

użytkownika, 661

reagowanie na polecenia, 651rejestrowanie strony Options, 665sekwencja zdarzeń w czasie usuwania, 646sekwencja zdarzeń w czasie wczytywania, 646strona Options, 662struktura dodatków, 645tworzenie interfejsu użytkownika, 662udostępnianie ustawień dodatku, 662wyświetlanie kontrolki użytkownika, 660wyświetlanie okna narzędzi, 660zarządzanie dodatkami, 653

dodatki dla pakietu Office, 1136modyfikacja wstążki, 1137

dodawaniebaza danych, 944dane do pamięci podręcznej, 1151elementy do diagramu klasy, 294elementy do wstążki, 1139fragmenty kodu do środowiska Visual Studio, 388klawisze skrótu, 607kontrolki, 273, 282, 284kontrolki do strony internetowej, 738kontrolki użytkownika do strony, 803logika biznesowa do wygenerowanego kodu, 158materiały do lokalnego systemu pomocy, 313metody do istniejących klas, 157projekt do rozwiązania, 194referencje, 730strony internetowe do witryny, 737tekst, 599zakładki, 247zależności, 689

dokowanie, 106, 108, 834dokumentacja środowiska Visual Studio, 314dokumenty, 51, 592

CSS, 270DTD, 264HTML, 288obiektowy model automatyzacji, 592WSDL, 1029XDR, 264XSD, 265XSLT, 269

dokumenty tekstowe, 593dodawanie tekstu, 599modyfikacja, 595, 600punkt edycji, 599wstawianie komentarzy, 601zmiana pozycji obiektu EditPoint, 600

1221

Skorowidz

dokumenty XML, 165, 264edycja, 264generowanie szablonów, 265uruchamianie szablonu XSLT, 269

dołączanie debugera do usług WCF, 515dopasowywanie nawiasów, 391dopasowywanie strukturalne, 690dopracowywanie poleceń SQL, 953dostawcy obrazów dla kontrolek, 850dostawcy rozszerzeń, 837dostęp do danych, 67, 160, 909dostęp do kodu projektu, 569dostęp do okien, 572dostęp do pamięci podręcznej danych, 1152dostęp do paneli okna tekstu, 577dostępność, 733dostępność składowych, 118dostosowywanie

czcionki, 110edytory, 100mechanizm IntelliSense, 392odwzorowanie źródła danych, 980paski narzędzi, 95wstążka, 53wygląd kontrolek WPF, 878

double, 130, 132, 133Double, 130DoWhile, 1083, 1084DropDownList, 792DropDownListContentControl, 1149drukowanie kodu, 262

czcionki, 262kolory, 262Print, 262

DTD, 265DTE, 561, 562, 564

ActiveWindow, 573AddIns, 653Commands, 605Debugger, 608Documents, 592Events, 608ExecuteCommand, 606MainWindow, 572ToolWindows, 573, 660Windows, 573

DTE2, 561, 564ActiveDocument, 564ActiveSolutionProjects, 564ActiveWindow, 564

CommandBars, 564Commands, 564Debugger, 564Documents, 564Events, 564ExecuteCommand, 565LaunchWizard, 565MainWindow, 565Quit, 565Solution, 564StatusBar, 565ToolWindows, 565WindowConfigurations, 565

DTEEvents, 628OnMacrosRuntimeReset, 628OnStartupComplete, 628

duck typing, 690dynamic, 167Dynamic Data Entities Web Site, 717Dynamic Data Field, 727Dynamic Data Linq to SQL, 717Dynamic Data Linq to SQL Web Site, 717DynamicObject, 169

TryCreateInstance, 169TryGetMember, 169TryInvokeMember, 169TrySetMember, 169

dynamiczne aplikacje, 688dynamiczne obiekty, 167dynamiczne typy danych, 167dziedziczenie, 121, 296

przesłanianie operacji, 122składowe wirtualne, 122wywołanie metody z klasy bazowej, 122

dzielenie podzespołów na wiele plików, 164

E

ECMA, 41ECMAScript, 905Edit, 89Edit and Continue, 511Edit breakpoint labels, 499Edit DataSet with Designer, 984Editor Classifier, 695Editor Margin, 696Editor Text Adornment, 697Editor Viewport Adornment, 698EditorClassifier1, 695EditorClassifier1Format, 695

1222

Skorowidz

EditorMargin1, 696EditorZone, 779, 786EditPoint, 562, 596, 597, 599, 600, 601

InsertFromFile, 600EditPoint2, 597

składowe, 597EDM, 68, 69, 977, 1001edycja

arkusze stylów XSLT, 269dokumenty XML, 264model EDM, 1003

edycje środowiska Visual Studio 2010, 24, 31edytor arkuszy CSS, 270

definiowanie atrybutów arkuszy stylów, 271dodawanie zasad stylów, 271

edytor File System, 542edytor formularzy, 830, 831

paleta komponentów, 831edytor HTML Source Editor, 285

opcje formatowania kodu, 286tabele HTML, 286

edytor manifestów, 352edytor Registry, 543edytor środowiska Visual Studio, 692

dekoracje, 693formatowanie, 692IntelliSense, 693marginesy, 692mechanizmy obsługi myszy, 693mechanizmy obsługi upuszczania, 693opcje, 693rodzaje zawartości, 692suwaki, 692tagi, 693typy klasyfikacyjne, 692

edytor XML, 264edytory kodu, 98

Code Definition, 262edytor języka C#, 98edytor języka SQL, 956, 957edytor języka Visual Basic, 99inteligentne znaczniki, 373

edytory tekstu, 98, 236aktywne odnośniki, 365diagnozowanie, 258dostosowywanie, 100drukowanie kodu, 262elementy okna, 243IntelliSense, 363, 375

kolorowanie składni, 365konfiguracja punktów przerwania, 259kontrola wykonywania kodu, 260margines wyboru, 245margines ze wskazówkami, 244narzędzia pomocnicze, 364nawigowanie po kodzie, 246numerowanie wierszy, 246obszar wirtualny, 237Options, 238otwieranie edytora, 241panel kodu, 244pisanie kodu, 240, 241przeszukiwanie dokumentów, 249schematy kodu, 367śledzenie zmian, 364ustawianie punktów przerwania, 258wirtualne odstępy, 239wskazówki dotyczące problemów, 364wyszukiwanie przyrostowe, 257zakładki, 247zawijanie wierszy, 237, 239zaznaczanie tekstu, 237

EF, 1001egzemplarz klasy, 131eksplorator szablonów, 266eksportowanie

moduł makra, 618szablony, 333ustawienia, 82

ElementHost, 1143ElementHost.Child, 1143elementy projektów, 203elementy rozwiązania, 188elementy XML, 164Else, 136Empty Web Site, 717EmptyResult, 808Enable Event Handling Code, 629Enable Virtual Space, 238Enable Windows Azure Tools, 1161EnableClientScript, 793Encapsulate Field, 441, 465End If, 136End Sub, 117Enforce Foreign Key Constraint, 950Entity, 68Entity Data Model, 68, 69Entity Data Model Designer, 1002

1223

Skorowidz

Entity Framework, 1001aktualizacja danych w modelu EDM, 1007graficzny widok modelu pojęciowego, 1003kierowanie zapytań do modelu EDM, 1006konfiguracja modelu EDM, 1002Mapping Details, 1005Model Browser, 1004model EDM, 1001model fizyczny, 1004model pojęciowy, 1003modyfikacja modelu EDM, 1002odwzorowanie między modelami, 1005odwzorowanie obiektów na niestandardowe

funkcje, 1005okno projektowe modelu EDM, 1003projekt, 1001tabele, 1001zapytania, 1007zapytania LINQ, 1006

EntityDataSource, 800EntityServices, 1025, 1045enum, 120Enum, 121EnvDTE, 561EnvDTE.IDTWizard, 677EnvDTE100, 561EnvDTE80, 561EnvDTE90, 561EnvDTE90a, 561EnvironmentEvents, 623, 625, 627Error Handling, 1086Error List, 623etapy diagnozowania, 469etykiety, 274etykiety punktów przerwania, 499event, 147EventHandler, 147, 149Events, 562, 608Excel, 1147Excel 2007 Workbook, 1136, 1147Excel 2010, 51Exception Assistant, 476ExceptionGroups, 562Exceptions, 474, 483, 486Execute, 681, 1077ExecuteCommand, 606ExecuteOption, 652Existing Style Sheet, 761ExistsInCollection<T>, 1087ExpandAll, 621

ExpandCollapseNodes, 621ExpectedException, 416, 422Explicit naming, 373Export DataTips, 483, 486Export File, 618Expression Blend, 40, 48, 61, 62Expression Design, 40Expression Encoder, 40Expression Media, 40Expression Studio, 40Expression Web, 40ext_cm_AfterStartup, 648ext_cm_CommandLine, 648ext_cm_External, 648ext_cm_Solution, 648ext_cm_Startup, 648ext_cm_UISetup, 648ext_ConnectMode, 648ext_DisconnectMode, 650ext_dm_HostShutdown, 650ext_dm_SolutionClosed, 650ext_dm_UISetupComplete, 650ext_dm_UserClosed, 650extender providers, 837Extender Wizard, 920Extensible Application Markup Language, 53Extensible Markup Language, 1016Extension Manager, 341, 699

tryb działania, 700extension method, 157ExtensionAttribute, 157Extract Interface, 441, 459

wyodrębnianie interfejsów, 459Extract Method, 441, 451

F

F#, 114Fail, 420false, 138FastCGI, 1167File, 85, 89File Breakpoint, 501, 502File System, 542File Transfer Protocol, 722File Types, 544FileResult, 808FileUpload, 792FilteredTextBoxExtender, 918filtry ISAPI, 721

1224

Skorowidz

filtry punktów przerwania, 502Finally, 146, 147Find, 562Find and Replace, 249, 253

Choose Search Folders, 253Find In Files, 253Find Results, 254Find Symbol, 256Find Symbol Results, 256podmienianie tekstu w plikach, 253, 255Replace in Files, 255tworzenie grup przeszukiwanych katalogów, 253wyniki wyszukiwania, 254wyszukiwanie symboli, 256wyszukiwanie tekstu w plikach, 253

Find Results, 254Find Symbol, 249FK, 950float, 130, 132Floating, 108Flowchart, 73, 1095, 1113, 1114FlowDecision, 1095FlowDocumentReader, 862FlowLayoutPanel, 836, 837FlowSwitch<T>, 1095FolderBrowserDialog, 895Font, 840for, 139For…Each, 139For…Next, 139fora społeczności MSDN, 315

dyskusja, 319ikony wątków, 322nawigowanie po forach i wątkach, 320otwieranie nowego wątku, 318powiadomienia dotyczące własnych wątków, 321Windows Live, 318wyszukiwanie odpowiedzi na pytania, 316

foreach, 139ForEach, 1083, 1084ForeColor, 828, 840foreign key, 950Foreign Key Relationship, 948, 950Form, 823, 835

BackgroundImage, 828formalny opis usługi sieciowej, 1029Format, 92formatowanie kodu, 101Forms Designer, 830

FormStartPositon, 827formularz startowy, 826formularze sieciowe, 282, 737, 808, 809

Apply Styles, 287dodawanie kontrolek, 284Manage Styles, 287modyfikacja znaczników, 285projekt, 283projektowanie aplikacji, 283rozmieszczanie kontrolek, 284sposób wyświetlania, 741sprawdzanie poprawności kodu, 288tworzenie, 285wygląd strony w przeglądarce, 288zarządzanie stylami, 287zgodność ze standardami, 289

formularze Windows, 44, 46, 62, 271, 274, 822BackColor, 828cykl życia, 829dodawanie kontrolek, 273, 274, 830dostosowywanie wyglądu formularza, 273dziedziczenie wyglądu innego formularza, 827ForeColor, 828Forms Designer, 830formularz startowy, 826głębokość kontrolek, 846klasa formularza, 826kolejność przechodzenia po kontrolkach, 840kolory, 828komponenty, 830kontenery, 836kontrola automatycznego skalowania, 835kontrolki, 830kontrolki kontenerowe, 835kultura, 823lokalizacja, 823menu, 842okno projektowe, 373Opacity, 828pasek narzędzi, 844pasek statusu, 847pisanie kodu, 277położenie początkowe, 827pozycjonowanie kontrolek, 831projekt, 826projektowanie, 822przezroczystość, 828rozmieszczanie kontrolek, 275standardy UI, 824StartPosition, 827

1225

Skorowidz

tworzenie, 826tworzenie procedury obsługi zdarzeń, 829układ kontrolek, 831użytkownik końcowy, 823wiązanie danych, 982właściwości, 827wygląd, 828wyświetlanie danych, 849zdarzenia, 827, 828, 829

formularze WinForm, 44formularze WPF, 48, 49, 102, 281, 310

dodawanie kontrolek, 282projektowanie, 62

FormView, 800, 989FPSE, 553fragmenty kodu, 380

Code Snippets Manager, 389dodawanie fragmentów kodu do środowiska

Visual Studio, 388format XML fragmentów kodu, 385funkcje, 388okno narzędzi, 390otaczanie kodu, 383Surround With, 383tworzenie własnych fragmentów kodu, 385udostępnianie przez sieć, 390węzły XML, 386wstawianie, 381

FrameworkElement, 882FrontPage Server Extensions, 553FTP, 722Func, 175Function, 117, 134, 162funkcje anonimowe, 162funkcje definiowane przez użytkownika, 961funkcje pakietu Office, 1131funkcje wewnątrzwierszowe, 163

G

GAC, 729galeria środowiska Visual Studio, 331GDI+, 176Generate From Usage, 373, 374GenerateSwitchCases(), 388Generic Handler, 727generowanie

kod, 158schematy kodu, 367szablony XML, 265

szkielety metod, 457testy jednostek ASP.NET, 429testy na podstawie istniejącego kodu, 402związane kontrolki Windows Forms, 976

GetClassificationSpans, 695GetElement, 169Global.asax, 716, 744, 819głębokość kontrolek na formularzu, 846główną przestrzeń nazw, 127graficzne okna projektowe, 102graficzne wyróżniki tekstu, 697Grid, 702, 871, 874, 885, 888

okna dialogowe, 875Grid.ColumnDefinitions, 874GridSize, 275GridView, 801, 808, 911, 989, 990

AutoGenerateDeleteButton, 992AutoGenerateEditButton, 992uaktualnianie danych, 992źródło danych, 990

GUID, 188, 335, 661

H

HACK, 394Hashtable, 143, 170Help, 93, 312Help Library Manager, 312hermetyzacja pól, 465Hit Count, 502HorizontalAlignment, 886host, 1042, 1049host procesu, 1064hosting, 1158hosting usług WCF, 1058

hosting samodzielny, 1058IIS, 1059usługi systemu Windows, 1059WAS, 1059

HostType, 416, 428HoverMenuExtender, 918HTML Designer, 751HTML Page, 728HTML Source Editor, 285HTMLWindow, 562HTMLWindow3, 562HTTP, 74, 75, 1016, 1031Hypertext Transfer Protocol, 1016

1226

Skorowidz

I

IClassifier, 695IComponent, 289Icon, 206Icons Gallery Add-In, 1140ICustomerProfile, 1045IDE, 88, 969IDE Macros, 616identyfikator GUID, 661identyfikator skórki, 775IDictionary, 1074, 1081IDTCommandTarget, 645IDTCommandTarget.Exec, 651IDTExtensibility2, 636, 645, 646

OnAddInsUpdate, 646, 647OnBeginShutdown, 646, 647OnConnection, 646, 648OnDisconnection, 646, 650OnStartupComplete, 646, 651

IDTToolsOptionsPage, 662, 683składowe, 663

IDTWizard, 677, 679, 680IEnumerable, 161IEnumerable<T>, 174IEnumerator<T>, 174if, 136If…Then…Else, 136Ignore, 416IIS, 718, 720, 1059ikona podzespołu, 206ikony punktów przerwania, 496Image, 705, 792, 888ImageList, 47, 850imageMso, 1140Images Collection Editor, 851Immediate, 476, 482, 485implementacja interfejsu, 125, 297

inteligentne znaczniki, 374Implements, 125Implicit naming, 373implicit typing, 151Import and Export Settings, 80, 81, 82, 303

wybór ustawień, 81Import DataTips, 483, 486importowanie przestrzeni nazw, 128importowanie ustawień, 82imports, 128in, 174Inconclusive, 420Incremental Search, 257

indeksy, 946Index Columns, 946Indexes/Keys, 946informacje o parametrach, 379Inherited Form, 827Inherits, 121inicjator obiektów, 153inicjowanie kolekcji, 155inicjowanie obiektów zdarzeń, 628Init, 743InitComplete, 743InitializeCorrelation, 1090Inline Function, 961INSERT, 954, 955Insert Breakpoint, 478, 495Insert Snippet, 381Insert Tracepoint, 504instalacja

aplikacje XBAP, 929ClickOnce, 208pakiet SDK, 349szablony Visual Studio, 331, 339udostępniane zasoby, 330usługi w chmurze technologii Azure, 66usługi WCF, 1058

instalacja środowiska Visual Studio 2010, 78wybór języka, 78

instalator systemu Windows, 535, 539Custom Actions, 546dołączanie plików do pakietu instalacyjnego, 541dostosowanie wyglądu kreatora instalacji, 545File System, 542File Types, 544Launch Conditions, 546powiązania typów plików, 544projekt, 540publikowanie projektów, 539Registry, 543Setup Wizard, 540User Interface, 545warunki wstępne, 546wpisy w rejestrze, 543wyjątkowe wymagania związane z instalacją, 546

instrukcje SLQ, 909instrukcje Using, 380int, 130Integer, 130inteligentne operacje, 372inteligentne znaczniki, 372, 373

Generate From Usage, 373, 374generowanie, 373

1227

Skorowidz

implementacja interfejsu, 374refaktoryzacja, 442

IntelliSense, 285, 299, 363, 372, 375, 693Add New Line on Enter at End of Fully Typed

Word, 393Committed by Pressing the Space Bar, 393Committed by Typing the Following

Characters, 393Complete Word, 375dopasowywanie nawiasów, 391dostosowywanie mechanizmu, 392fragmenty kodu, 380kod szablonowy, 380List Members, 378lista uzupełniania, 375okno z informacjami o parametrach, 379okno z informacjami podręcznymi, 377okno z listą składowych, 378otaczające fragmenty kodu, 383otaczanie kodu fragmentami, 383Parameter Info, 379Place Code Snippets in Completion Lists, 393Place Keywords in Completion Lists, 393porządkowanie instrukcji Using, 380Pre-select Most Recently Used Members, 393Quick Info, 377Remove and Sort, 380Remove Unused Usings, 380Show Completion List After a Character

Is Typed, 393Sort Usings, 380tryb pierwszeństwa tekstu, 377tryb standardowy, 377uzupełnianie słów, 375

interakcja z oknami, 573interface, 125Interface, 125interfejs użytkownika, 746, 822

kultura, 823lokalizacja, 823niepisane standardy, 824planowanie, 825początkowy plan układu, 825projektowanie, 822standardy, 824użytkownik końcowy, 823wstępny projekt, 825

interfejsy, 124, 296definiowanie, 125implementacja, 125, 297refaktoryzacja, 459

Internal, 119InternalsVisibleToAttribute, 164InvokeMethod, 1085IronPython, 171IronRuby, 171Is, 135ISAPI, 721IsCached(), 1152IService1.cs, 1044IsFalse, 420IsInstanceOfType, 420IsNot, 135IsNotInstanceOfType, 420IsNotNull, 420IsNull, 420IsTrue, 420Item Collection Editor, 848itemname, 335iteratory, 139

J

JavaScript, 59, 526, 793, 905jednostki eksportowane, 690język programowania, 40, 114

ASP, 165CSS, 757F#, 114JavaScript, 59język skryptowy, 41T-SQL, 956UML, 297VBA, 1130WSDL, 1012, 1029XAML, 44, 48, 53, 61, 863XHTML, 55

JOIN, 954jQuery, 53, 716JScript 8.0, 41JScript File, 728JsonResult, 808Just-In-Time, 487

K

kanały RSS, 306, 308kaskadowe arkusze stylów, 270katalog, 691

katalog folderów, 691katalog podzespołów, 691katalog typów, 691

1228

Skorowidz

katalogi ASP.NET, 726katalogi projektu, 203katalogi rozwiązania, 190katalogi zakładek, 248Key, 156kierowanie zapytań do modelu EDM, 1006klasy, 115

Action, 1154Activity, 1077Application, 863Array, 142ArrayList, 143asocjacja, 297AssemblyCatalog, 691Assert, 420atrybuty, 145Binding, 881BitmapSource, 891CachedDataHostItem, 1153CachedDataItem, 1153CodeActivity, 1063, 1075, 1077CollectionAssert, 421CollectionBase, 143, 144Connect, 645, 659ContainerControl, 835Control, 290, 830, 863ControlTemplate, 879Convert, 133DataContext, 882DataGridViewColumn, 983DataServiceContext, 1177DataTemplate, 893Debugger, 260definiowanie, 115definiowanie relacji między klasami, 296diagram, 293DirectoryCatalog, 691DispatcherObject, 863DocumentReader, 862dostępność składowych, 118DTEEvents, 628DynamicObject, 169dziedziczenie, 121, 296EventHandler, 149FlowDocumentReader, 862FlowLayoutPanel, 836, 837FolderBrowserDialog, 895Form, 823implementacja interfejsu, 125interfejsy, 296

klasy anonimowe, 156klasy bazowe, 121klasy częściowe, 158, 738klasy kolekcji, 143klasy LINQ, 1000klasy LINQ to SQL, 996klasy ogólne, 174klasy statyczne, 120konstruktory, 118, 154kontrola dostępu do danych, 116MessageMapper, 258metody, 117NativeActivity, 1063, 1077ObjectQuery, 1007Panel, 836pola, 115poziom dostępu do klasy, 118przeciążanie składowych, 123przesłanianie operacji, 122ServerDocument, 1152, 1153składowe statyczne, 120składowe wirtualne, 122SmartTag, 1153SplitContainer, 837StringAssert, 422Style, 878TableLayoutPanel, 836TableServiceContext, 1177TestContext, 413ToolStrip, 844ToolStripContainer, 838ToolStripItem, 841, 844ToolTip, 841Tuple, 144tworzenie, 293TypeCatalog, 691ukrywanie składowych, 123UrlRoutingModule, 807Visual, 863, 879WebService, 1027WebServiceAttribute, 1027WizardDialog, 681właściwości, 115WorkflowApplication, 1074WorkflowInvoker, 1074WorkflowServiceHost, 1075wyświetlanie składowych, 294

klasy atrybutów testów, 415klasy testów, 400, 406klawisze skrótu, 607

1229

Skorowidz

klient sieciowy, 53klient SOAP, 1037klient WCF, 1042klucz główny, 945, 950klucze obce, 946, 948, 950kod HTML, 285kod LINQ, 998kod SQL, 953kod szablonowy, 380kod XAML, 48, 280kod XML, 165kodowanie, 469kolejki, 1168kolejkowanie komunikatów, 228kolekcje, 141, 143

ArrayList, 143CollectionBase, 143definiowanie, 155Hashtable, 143inicjowanie, 155Queue, 143SortedList, 143Stack, 143

kolekcje ogólne, 144wariancja, 174

kolorowanie składni, 365kompilacja, 469

aplikacje ASP.NET, 731procedury składowane, 974

kompilator, 364komponenty, 289, 830

pisanie kodu, 291tworzenie, 290

komponenty COM, 661kompozycje, 770

App_Themes, 771stosowanie, 773tworzenie, 771

komunikacja P2P, 176komunikacja z pamięcią trwałą, 1118komunikaty SOAP, 1031komunikaty XML, 165konfiguracja atrybutów testów jednostek, 431

DataSource, 431definiowanie połączenia, 431DeploymentItem, 431

konfiguracja chmury, 65konfiguracja kompilacji, 193, 206konfiguracja punktów przerwania, 259konfiguracja środowiska programistycznego, 79

konfiguracja usług WCF, 76, 1050konfiguracja uwierzytelniania użytkowników, 796konflikty nazw, 128konstruktory, 118, 154konsumowanie usługi sieciowej ASP.NET, 1033konsumowanie usługi WCF, 74, 76, 1055kontekst danych, 882kontener łączący, 690kontenery, 836

FlowLayoutPanel, 836, 837SplitContainer, 836, 837StatusStrip, 847TableLayoutPanel, 836ToolStripContainer, 838

kontrakt usługi, 1042kontrakty, 690kontrawariancja, 173kontrola dostępu do danych, 116kontrola wersji, 37kontrola wykonywania kodu, 260kontroler, 806, 807kontrolki, 273, 282, 289, 738, 823, 830

Canvas, 871chmurki, 841ContentPlaceHolder, 766DataGridView, 852, 980DataList, 990DateTimePicker, 980, 983DetailsView, 989DockPanel, 872dokowanie, 834dziedziczenie po istniejącej kontrolce, 853formularze Windows, 1147FormView, 989Grid, 874GridView, 989, 990Image, 888ImageList, 850kolejność przechodzenia, 840kontenery, 836kontrola automatycznego skalowania, 835kontrolki ASP.NET Ajax Library, 915kontrolki danych, 989kontrolki kontenerowe, 835kontrolki sieciowe, 989kontrolki Silverlight, 936kontrolki WPF, 705kontrolki XAML, 49kontrolki złożone, 290kotwiczenie, 833

1230

Skorowidz

kontrolkiListBox, 886menu, 842MenuStrip, 46, 841, 842, 843modyfikacja atrybutów, 277Panel, 46pasek narzędzi, 844pasek statusu, 847pozycjonowanie, 749, 831Repeater, 989rozmieszczanie, 275SplitContainer, 46, 849Splitter, 837StackPanel, 876StatusBar, 847StatusStrip, 46, 841style wizualne, 840Timer, 274ToolStrip, 841, 844, 847ToolStripItem, 841, 844TreeView, 849tworzenie, 290tworzenie kontrolek, 853układ, 831UpdatePanel, 58UpdateProgress, 58wiązanie danych, 974wskazówki, 841wygląd, 840zachowanie, 840zmiana rozmiaru, 277

kontrolki Ajax Control Toolkit, 917Accordion, 917AlwaysVisibleControlExtender, 917AutoCompleteExtender, 917CalendarExtender, 918, 919CascadingDropDown, 918CollapsiblePanelExtender, 917ConfirmButtonExtender, 918, 921FilteredTextBoxExtender, 918HoverMenuExtender, 918ListSearchExtender, 918MaskedEditExtender, 918ModalPopupExtender, 918PasswordStrength, 918PopupControlExtender, 918ReorderList, 918SliderExtender, 918SlideShowExtender, 919stosowanie kontrolek, 919

TabContainer, 919TextBoxWatermarkExtender, 919

kontrolki ASP.NET, 788AccessDataSource, 800adaptacyjne generowanie, 789Button, 792Calendar, 792ChangePassword, 796Chart, 800, 801CheckBox, 792CompareValidator, 794CreateUserWizard, 796CustomValidator, 794DataList, 800DataPager, 800DetailsView, 800DropDownList, 792EntityDataSource, 800FileUpload, 792FormView, 800GridView, 801Image, 792kontrolki danych, 799kontrolki do sprawdzania poprawności, 793kontrolki logowania, 795kontrolki nawigacyjne witryny, 798kontrolki standardowe, 792kontrolki użytkownika, 801kontrolki walidacyjne, 793, 794Label, 792LinqDataSource, 800ListBox, 792ListView, 801Literal, 792Login, 795LoginName, 796LoginStatus, 796LoginView, 795model obsługi zdarzeń, 789MultiView, 792ObjectDataSource, 800Panel, 792PasswordRecovery, 795QueryExtender, 801RadioButton, 792RangeValidator, 794RegularExpressionValidator, 793, 794Repeater, 801RequiredFieldValidator, 794SiteMapDataSource, 800

1231

Skorowidz

SiteMapPath, 798skórki, 790sprawdzanie poprawności danych, 790, 793SqlDataSource, 800style, 790Table, 792TextBox, 792układ oparty na szablonach, 790ValidationSummary, 793, 794wiązanie danych, 790Wizard, 793wprowadzanie danych, 790wykrywanie przeglądarek, 789XML, 793XmlDataSource, 800zachowywanie stanu, 789zgodność ze standardem XHTML, 789

kontrolki ASP.NET Ajax, 905ScriptManager, 905, 906ScriptManagerProxy, 906Timer, 906UpdatePanel, 906UpdateProgress, 906, 913

kontrolki niestandardowe, 290, 805, 853, 857kontrolki „rysowane przez programistę”, 857tworzenie, 857

kontrolki użytkownika, 290, 853, 854dodawanie kontrolek, 855projekt, 854projektowanie, 854przechwytywanie zdarzeń, 661tworzenie, 655zagnieżdżanie kontrolek użytkownika, 855

kontrolki użytkownika ASP.NET, 801dodawanie kontrolki do strony, 803projekt, 802rejestrowanie kontrolki na stronie, 804tworzenie, 802Web User Control, 802

kontrolki Web Part, 776CatalogZone, 779EditorZone, 779, 786LayoutEditorPart, 786strefy strony, 777style, 778ustawienia kontrolek, 788WebPartManager, 777, 779WebPartZone, 777, 779zarządzanie układem strony, 777

kontrolki źródła danych, 993AccessDataSource, 993ObjectDataSource, 993SiteMapDataSource, 993SqlDataSource, 993XMLDataSource, 993

kontrolki-hosty, 1148kontynuowanie wykonywania kodu, 493konwersja typów, 131kończenie sesji diagnostycznej, 493kotwiczenie, 833kowariancja, 173kreator dodatków, 637, 677kreator eksportowania szablonów, 337kreator modelu EDM, 69kreatory, 677

Add New Item, 680ContextParams, 678Execute, 681formularz, 682identyfikator kreatora, 679IDTToolsOptionsPage, 683IDTWizard, 677, 679, 680numer wersji, 679plik szablonu, 682pliki .vsdir, 679, 680pliki .vsz, 679struktura kreatorów, 677tworzenie, 680tworzenie okna dialogowego, 681tworzenie plików .vsz i .vsdir, 685uruchamianie kreatora, 683WizardDialog, 681wizardResult, 679

kroczenie przez kod, 480krotki, 144

dodawanie elementów, 144tworzenie, 144

kultura, 823

L

Label, 274, 755, 792LabelInstructions, 768Language Integrated Query, 160Launch Conditions, 546Layout, 102LayoutEditorPart, 786LayoutMode, 275Left, 833

1232

Skorowidz

liczba dojść do punktu przerwania, 502liczniki wydajności, 228LIKE, 909LineDown, 601LineUp, 601LinkedWindows, 587LINQ, 156, 160, 161, 176, 816, 994, 998

atrybuty, 999klasy, 1000odwzorowanie O/R, 995podsystemy, 995stosowanie obiektów LINQ, 1000wyrażenia lambda, 162, 163zapytania, 994

LINQ to Objects, 995LINQ to SQL, 717, 728, 995, 996LINQ to SQL Classes, 728, 996LINQ to XML, 995LinqDataSource, 800List Members, 377, 378lista składowych, 378lista zadań do wykonania, 393ListBox, 792, 885, 886ListObject, 1149ListSearchExtender, 918ListView, 47, 801, 850Literal, 792Load, 743Load Macro Project, 619, 629Load Metadata File, 402Load Test Virtual User Pack, 39LoadComplete, 743local type inference, 151Local.testsettings, 400Locals, 476, 485, 505, 506logika biznesowa, 158Login, 795Login.aspx, 796LoginName, 796LoginStatus, 796LoginView, 795logowanie, 795

uwierzytelnianie użytkowników, 796lokalizacja, 823lokalizacja kodu źródłowego na potrzeby

diagnozowania, 192lokalna pamięć podręczna dla bazy danych, 71long, 130Long, 130

Ł

łańcuch połączenia, 973łańcuchy znaków, 130łączenie łańcuchów znaków, 135łączenie okien narzędzi, 587

M

machinename, 335Macro Explorer, 614, 617, 619Macros, 616, 619

diagnozowanie makra, 623dodawanie projektów, 619obsługa zdarzeń, 623pisanie makr, 620wywoływanie makr, 629

Main, 242, 367MakeCert.exe, 349MakeZipExe.exe, 349makra, 345, 612

diagnozowanie, 623dodawanie deklaracji nowych zdarzeń, 627dodawanie projektów, 619dostęp do okna, 620dostęp do zdarzenia, 627DTEEvents, 628DTEEvents.OnMacrosRuntimeReset, 628DTEEvents.OnStartupComplete, 628edytor kodu, 621eksportowanie modułu, 618EnvironmentEvents, 623, 625format przechowywania, 618inicjowanie obiektów zdarzeń, 628kod makra, 615Macro Explorer, 614Macros, 616makra tymczasowe, 614, 617metody obsługi zdarzeń, 626modyfikacja kodu, 621obsługa zdarzeń, 623parametry, 632pisanie makr, 616, 620pliki .vsmacros, 619projekt, 617rejestrowanie, 613skróty klawiaturowe, 631tworzenie, 613uruchamianie, 613, 614, 629WindowHiding, 627

1233

Skorowidz

współużytkowanie makr, 618wstrzymanie rejestrowania, 613wyświetlanie komunikatów, 615zarządzanie makrami, 614zmiana formatu przechowywania projektu

makr, 619zmiana rozmiaru IDE, 632

Manage Styles, 287, 288, 758, 760, 761, 762Managed Execution Framework, 23Managed Extensibility Framework, 688manifest VSIX, 352, 353manipulowanie obrazami, 895manipulowanie zakładkami w dokumencie, 594Manual, 828mapa witryny, 728, 798, 993Mapping Details, 69, 1002marginesy, 696MaskedEditExtender, 918Master, 768Master Page, 56, 727master pages, 765mechanizm DAC, 969mechanizm generowania kodu, 158mechanizm IntelliSense, 363, 375mechanizm nawigowania po znacznikach, 370mechanizm obsługi korelowania, 1112mechanizm szeregowania zadań, 523mechanizm wstawiania fragmentów kodu, 381mechanizm wyszukiwania przyrostowego, 577mechanizmy języka, 150mechanizmy obsługi myszy, 693mechanizmy obsługi upuszczania, 693MEF, 23, 688

AggregateCatalog, 691aktywowanie, 690aplikacje, 690aplikacje nadrzędne, 689architektura platformy, 689AssemblyCatalog, 691CompositionContainer, 691części, 690, 695dekoracje, 697, 698DirectoryCatalog, 691dodawanie zależności, 689dopasowywanie strukturalne, 690Editor Margin, 696Editor Text Adornment, 697Editor Viewport Adornment, 698edytor środowiska Visual Studio, 691, 692Extension Manager, 699jednostki eksportowane, 690, 692

jednostki importowane, 690katalog, 691katalog folderów, 691katalog podzespołów, 691katalog typów, 691kontener łączący, 690kontrakty, 690menedżer rozszerzeń, 699model programowania, 689określanie nazw, 690projekt dekoracji, 702punkty dołączania rozszerzeń do edytora, 692reguły działania, 689rozszerzalne platformy, 689rozszerzenia, 689stosowanie, 690tworzenie rozszerzenia edytora, 701TypeCatalog, 691

Memory, 485menedżer dodatków, 653menu, 89, 842

Build, 91Data, 92Debug, 91, 482Edit, 89elementy menu, 844File, 85, 89Format, 92główne, 842Help, 93, 312MenuStrip, 842, 843Project, 89, 91Refactor, 89, 90, 442Table, 92Test, 93, 401Tools, 92View, 90Website, 90Window, 93

MenuItem, 888MenuStrip, 46, 841, 842, 843MessageMapper, 258Method Name, 244metody, 117

definiowanie, 117, 298dodawanie metod do istniejących klas, 157metody częściowe, 158przeciążanie, 123przesłanianie, 122refaktoryzacja, 450

1234

Skorowidz

metody dodatkowe, 157użycie, 158

metody sieciowe, 1015wywoływanie, 1032

metody usługi sieciowej, 1015MFC, 41Microsoft Excel, 1132Microsoft Expression, 39Microsoft Foundation Class, 41Microsoft InfoPath, 1132Microsoft Office, 63, 1130Microsoft Outlook, 1132Microsoft Patterns and Practices, 306Microsoft PowerPoint, 1132Microsoft Report Viewer, 717Microsoft Silverlight, 59Microsoft Solutions Framework (MSF)

for CMMI 5.0, 36Microsoft Word, 1130, 1132Microsoft.Office.Tools.Excel.SmartTag, 1153Microsoft.Office.Tools.Excel.Worksheet, 1147Microsoft.Office.Tools.SmartTagBase, 1153Microsoft.Office.Tools.Word.Document, 1147Microsoft.Office.Tools.Word.SmartTag, 1153Microsoft.VisualStudio.CoreUtility, 351Microsoft.VisualStudio.QualityTools.�UnitTestFramework, 400

Microsoft.VisualStudio.TestTools.UnitTesting, 413Microsoft.VisualStudio.Tools.Applications, 1152MIME, 931ModalPopupExtender, 918model, 806Model Browser, 1002, 1004model EDM, 68, 69, 977, 1001

zapytania, 1006model formularzy sieciowych, 809model MVC, 56model procesu, 72model projektowy, 68model przetwarzania żądań w aplikacjach ASP.NET

MVC, 807model źródła danych, 68Model-View-Controller, 56, 714model–widok–kontroler, 56Modify Style, 758, 759Modules, 485modyfikacja

dokumenty tekstowe, 595kod makra, 621manifest VSIX, 352

model EDM, 1002panel zadań pakietu Office, 1141plik .vstemplate, 338strona startowa, 310style CSS, 287, 764tekst, 600wstążka, 1137zapytania dla źródła danych, 985znaczniki HTML, 285

monitor zdalnego diagnozowania, 513MOSS, 776MSDN, 35, 314MSDN Forums, 315MSF for Agile 5.0, 36MSI, 341MSMQ, 1014msvsmon.exe, 513MultiView, 792MustInherit, 121MVC, 56, 714, 805

N

NamedRange, 1149namespace, 127Namespace, 127narzędzia, 36

narzędzia pomocnicze edytorów tekstu, 364nawigowanie po kodzie, 246refaktoryzacja, 441tworzenie stylów, 756VSTO, 1130

NativeActivity, 1063, 1077nawiasy, 391nawigacja, 367nawigacja po środowisku IDE, 88nawigowanie po kodzie, 246

Call Hierarchy, 248numerowanie wierszy, 246zakładki, 247

nawigowanie po znacznikach, 370Document Outline, 371

nazwy, 127nazywanie elementów, 373NetCF, 45new, 123, 141New, 156New Breakpoint, 483, 486, 495New Cloud Service Project, 64, 1166, 1170, 1175New Data Breakpoint, 483

1235

Skorowidz

New File, 241New Line, 192New Macro Project, 619New Project, 43, 50, 54, 79, 84, 86, 183, 184, 194, 272,

330, 334, 962, 1135Online Templates, 328

New Query, 952New Service Endpoint Element Wizard, 1051, 1052New Style, 761New Style Sheet, 761New Test, 401New Test List, 436New Web Site, 197, 283, 715niejawne określanie typu zmiennych, 151

zmienne lokalne, 153niestandardowa strona startowa, 310Not, 136NotInheritable, 121numerowanie wierszy, 246NUnit, 398

O

O/R Designer, 996dodawanie jednostek bazy danych, 996klasy danych, 997klasy LINQ to SQL, 996kod LINQ, 998nazwy jednostek, 999obszar projektowy, 997tabele, 997

obiektowy model automatyzacji, 560BuildEvents, 609CodeClass, 569CodeElement, 569CodeElements, 569, 570Command, 605Command Window, 583CommandBar, 588, 589, 590CommandBarControl, 589Commands, 605CommandWindow, 578, 583debuger, 608Debugger, 608Document, 592Documents, 592dodatki, 653dodawanie tekstu, 599dokumenty, 592dokumenty tekstowe, 593

dostęp do kodu projektu, 569dostęp do okien, 572dostęp do paneli okna tekstu, 577DTE, 561, 564DTE2, 561, 564EditPoint, 597, 599, 600EditPoint2, 597Events, 608hierarchia modelu obiektowego kodu, 570hierarchia rozwiązań i projektów, 566interakcja z oknami, 573kategorie automatyzacji, 563klasy, 570kontrola projektów wchodzących w skład

rozwiązania, 568manipulowanie tekstem, 599modyfikacja dokumentów tekstowych, 595modyfikacja tekstu, 600obiekty debugera, 608obiekty polecenia, 604okna, 572okna narzędzi, 578okna połączone, 586okna tekstowe, 576okno poleceń, 583okno Toolbox, 581Output, 584OutputWindow, 578, 584OutputWindowPane, 584, 585OutputWindowPanes, 584panele, 576, 577pasek poleceń, 588podzespoły, 561polecenia, 604Project, 565, 568projekty, 565przełączanie stanu ukończenia zadań, 580przestrzenie nazw, 570rozwiązania, 565Solution, 565, 567sprawdzanie kolekcji okien, 575Task List, 579TaskItem, 580TaskList, 578, 579, 580TextDocument, 593TextPane, 577TextSelection, 596TextWindow, 576ToolBox, 578, 581ToolBoxItem, 581

1236

Skorowidz

obiektowy model automatyzacjiToolBoxItems, 581ToolBoxTabs, 581typy modelu automatyzacji, 562ustawianie aktywnego okna, 575VirtualPoint, 597vsCMElement, 571wersje modelu obiektowego, 561Window, 572, 573Windows, 588wykonywanie poleceń, 606wykonywanie poleceń w oknie poleceń, 583wyszukiwanie przyrostowe, 577zadania, 579zdarzenia automatyzacji, 608

obiekty, 115, 130, 131, 153inicjator obiektów, 153konstruktory, 154tworzenie, 153

obiekty bazy danych, 970łańcuch połączenia, 973procedury składowane, 971

obiekty blob, 1168obiekty dynamiczne, 169

DynamicObject, 169stosowanie, 171tworzenie, 169

obiekty polecenia, 604obiekty statyczne, 120obiekty współużytkowane, 120object, 167Object, 152Object Browser, 229

Class View, 230Edit Custom Component Set, 230modyfikacja niestandardowego zbioru

komponentów, 229opcje zasięgu, 229panel z opisem, 231przeglądanie obiektów, 230Rename, 447zmiana nazw, 447zmiana zasięgu, 229

object initializer, 153ObjectDataSource, 800, 993ObjectQuery, 1007obrazy, 850obsługa danych, 67obsługa dodatków, 175obsługa korelowania, 1112

obsługa okien środowiska IDE, 109obsługa ruchów kursora nad paletą, 655obsługa transakcji, 1087obsługa wariancji, 174obsługa właściwości, 166obsługa wyjątków, 146obsługa zapytań LINQ, 162obsługa zbiorów danych, 67obsługa zdarzeń, 149, 623

dodatki, 645kontrolki wstążki, 1141usuwanie nieużywanych argumentów

z metod obsługi zdarzeń, 166obszary kodu, 368ODBC, 993oddzielanie projektu danych od modelu źródła

danych, 68odpowiedź SOAP, 1032odświeżanie częściowe, 912odwzorowanie O/R, 994odwzorowanie obiektowo-relacyjne, 993

LINQ, 994O/R Designer, 996

odwzorowywanie obiektów na modele bazy danych, 68odwzorowywanie źródeł danych na kontrolki, 978Office, 44, 50, 63, 1130ograniczenia, 946okna, 572

dostęp do okien, 572interakcja z oknami, 573

okna dialogowe, 681, 875, 895okna narzędzi, 103, 578okna połączone, 586okna projektowe, 102, 240

okno projektowe aplikacji sieciowych, 283okno projektowe formularzy Windows, 373okno projektowe HTML, 283, 372okno projektowe klas, 295

okna tekstowe, 576okno edytora kodu, 243okno projektowe procesów, 1067

powierzchnia projektowa procesu, 1067okno projektowe szablonów XML, 267

Content Model View, 268Graph View, 267, 268Start View, 267

okno projektowe WPF, 280, 282, 865kontrola rozmiaru, 868kontrolka przybliżania, 869okno właściwości, 868

1237

Skorowidz

określanie pozycji, 868panele projektowe, 866Properties, 868widok podzielony, 281XAML, 866zarządzanie panelami, 867

określanie nazw, 690OLE DB, 993OnAddInsUpdate, 646, 647OnAfterCreated, 683OnBeginShutdown, 646, 647OnConnection, 646, 648OnDisconnection, 646, 650One-Click Publishing, 554Online Templates, 328OnMacrosRuntimeReset, 629OnPaint, 857OnSizeChange, 705OnStartupComplete, 629, 646, 651Opacity, 828opcje diagnozowania, 487opcje uruchomieniowe, 84Open Folder in Windows Explorer, 1082Open Project, 84operacje inteligentne, 372OperationContract, 1045operatory, 133

łączenie, 135operatory arytmetyczne, 134operatory logiczne, 135, 136operatory warunkowe, 135, 136operatory zapytań, 161porównywanie, 134przypisanie, 133

opis usługi sieciowej, 1029opisywanie dodatków, 639opóźnione podpisywanie, 209Option Infer Off, 153Option Strict, 153Options, 84, 100, 101Options and Settings, 483, 486Or, 136Oracle, 993Order by, 163Ordered Test, 433OrElse, 136organizowanie testów, 434

lista testów, 436Test List Editor, 435Test View, 434

uruchamianie testów z listy testów, 437wyszukiwanie testów, 434, 435wyświetlanie wszystkich testów, 434

otaczające fragmenty kodu, 383otaczanie kodu fragmentami, 383otwarte aplikacje .NET, 688otwarte dokumenty, 592otwieranie edytora, 241otwieranie starszej aplikacji, 88out, 174outlining, 367Outlining, 369Outlook, 1144

tworzenie regionów formularzy, 1144wiązanie regionu z klasą komunikatu, 1146

Outlook Form Region, 1144Output, 482, 484, 494, 578, 584

wyświetlanie informacji, 586Output project, 403Output type, 206OutputWindow, 562, 578, 584OutputWindowPane, 584, 585

składowe, 585OutputWindowPanes, 584Overridable, 122override, 122, 123Overrides, 122, 123

P

P2P, 176Page, 428Page_Event, 744pakiet Office, 50pakiet Visual Studio SDK, 693pakiety, 341

plik VSContent, 342VSI, 342VSIX, 349

pakiety startowe, 333pakowanie rozszerzeń do plików VSIX, 349paleta do wybierania kolorów, 654paleta komponentów, 830PaletteControl, 661pamięć podręczna danych, 1133, 1150

CachedAttribute, 1151dodawanie danych, 1151dostęp do pamięci podręcznej danych, 1152wyspy danych, 1150, 1151

1238

Skorowidz

pamięć trwała, 1117Panel, 46, 792, 836panele, 576, 577, 838panele operacji pakietu Office, 1132, 1149

ActionsPane.StackOrder, 1150kontrola wyświetlania, 1150StackStyle, 1150tworzenie, 1149

panele WPF, 871panele zadań pakietu Office, 1132

dodawanie kontrolek, 1142modyfikacja, 1141

Parallel, 1084Parallel LINQ, 995Parallel Stacks, 484, 521, 523

pasek narzędzi, 522wątki, 521widok zadań, 523zadania, 523

Parallel Tasks, 484, 523, 525Location, 525lokalizacja zadania, 525

ParallelForEach, 1084Parameter Info, 379parametry, 379

refaktoryzacja, 462usuwanie parametrów, 462zmiana kolejności parametrów, 463

parametry dodatku, 637parametry projektu, 334parametry szablonów, 335Parse, 132Partial, 159partial class, 738pasek menu, 842, 843pasek narzędzi, 94, 844

Breakpoints, 480Debug, 482, 486dostosowywanie, 95ToolStrip, 844ToolStripItem, 844

pasek poleceń, 588kontrolki, 590

pasek statusu, 847edycja elementów StatusStrip, 848StatusBar, 847StatusStrip, 847

PasswordRecovery, 795PasswordStrength, 918Paste, 94

Persist, 1084, 1085pętle, 138

do…while, 140Do…While, 140for, 139For…Each, 139For…Next, 139foreach, 139until, 140Until, 140while, 140

Pick, 1084PictureBox, 47PictureContentControl, 1149pinning, 105pisanie kodu, 240, 241, 242, 277

kod komponentów, 291kod makr, 616, 620

pisanie testów jednostek, 405PK, 950PlainTextContentControl, 1149planowanie interfejsu użytkownika, 825platforma .NET, 23, 42, 175platforma .NET Compact Framework 3.5, 45platforma Azure, 1158platforma Entity, 68, 1001platforma MEF, 23, 688platforma testów jednostek, 398, 413platforma WCF, 23platforma WF, 23platforma Windows Presentation Foundation, 860platforma WPF, 23, 47Play, 94plik definicji projektu, 198

projekt Visual C#, 198projekt Visual C++, 200

plik definicji rozwiązania, 185pliki

addin, 654, 665asax, 727ascx, 727ashx, 727asmx, 75, 727, 1018ASP.NET, 727aspx, 727cab, 540config, 264, 728cs, 727cspkg, 66, 1199csproj, 198

1239

Skorowidz

css, 728dacpac, 969dbml, 728DISCO, 1016edmx, 69htm, 728js, 728master, 727MSI, 341pdb, 529, 530rdlc, 728resx, 728sitemap, 728, 798skin, 728svc, 728sync, 71testsettings, 411vb, 727vbproj, 198VSContent, 342vsdir, 679VSI, 342VSIX, 310, 341, 349vsmacros, 619vssettings, 82vstemplate, 336, 338vsz, 679XAML, 280xml, 264xsd, 67, 265xsl, 264XSLT, 269

pliki zrzutów, 527PLINQ, 176, 995pobieranie danych, 160początkowy formularz, 827podejmowanie decyzji, 135podgląd zmian, 445podglądanie danych w debugerze, 505

podpowiedzi DataTip, 508wizualizacja danych, 510

podglądanie zmiennych, 505Autos, 506Locals, 505QuickWatch, 508Watch, 507

podmienianie tekstu w plikach, 253, 255podpisywanie plików, 349podpisywanie podzespołu, 209podpowiedzi DataTip, 483, 508

przyczepianie, 509

podzespoły, 164podzespoły zaprzyjaźnione, 164

stosowanie, 164pola, 115

definiowanie, 298pola prywatne, 116pola publiczne, 116

pole tekstowe, 274polecenia, 604

argumenty, 606Command, 605dodatki, 651klawisze skrótu, 607obiektowy model automatyzacji, 604polecenia nazwane, 651wykonywanie, 606

polecenia SQL, 951połączenie kontrolki ze źródłem danych, 881połączenie z bazą danych, 943połączenie z danymi, 224pomoc, 312

aktualizacja lokalnego systemu pomocy, 313Customer Feedback Options, 324dodawanie materiałów do lokalnego systemu

pomocy, 313dokumentacja środowiska Visual Studio, 314Find Content Online, 313fora społeczności MSDN, 315Help Library Manager, 312menu Help, 312MSDN, 314MSDN Forums, 315przesyłanie informacji zwrotnych, 323przykłady, 326Report a Bug, 324Samples, 326zarządzanie ustawieniami systemu pomocy, 312zgłaszanie błędów, 323, 324

pomoc internetowa, 312pomoc w usprawnianiu środowiska Visual Studio, 324PopupControlExtender, 918porównywanie, 134poruszanie się po środowisku IDE, 88, 108porządkowanie instrukcji Using, 380Position, 750powiązanie arkusza XSLT z dokumentem XML, 270poziomy dostępu do składowych, 118, 119pozycjonowanie bezwzględne, 748pozycjonowanie kontrolek, 749, 831pozycjonowanie względne, 748pozycjonowanie za pomocą stylów CSS, 748

1240

Skorowidz

PreInit, 743PreLoad, 743PreRender, 743PreRenderComplete, 743PresentationCore.dll, 860PresentationFramwork.dll, 860Preview Changes, 445, 446primary key, 950Primitives, 1084Print, 262Private, 116, 119procedury obsługi zdarzeń, 829

kontrolki, 745strony ASP.NET, 744

procedury składowane, 956C#, 971diagnozowanie, 958kompilacja, 974polecenia SQL, 957wdrażanie, 974

proces, 1062, 1063, 1065Activity, 1069, 1077Activity Designer, 1069Activity Library, 1065argumenty, 1070Code Activity, 1069, 1075CodeActivity, 1075CompensableActivity, 1087, 1088Control Flow, 1084czynności, 1082, 1083czynności Collection, 1086czynności Control Flow, 1083czynności Error Handling, 1086czynności Flowchart, 1094czynności Messaging, 1089czynności Primitives, 1084czynności Runtime, 1084czynności Transaction, 1087DoWhile, 1083elementy, 1068Execute, 1077ForEach, 1083kolekcje, 1086NativeActivity, 1077obsługa kolekcji, 1086obsługa transakcji, 1087okno projektowe, 1067Persist, 1084projekt, 1065

projektowanie, 1107, 1110przechowywanie, 1074Sequence, 1083składniki, 1063sterowanie przepływem, 1083szablony elementów, 1068TransactionScope, 1087tworzenie, 1069tworzenie procesu opartego na komunikatach, 1090tworzenie procesu opartego na XAML, 1069tworzenie za pomocą szablonu Code Activity, 1075utrwalanie, 1116WCF Workflow Service, 1069WCF Workflow Service Application, 1065While, 1083WorkflowApplication, 1074WorkflowInvoker, 1074WorkflowServiceHost, 1075wywoływanie, 1074XAML, 1069zapisywanie procesu, 1077zarządzanie komunikatami, 1089

proces dynamiczny, 1080konfiguracja, 1080sposoby wywoływania, 1081

proces hosta, 1063proces tworzenia oprogramowania, 182proces wiązania danych, 975Processes, 485procesy biznesowe, 72Program, 562programiści, 61programowanie obiektowe, 114, 115programowanie pod kątem chmury, 63programowanie z wykorzystaniem atrybutów, 145programowanie z wykorzystaniem WPF, 871programowanie za pomocą okna Server Explorer, 228programowe zarządzanie dodatkami, 653Project, 89, 91, 562, 565, 568, 575

CodeModel, 569składowe, 568

Project Dependencies, 192Project Designer, 204, 205Project Explorer, 618Project Properties, 827Project.ProjectItems, 565ProjectItem, 562, 575ProjectItems, 562projectname, 335

1241

Skorowidz

projekt, 43, 85, 182, 194, 203Activity, 1069Activity Designer, 1069Activity Designer Library, 1066Activity Library, 1065ADO.NET Entity Data Model, 812, 1001aplikacje ASP.NET, 715aplikacje ASP.NET MVC, 809aplikacje do zarządzania procesem, 1097aplikacje działające w chmurze, 64aplikacje Office, 1135aplikacje SharePoint, 52aplikacje sieciowe, 283aplikacje Silverlight, 59, 934aplikacje Windows, 46, 272aplikacje WPF, 48, 280, 866aplikacje XBAP, 923ASP.NET Empty Web Site, 1017ASP.NET MVC 2 Web Application, 809ASP.NET MVC 2 Web Role, 1167ASP.NET MVC Web Application, 57ASP.NET Web Application, 54ASP.NET Web Role, 1167ASP.NET Web Service, 1017Azure, 1165Blank Solution, 184CGI Web Role, 1167Cloud Service, 64Code Activity, 1069, 1075Database, 961definiowanie niestandardowych parametrów, 336dekoracje, 702dodatki, 637Editor Classifier, 695Editor Margin, 696Editor Text Adornment, 697Editor Viewport Adornment, 698eksportowanie do szablonu, 334, 336elementy projektów, 203Enable Windows Azure Tools, 1161Excel 2007 Workbook, 1136Inherited Form, 827katalogi, 203kontrolki użytkownika ASP.NET, 802LINQ to SQL Classes, 996makra, 617parametry, 334plik definicji projektu, 198proces, 1065rozwiązania oparte na pakiecie Office, 50

Setup Wizard, 540Shared Add-in, 637Silverlight Application, 59, 934Silverlight Class Library, 934Silverlight Project, 934SQL Server CLR, 970SQL Server Project, 970strona startowa, 303struktura projektu, 204tworzenie, 85, 194, 333tworzenie szablonów, 333typy projektów, 195usługi WCF, 1043Visual Studio Add-in, 637Visual Studio SDK, 694VSIX, 350WCF, 75WCF Service Application, 75, 1043, 1049WCF Service Library, 1049WCF Service Web Role, 1167WCF Workflow Service, 1069WCF Workflow Service Application, 1043, 1065Windows Application, 203, 826Windows Azure Cloud Service, 1165Windows Control Library, 854Windows Form Application, 46WinForms, 290właściwości, 204Word 2007 Document, 1136Worker Role, 1167Workflow Console Application, 1066WPF Application, 48, 280, 866WPF Browser Application, 48, 923wybór docelowego środowiska, 86zależności, 191zarządzanie, 218

projekt bazy danych, 961DAC, 969Database Options, 964Import Database Scheme, 966importowanie schematu, 966opcje wdrażania, 969Project Properties, 964Schema View, 967SQL Server 2008 Wizard, 963struktura projektu, 964tworzenie, 962właściwości, 964zarządzanie projektami, 969

1242

Skorowidz

projekt startowy, 191projekt testów jednostek, 399, 400

opcje, 410szablony, 399tworzenie, 399

projekt witryny, 196, 715tworzenie, 197, 715

projektanci, 61projektowanie aplikacji opartych na formularzach

sieciowych, 283projektowanie danych, 67projektowanie formularzy, 822projektowanie formularzy WPF, 49, 62projektowanie interfejsu użytkownika, 746, 830projektowanie klas do obsługi danych, 68projektowanie kontrolki użytkownika, 854projektowanie procesu, 73, 1107, 1110projektowanie strony internetowej, 283projektowanie szablonów XML, 265Properties, 46, 47, 102, 104, 127, 431, 745, 868Property, 563Property Pages, 190, 729Protected, 119Protected Internal, 119przechodzenie przez kod, 491przechowywanie danych w platformie Azure, 1167

kolejki, 1168obiekty blob, 1168SQL Azure, 1169tabele, 1167

przechowywanie procesów, 1074przechowywanie udostępnianych zasobów, 330przechwytywanie zdarzeń kontrolki użytkownika, 661przeciążanie metody, 123przeciążanie składowych, 123przegląd kodu, 470przeglądanie obiektów, 230przeglądarka obrazów, 884przełączanie stanu ukończenia zadań, 580przeniesienie aplikacji na inną wersję platformy .NET, 87przerywanie działania na podstawie warunków, 500przerywanie działania programu w danej lokalizacji, 501przesłanianie operacji, 122przestrzenie nazw, 127przesyłanie informacji zwrotnych, 323przeszukiwanie dokumentów, 249

Find and Replace, 249Find Symbol, 249Quick Find, 249, 250Quick Replace, 250Search In Files, 249

przetwarzanie kolekcji, 139przezroczystość, 828przyciąganie do linii, 276przyciski, 274przyczepianie okna, 105przyczepianie podpowiedzi DataTip, 509przykłady, 326przypadki użycia, 823przypisanie, 133public, 117, 119Public, 119publikowanie aplikacji ASP.NET, 549

Copy Web Site Tool, 549, 554Web Deployment Tool, 549, 550

publikowanie aplikacji działającej w chmurze, 66, 1199publikowanie projektów, 536

instalator systemu Windows, 539publikowanie witryn, 549Publish, 929Publish Cloud Service, 1199, 1202Publish Web, 554Publish Wizard, 536, 538, 929, 930punkt edycji, 599punkt końcowy usługi, 1042punkt przerwania, 245, 476, 480, 494

Condition, 500etykiety, 499Filter, 500filtry, 502funkcje, 495Has Changed, 500, 501Hit Count, 500, 502ikony, 496Is True, 500konfiguracja, 259kontrola wykonywania programu, 261liczba dojść do punktu przerwania, 502Location, 500przerywanie działania programu w danej

lokalizacji, 501punkt śledzenia, 503ustawianie, 258, 478, 494ustawianie warunków, 500ustawienia licznika, 503When Hit, 500zarządzanie, 498

punkt śledzenia, 503Continue execution, 504ustawianie, 504When Breakpoint Is Hit, 504When Hit, 503

punkty dołączania rozszerzeń do edytora, 692

1243

Skorowidz

Q

Query Builder, 909Query Designer, 94, 952Query/View Designer, 951, 956, 957QueryExtender, 801Queue, 143Quick Find, 249, 250

All Open Documents, 250Current block, 250Current Document, 250doprecyzowanie wyszukiwania, 251Entire Solution, 250Find Next, 251Look In, 250, 251podmienianie tekstu, 252przeglądanie wyników wyszukiwania, 251Quick Replace, 252Selection, 250zasięg wyszukiwania, 250

Quick Info, 377Quick Replace, 250, 252QuickWatch, 486, 508

R

RAD, 822RadioButton, 792RangeValidator, 794Rapid Application Development, 822raporty sieciowe, 717rdbsetup.exe, 513ReadOnly, 117Receive, 1090, 1115ReceiveAndSendReply, 1090, 1091Record TemporaryMacro, 613RedirectResult, 808RedirectToRouteResult, 808Refactor, 89, 90, 442refaktoryzacja, 440

Class Designer, 444Encapsulate Field, 441, 465Extract Interface, 441, 459Extract Method, 441, 451generowanie szkieletu metody, 457hermetyzacja pól, 465inteligentne znaczniki, 442narzędzia, 441parametry, 462podgląd zmian, 445

Preview Changes, 445Refactor, 442Remove Parameters, 441, 462Rename, 441, 446Reorder Parameters, 441, 463uruchamianie narzędzi, 441usuwanie parametrów, 462wyodrębnianie interfejsów, 459wyodrębnianie metod, 450wyodrębnianie pojedynczych wierszy kodu, 456zmiana kolejności parametrów, 463zmiana nazw, 446

referencje, 729referencje sieciowe, 1033

wyświetlanie, 1036refleksja, 145region, 368regiony formularzy aplikacji Outlook, 1144registeredorganization, 335RegisterRoutes, 819Registers, 485RegularExpressionValidator, 793, 794rejestrowanie kontrolki na stronie, 804rejestrowanie makr, 613relacje między klasami, 296

asocjacja, 297dziedziczenie, 296interfejs, 296

relacyjne bazy danych, 993Remote Debugging Monitor, 513Remoting, 1014Remove and Sort, 380Remove Parameters, 441, 462Remove Unused Usings, 380RemoveFromCollection<T>, 1087Rename, 441, 446, 449

opcje, 449Preview Reference Changes, 449Search in Comments, 450Search in Strings, 450zmiana nazw, 449

Reorder Parameters, 441, 463ReorderList, 918Repeater, 801, 808, 989Report a Bug, 324Report Wizard, 728Reporting Services, 1169RequestedPage, 429RequiredFieldValidator, 794Resource File, 206, 728

1244

Skorowidz

Restart, 485Rethrow, 1086return, 118Return, 117REVIEW, 395ręczne wiązanie kontrolek formularzy Windows, 982RIA, 904, 940Ribbon (Visual Designer), 1137Ribbon (XML), 1137RibbonControlSizeLarge, 1139Rich Internet Applications, 940RichTextContentControl, 1149Right, 833RightToLeft, 823RightToLeftLayout, 823role, 1164

Web, 1164Worker, 1164

Root namespace, 206rootnamespace, 335routed events, 883Row.Height, 889rozbudowywanie edytora kodu, 688rozgałęzianie kodu, 135rozłączanie okien narzędzi, 587rozmieszczanie kontrolek, 275, 284

przyciąganie do linii, 276układ tabelaryczny, 275

rozpoczynanie sesji diagnostycznej, 489rozpowszechnianie pików VSIX, 354rozszerzalne funkcje pakietu Office, 1131

pamięć podręczna danych, 1133panele operacji, 1132panele zadań, 1132tagi inteligentne, 1134wstążka, 1133

rozszerzenia, 688, 689rozszerzenia dokumentów Office, 1147

kontrolki formularzy Windows, 1147kontrolki kontenerowe, 1147kontrolki-hosty, 1148pamięć podręczna danych, 1150tagi inteligentne, 1153tworzenie paneli operacji, 1149wyspy danych, 1150

rozszerzenia edytora, 701rozwiązania, 182

dodawanie projektu, 194elementy, 188hierarchia plików, 185

katalogi, 190kontrola projektów, 568lokalizacja kodu źródłowego na potrzeby

diagnozowania, 192plik definicji rozwiązania, 185praca programistów, 182projekt, 184projekt startowy, 191referencje do projektów, 188stosowanie, 188tworzenie, 183właściwości, 190właściwości konfiguracji kompilacji, 193zależności projektu, 191zarządzanie, 217

RS, 1169RSS, 306Run, 94Run TemporaryMacro, 613Run To Cursor, 472, 490Runtime, 1084rzutowanie, 132rzutowanie w dół, 123

S

SafeArray, 607safeitemname, 335safeprojectname, 335samodzielne sprawdzanie, 470Save Dump As, 486, 527SaveStateComplete, 743sbyte, 130scalanie łańcuchów znaków, 135Scalar-valued Function, 961ScaleTransform, 895scenariusz diagnozowania, 469Schema View, 967schematy kodu, 367

menu Outlining, 369polecenia, 369tworzenie, 367

ScriptManager, 905, 906, 907ScriptManagerProxy, 906Scripts, 716SDK, 349, 693Sealed, 121Search In Files, 249Select, 163SELECT, 953, 955

1245

Skorowidz

Select Active Test Settings, 411SELECT DISTINCT, 984Select Master Page, 738Select Style Sheet, 762Select…Case, 137SelectedItem, 563Send, 1090Send to Back, 752, 846SendAndReceiveReply, 1090Sequence, 1083, 1084SequentialWorkflow, 73SequentialWorkflowActivity, 1062serializacja, 1151Server Explorer, 67, 223, 942

Add Data Connection, 224Add Server, 224budowanie związków tabel, 948Data Connections, 224, 943definiowanie kolumn, 945definiowanie tabel, 945Event Logs, 226indeksy, 946klucze obce, 946komponenty serwera, 225Management Classes, 226Management Events, 227Message Queues, 228modyfikacja definicji tabel, 948ograniczenia, 946określanie klucza głównego, 945Performance Counters, 228połączenia z danymi, 224połączenie z bazą danych, 943programowanie, 228przeciąganie, 228Services, 228Step Into Stored Procedure, 958tworzenie diagramu bazy danych, 947wyzwalacze, 960

ServerDocument, 1152, 1153Service Configuration Editor, 1051Service Reference Settings, 1034, 1035Service.asmx, 716Service.svc, 717Service1.svc, 1044Service1.svc.cs, 1044ServiceConfiguration.csfg, 1171serwer IIS, 718, 720serwer TFS, 36Session, 428, 1017

Set as Recording Project, 617Set as Startup Project, 1049Set Next Statement, 260Set Primary Key, 945Set Symbol Paths, 528SetFocus, 575SetSelectionContainer, 574, 575SetTabPicture, 574, 575Setup Wizard, 540Shadows, 123Shared, 120Shared Add-in, 637SharePoint, 38, 45, 52short, 130Short, 130Show Next Statement, 478Show Threads in Source, 516Sign Tool, 349SignTool.exe, 349silnik uruchomieniowy procesu, 1064Silverlight, 44, 53, 59, 62, 736, 904, 922, 933

tworzenie aplikacji, 934Silverlight 4.0, 939Silverlight Application, 59, 934Silverlight Class Library, 934Silverlight Project, 934Simple Object Access Protocol, 1016SimpleTypeName(), 388Single, 130Site Map, 728Site.css, 716Site.master, 716, 765, 803SiteMapDataSource, 800, 993SiteMapPath, 798SketchFlow, 40Skin File, 728SkinId, 772składniki procesu, 1063składowe, 118

składowe statyczne, 120składowe wirtualne, 122

skoroszyt aplikacji Excel, 1147skórki, 770

identyfikator, 775SkinId, 772skórki nazwane, 772skórki nienazwane, 772tworzenie pliku skórki, 772typy definicji, 772

1246

Skorowidz

skróty klawiaturowemakra, 631polecenia, 607

skrypty działające po stronie klienta, 526skrypty SQL, 962SliderExtender, 918SlideShowExtender, 919SLQ, 909słowa kluczowe

class, 115Class, 115Function, 117Private, 116ReadOnly, 117return, 118Return, 117Sub, 117

SmartTag, 1153SmartTagBase, 1153SnapLines, 275SnapToGrid, 275snippets, 380SOAP, 75, 1012, 1016, 1031

wyjątki, 1041SoapException, 1040, 1041Software Publisher Certificate Test Tool, 349solution, 182Solution, 563, 565, 567

składowe, 567Solution Explorer, 88, 97, 205, 212, 241, 1049

Add New Solution Folder, 217ASP.NET Configuration, 217Copy Web Project, 216Copy Web Site, 217ikony, 213ikony sygnalizacyjne, 216Nest Related Files, 217Properties, 217przyciski paska narzędzi, 216Refresh, 217Unhide All, 217View Class Diagram, 217View Code, 217View Designer, 217wskazówki graficzne, 213zarządzanie projektami, 218zarządzanie rozwiązaniami, 217zmiana nazw, 447

Solution Property Pages, 190Solution.Projects, 565, 566Solution2, 563, 567

Solution3, 563, 567Solution4, 563SolutionEvents, 626Sort Usings, 380SortedList, 143sortowanie instrukcji Using, 380Source, 55SourceControl, 563SourceControl2, 563Split, 55, 56SplitButton, 847SplitContainer, 46, 836, 837, 849Splitter, 837społeczność, 302

strona startowa Visual Studio, 303wkład w społeczność, 332

sprawdzanie kolekcji okien, 575sprawdzanie poprawności danych, 793sprawdzanie poprawności kodu HTML, 288sprawdzanie usługi sieciowej, 1031SQL, 951

funkcje definiowane przez użytkownika, 961procedury składowane, 956

SQL Azure, 1169SQL Debugger, 959

parametry, 959SQL Server, 942, 993SQL Server 2008 Wizard, 963SQL Server CLR, 970SQL Server Compact Edition, 71SQL Server Project, 970SqlCommand, 971SqlConnection, 971SqlDataSource, 800, 993SqlDataSource.UpdateQuery, 992SquiggleTag, 693SSL, 722, 797Stack, 143StackPanel, 871, 876, 885, 888StackStyle, 1150stałe, 133standardowe okna dialogowe, 895standardowy pasek narzędzi, 94standardy UI, 824Start, 191Start Automatic Outlining, 369Start Debugging, 483, 487, 491Start Page, 303Start Page news channel, 84Start Without Debugging, 191, 472, 483StartCaching(), 1152

1247

Skorowidz

Starter Kit, 717StartPage.xaml, 310StartPosition, 827Startup object, 206Startup Project, 191StateMachineActivity, 1062StateMachineWorkflow, 73statement, 128Static, 120Static Code Analyzer, 470StatusBar, 847StatusStrip, 46, 841, 847

edycja elementów, 848Step Into, 480, 483, 486, 489, 491Step Into Stored Procedure, 958Step Out, 486, 493Step Over, 483, 486, 489, 491sterowanie przepływem w procesie, 1083Stop, 260Stop Debugging, 485Stop Hiding Current, 369Stop Outlining, 369Storage Connection String, 1186, 1197stos wywołań, 476stosowanie kompozycji, 773stosowanie obiektów dynamicznych, 171stosowanie stylów CSS, 763strefy strony Web Part, 777string, 151String, 151StringAssert, 422strona startowa, 83, 303, 304

Get Started, 305Getting Started, 303Guidance and Resources, 303, 306kanały RSS, 306, 307Latest News, 303, 306Microsoft Patterns and Practices, 306modyfikacja, 310obszar projektów, 303operacje wykonywane przy uruchamianiu, 308StartPage.xaml, 310tworzenie niestandardowej strony startowej, 310ustawianie niestandardowych kanałów

z wiadomościami, 307wiadomości związane ze środowiskiem, 306

stronicowanie, 912strony ASP.NET, 55, 737

arkusze stylów, 754, 756cykl życia, 741dodawanie kontrolek, 738

dodawanie procedur obsługi zdarzeń, 744dodawanie procedur obsługi zdarzeń kontrolki, 745dodawanie zasady stylu, 759generowanie strony, 742inicjowanie strony, 742Init, 743InitComplete, 743kod źródłowy, 739Load, 743LoadComplete, 743model zdarzeń, 741obsługa zdarzeń związanych z odesłaniem

strony, 742odpowiedzi na zdarzenia, 741odpowiedź dla użytkownika, 742opcje pozycjonowania kontrolki, 749położenie kontrolek, 747PreInit, 743PreLoad, 743PreRender, 743PreRenderComplete, 743programowanie, 55projekt, 55projektowanie, 55, 738rozpoczęcie przetwarzania, 741SaveStateComplete, 743sprawdzanie poprawności strony, 742strony wzorcowe, 56, 765style, 754style elementów, 755style z poziomu strony, 755synchronizacja między kodem źródłowym

a oknem projektowym, 55tworzenie, 737tworzenie jednolitego wyglądu i zachowania, 754układ strony, 747Unload, 744ustawianie tego samego rozmiaru kontrolek, 752ViewState, 742wczytanie strony, 742widok podzielony, 739widok projektowy, 738widok Split, 56wyrównywanie elementów, 752zarządzanie nawigacją i projektem, 56zdarzenia, 743żądanie użytkownika, 741

strony obsługujące częściową aktualizację, 907strony Web Part, 777

chromowanie elementów, 781definiowanie stref, 779dodawanie elementów Web Part do stref, 781

1248

Skorowidz

strony Web Partedycja układu strony, 786LayoutEditorPart, 786strefy, 777, 780tworzenie, 778układ strony, 780umożliwianie użytkownikom konfiguracji

strony, 783ustawienia kontrolek, 788

strony wzorcowe, 56, 727, 765@Page, 769ContentPlaceHolder, 766, 768dodawanie treści do elementu <head/>, 768Master, 768obszary z treścią, 768plik kodu, 766pozycjonowanie, 768Site.master, 765tworzenie, 765tworzenie strony z treścią, 767tytuł strony opartej na stronie wzorcowej, 769układ kontrolek, 768zagnieżdżanie stron wzorcowych, 769

struct, 126structural matching, 690structure, 126Structure, 126struktura kreatorów, 677struktury, 125, 130

definiowanie, 126studia ergonomii, 823style, 754, 755Style, 878style elementów, 755Style Sheet, 728, 758style wewnątrzwierszowe, 755style z poziomu strony, 755Styles, 758Stylesheet, 270StylesheetTheme, 774Sub, 117subskrypcja usług platformy Azure, 1188subskrypcja zdarzeń, 149SvcConfigEditor.exe, 1051switch, 137

case, 137Switch, 1084synchronizacja danych, 71system pomocy, 312System.Activities, 177

System.Activities.XamlIntegration, 1081System.AddIn, 175System.Array, 142System.Boolean, 130System.Byte, 130System.CodeDom, 175System.Collections, 143, 175System.Collections.Generic, 144System.ComponentModel, 175System.ComponentModel.Composition, 690System.ComponentModel.Composition.�ExportAttribute, 690

System.ComponentModel.Composition.Hosting, 690System.ComponentModel.Composition.Import�Attribute, 690

System.ComponentModel.IComponent, 289System.Configuration, 175System.Data, 175System.Decimal, 130System.Diagnostics, 175, 260System.Diagnostics.Contracts, 176System.Diagnostics.EventLog, 228System.Double, 130System.Drawing, 176System.Dynamic, 170, 176System.EnterpriseServices, 176System.Globalization, 176System.Int16, 130System.Int32, 130System.Int64, 130System.IO, 176System.Linq, 176System.Media, 176System.Messaging, 176System.Net, 176System.Net.PeerToPeer, 176System.NotImplementedException, 683System.Object, 130System.Runtime.CompilerServices, 157System.Runtime.Serialization, 1047System.Security, 176System.ServiceModel, 176System.Single, 130System.String, 130, 152System.Threading, 176System.Threading.Tasks, 176, 523System.Tuple, 144System.Web, 177System.Web.Mvc, 57, 807System.Web.Services.Protocols, 1041

1249

Skorowidz

System.Web.UI.WebControls, 989System.Web.UI.WebControls.WebParts, 776System.Windows, 177, 878System.Windows.Controls.Page, 924System.Windows.Data.Binding, 881System.Windows.Forms, 203, 895System.Windows.Forms.Control, 290System.Windows.Forms.Integration, 1143System.Windows.Forms.UserControl, 290System.Windows.Media.Imaging, 891System.Windows.Window, 924System.Workflow.Activities, 177System.Xml, 177System.Xml.Linq.XDocument, 165System.Xml.Linq.XElement, 165szablony, 44, 51, 329, 333

instalacja, 339modyfikacja pliku .vstemplate, 338opcje eksportowania, 337parametry, 335tworzenie, 333

szablony elementów, 340tworzenie, 340

szablony internetowe, 330szablony procesu, 36szablony projektu testów, 399szablony witryny, 54, 716szablony XML, 264

generowanie, 265okno projektowe, 267projektowanie, 265widoki szablonu, 266XML Schema Explorer, 266

szablony XSD, 264szeregowanie zadań, 523

Ś

śledzenie stanu projektu, 38śledzenie zmian, 364środowisko IDE, 30, 88, 89

Build, 91Class Designer, 94Customize, 95czcionki, 110Data, 92Debug, 91dokowanie okna, 106dostosowywanie edytorów, 100dostosowywanie pasków narzędzi, 95

Edit, 89edytor kodu języka C#, 98edytor kodu języka Visual Basic, 99edytory kodu, 98edytory tekstu, 98File, 89Format, 92graficzne okna projektowe, 102Help, 93konfiguracja, 79menu, 89nawigacja, 88, 94okna projektowe, 102okno narzędzi, 103opcje uruchomieniowe, 84otwieranie starszej aplikacji, 88pasek menu, 89paski narzędzi, 94poruszanie się między oknami, 108Project, 89, 91projekt, 85Properties, 104Query Designer, 94Refactor, 89, 90Solution Explorer, 97standardowy pasek narzędzi, 94strona startowa, 83Table, 92Test, 93Toolbox, 103Tools, 92View, 90Website, 90Window, 93zarządzanie ustawieniami, 80zarządzanie wieloma oknami, 105

środowisko IDE Macros, 616

T

Tab Order, 841TabContainer, 919TabControl, 373, 855tabele, 942

budowanie związków tabel, 948definiowanie kolumn, 945definiowanie struktury, 942edycja struktury, 942klucz główny, 945modyfikacja definicji, 948

1250

Skorowidz

tabeleokreślanie klucza głównego, 945wartości null, 945wirtualne tabele, 955związki tabel, 942

tabele HTML, 286TabIndex, 753Table, 92, 792, 1167Table Designer, 946TableLayoutPanel, 836, 837, 855Tables and Columns, 949TableServiceContext, 1177Table-valued Function, 961tablice, 141

Array, 142dostęp do elementów, 142indeks, 141inicjacja wartości elementów, 142liczba elementów, 142rozmiar, 141tablice wielowymiarowe, 142

tagi, 693tagi inteligentne, 1134, 1153

implementacja, 1153SmartTagBase, 1153

Target Framework, 87Task, 523Task List, 393, 578

obiektowy model automatyzacji, 579zadania użytkownika, 396zadania związane z komentarzami, 394zadania związane ze skrótami, 395

TaskItem, 563, 580Delete, 579składowe, 579

TaskItems, 563, 580Add, 579

TaskItems2, 563TaskList, 563, 578, 579, 580technologia ASP.NET Ajax, 904technologia ClickOnce, 534technologia LINQ, 994technologia PLINQ, 995technologia Silverlight, 933technologia Windows Workflow, 1063Template, 51, 563Terminate All, 485, 493TerminateWorkflow, 1085Test, 93, 401Test List Editor, 435, 436

Test Results, 407Test Runs, 409Test Settings, 413Test View, 407, 431, 432, 434TestClass, 415, 416TestCleanup, 416, 418TestContext, 413, 429

CurrentTestOutcome, 414DataConnection, 414DataRow, 414RequestedPage, 414TestDeploymentDir, 414TestLogsDir, 414TestName, 414

TestInitialize, 416, 418TestMethod, 406, 416, 438testowanie, 398testowanie jednostek, 398testowanie usług WCF, 1049testowanie wyjątków, 422

ExpectedException, 422TestProperty, 416testy jednostek, 398, 399, 470

asercje, 420AssemblyCleanup, 415AssemblyInitialize, 415Assert, 420automatyzacja procesu tworzenia testów

jednostek, 402Basic Unit Test, 401ClassCleanup, 415, 418ClassInitialize, 415, 418Create Unit Tests, 403Database Unit Test, 401DataSource, 415DeploymentItem, 416ExpectedException, 416, 422generowanie testów na podstawie istniejącego

kodu, 402HostType, 416Ignore, 416klasy asercji, 420klasy atrybutów testów, 415klasy testów, 400, 406konfiguracja atrybutów, 431konfiguracja opcji, 409kontrola operacji inicjujących i porządkujących

na poziomie wykonywania testów, 419kontrola ustawień testów, 411Local.testsettings, 400

1251

Skorowidz

menu Test, 401opcje projektów testów, 410operacje wykonywane po testach, 418operacje wykonywane przed testami, 418Ordered Test, 401organizowanie testów, 434piki .testsettings, 411pisanie testów jednostek, 405platforma, 413pliki z konfiguracją, 400projekt, 399, 400przeglądanie wyników testów, 407szablony projektów, 399, 401Test Results, 407Test Runs, 409Test Settings, 413Test View, 407, 434TestClass, 415, 416TestCleanup, 416, 418TestContext, 413TestInitialize, 416, 418TestMethod, 406, 416TestProperty, 416Timeout, 416TraceAndTestImpact.testsettings, 400tworzenie projektu, 399Unit Test, 401Unit Test Wizard, 401, 402, 411uruchamianie testów, 402uruchamianie testów jednostek, 407wczytywanie informacji o wcześniejszych

testach, 402wygenerowany kod testów, 404wyniki testów, 407wyświetlanie przebiegów testów, 409zarządzanie ustawieniami procesu generowania

testów, 404zarządzanie wynikami testów, 411

testy jednostek ASP.NET, 428AspNetDevelopmentServerHost, 428atrybuty środowiska ASP.NET, 428generowanie testów, 429HostType, 428konfiguracja hosta projektu testów, 430UrlToTest, 428

testy jednostek zależne od danych, 423DataSource, 423, 425łańcuch połączenia, 423nawiązywanie połączenia przy użyciu pliku

konfiguracyjnego, 424

połączenie z danymi, 423stosowanie danych testowych w asercjach, 426uruchamianie testów, 427wyniki testów, 427źródło danych, 425

testy obciążenia, 39testy sieciowe, 39testy uporządkowane, 433

Ordered Test, 433testy wytrzymałości, 39TextBlock, 880TextBox, 274, 751, 792TextBoxWatermarkExtender, 919TextDocument, 563, 593, 594

CreateEditPoint, 599składowe, 594

TextPane, 563, 577TryToShow, 577

TextPane2, 563TextPoint, 596, 599

CreateInstance, 599TextSelection, 596TextWindow, 563, 576

ActivePane, 577Panes, 577

TFS, 36automatyzacja procesu kompilacji, 37dostęp do sieci WWW, 38kontrola wersji, 37raporty, 38raporty ogólne, 38szablon procesu, 36Web Access, 38zarządzanie projektem, 37zarządzanie przypadkami testowymi, 37zarządzanie wymaganiami, 37

Then, 136this, 157ThisAddIn, 1142ThisDocument, 1150ThisWorkbook, 1150ThisWorkbook_Startup, 1150Threads, 485, 517Throw, 1086Thrown, 475time, 335Timeout, 416Timer, 274, 906TODO, 394Toggle All Outlining, 369

1252

Skorowidz

Toggle Breakpoint, 483, 486Toggle Outlining Expansion, 369Toolbox, 67, 103, 578, 581, 830, 831

dodawanie elementów, 582usuwanie elementów, 582

ToolBox, 563, 578, 581ToolBoxItem, 563, 581ToolBoxItem2, 563ToolBoxItems, 581

Add, 581ToolBoxTab, 563ToolBoxTab2, 563ToolBoxTab3, 563ToolBoxTabs, 581ToolkitScriptManager, 919Tools, 92ToolStrip, 841, 844, 847, 850ToolStripContainer, 838, 847ToolStripItem, 841, 844ToolTip, 841ToolWindows, 660Top, 833TRACE, 206TraceAndTestImpact.testsettings, 400TransactedReceiveScope, 1090Transaction, 1087TransactionScope, 1087, 1089Transact-SQL, 956transakcje, 1087transformacje obrazów, 895TravelDataLib, 1098TravelManagerWeb, 1098TravelRequestService, 1098TreeNode Editor, 850TreeView, 849, 850, 905

edytor węzłów, 850obrazy, 850

Triggers, 912true, 138Try…Catch…Finally, 146tryb nazywania elementów, 373try-catch, 376TryCatch, 1086TryCreateInstance, 169TryGetMember, 169, 172TryInvokeMember, 169TrySetMember, 169T-SQL, 956, 961tunneling event, 883Tuple, 42, 144

Create, 144

tworzenieaplikacje ASP.NET MVC, 805aplikacje biznesowe, 72aplikacje do zarządzania procesem, 1096aplikacje działające w chmurze, 64, 1170aplikacje LINQ to SQL, 996aplikacje okresowo nawiązujące połączenie, 71aplikacje Silverlight, 59, 934aplikacje Windows, 46aplikacje WPF uruchamiane w przeglądarce, 922aplikacje XBAP, 922arkusze stylów, 758baza danych, 943, 1099biblioteka dostępu do danych, 1100czynności Code Activity, 1106czynności złożone, 1105diagram bazy danych, 947diagram klasy, 293dodatki dla pakietu Office, 1136dokumenty XSD, 265dynamiczne aplikacje, 688egzemplarz klasy, 131egzemplarz nieistniejącej klasy, 156elementy Web Part, 782formularze sieciowe, 282, 285formularze Windows, 826fragmenty kodu, 385interfejs sieciowy, 46interfejs użytkownika, 822katalogi zakładek, 248klasy, 293klasy kontrolki użytkownika, 655klient sieciowy, 53klucze obce, 948komponenty, 290kompozycje, 771kontroler, 814kontrolki, 290, 853kontrolki niestandardowe, 857kontrolki użytkownika ASP.NET, 802kreatory, 677kreatory Add New Item, 680lista testów, 436makra, 345, 613menu, 842metody, 299model, 812model EDM, 69model procesu, 72niestandardowa wstążka pakietu Office, 1140niestandardowe strona startowa, 310

1253

Skorowidz

obiekty, 119, 153obiekty bazy danych w kodzie zarządzanym, 970obiekty dynamiczne, 169okna dialogowe, 681pakiet instalacyjny ClickOnce, 536pakiety, 341pakiety za pomocą narzędzia VSI, 342panele operacji pakietu Office, 1149pasek narzędzi, 844pasek statusu, 847połączenie z bazą danych, 943procedury obsługi zdarzeń, 829procedury składowane, 956procedury składowane w C#, 971proces, 1069proces dynamiczny, 1080proces oparty na komunikatach, 1090proces oparty na XAML, 1069proces typu Flowchart, 1094proces za pomocą szablonu Code Activity, 1075projekt, 85, 194, 333projekt aplikacji sieciowej, 715projekt aplikacji Windows, 272projekt bazy danych, 962projekt dekoracji, 702projekt dodatku, 637projekt instalacyjny aplikacji dla systemu

Windows, 541projekt testów, 399, 400projekt VSIX, 350projekt witryny internetowej, 197projekt WPF, 280punkt edycji, 599regiony, 368regiony formularzy aplikacji Outlook, 1144rozszerzenia dokumentów Office, 1147rozszerzenia edytora, 701rozwiązania, 183rozwiązania WPF, 48schematy kodu, 367skórki, 772strony ASP.NET, 737strony obsługujące częściową aktualizację, 907strony oparte na stronie wzorcowej, 57strony Web Part, 778strony wzorcowe, 56, 765struktury, 125style, 756szablony elementów, 340szablony projektów, 333

szablony XML, 265tabele, 942testy jednostek, 406testy jednostek zależne od danych, 423testy uporządkowane, 433usługi sieciowe ASP.NET, 1020usługi WCF, 74, 75, 1045, 1104widok, 817widoki (baza danych), 955witryny, 907witryny ASP.NET, 715wyjątki SOAP, 1041wyjątki usługi sieciowej, 1040wyliczenia, 120wyzwalacze, 960zapytania SQL, 951zapytania typu Management Event, 227zbiory danych, 67zdarzenia, 147zrzut informacji diagnostycznych, 527

TypeCatalog, 691typed dataset, 67typy danych, 130

dynamic, 167dynamiczne typy danych, 167konwersja, 131łańcuchy znaków, 130obiekty, 130struktury, 130typy anonimowe, 156typy ogólne, 143, 144, 161typy proste, 130

typy MIME, 931typy projektów, 195typy złączeń, 954

U

UDDI, 1016udostępnianie interaktywnych aplikacji w różnych

systemach, 933udostępnianie ustawień dodatku, 662UIHierarchyItem, 620, 621układ kontrolek, 831układ strony ASP.NET, 747

opcje pozycjonowania kontrolki, 749pozycjonowanie bezwzględne, 748, 751pozycjonowanie względne, 748pozycjonowanie za pomocą stylów CSS, 748układ płynny, 748, 753

1254

Skorowidz

układ tabelaryczny, 275ukrywanie składowych, 123UML, 297Undo, 94UNDONE, 394Uniform Resource Identifier, 1016uniform resource locator, 1016Unit Test, 401Unit Test Wizard, 401, 402, 411UnitTesting.Web, 428Universal Description, Discovery, and Integration, 1016Unload, 744Unload Macro Project, 629until, 140Until, 140UPDATE, 955, 992Update Service Reference, 1037UpdatePanel, 58, 906, 908UpdatePanelTrigger Collection Editor, 912UpdateProgress, 58, 906, 913UpdateQuery, 992uproszczone deklarowanie właściwości, 166URI, 1016, 1031, 1042UriSource.LocalPath, 893URL, 1016UrlRoutingModule, 807UrlToTest, 428uruchamianie

aplikacje MVC, 820aplikacje w chmurze, 64aplikacje w trybie diagnozowania, 470, 471, 472aplikacje XBAP, 925kod, 260kreator, 683narzędzie do refaktoryzacji, 441sesje diagnostyczne, 482szablon XSLT dla dokumentu XML, 269testy jednostek, 407testy zależne od danych, 427usługi WCF, 1049zdalne diagnozowanie, 513

uruchamianie makra, 613, 614, 629makra z parametrami, 632menu, 630okno poleceń, 632paski narzędzi, 630skróty klawiaturowe, 631

urządzenia mobilne, 45user control, 853UserControl, 835

userdomain, 335UserLookupActivityLib, 1098username, 335using, 128, 367Using, 153, 380usługa WAS, 1118usługi, 71, 74usługi sieciowe, 75, 514, 1012

format danych, 1012odkrywanie, 1013SOAP, 75, 1012wywoływanie, 1037XML, 1012

usługi sieciowe ASP.NET, 1012, 1014, 1015atrybut WebMethod, 1027atrybut WebService, 1027definiowanie referencji sieciowej, 1033DISCO, 1016formalny opis usługi sieciowej, 1029HTTP, 1016, 1031interfejsy, 1026kod metod sieciowych, 1025konsumowanie, 1033metody, 1015odpowiedź SOAP, 1032opis, 1029pliki usługi sieciowej, 1018pośrednik usługi, 1036projekt, 1017SOAP, 1016, 1031SoapException, 1040sprawdzanie usługi sieciowej, 1031tworzenie, 1020tworzenie wyjątku usługi sieciowej, 1040UDDI, 1016URI, 1016web.config, 1018WebMethod, 1027WebService, 1027WebServiceAttribute, 1027WSDL, 1016, 1029WSE, 1016wyjątki, 1039wyświetlanie metody sieciowej, 1031wywoływanie metody sieciowej, 1032wywoływanie usługi sieciowej, 1037XML, 1016XSD, 1016żądanie SOAP, 1031

1255

Skorowidz

usługi uruchomieniowe procesu, 1064usługi WAS, 76usługi WCF, 74, 75, 717, 1012, 1014, 1041, 1104

adres, 1042adres punktu końcowego, 1053diagnozowanie, 514działania, 1042elementy wiązania, 1042host, 1042, 1049hosting, 1058kanały, 1042klient, 1042konfiguracja, 76, 1050konsumowanie, 74, 76, 1055kontrakt, 1042pliki usług, 1044projekt, 1043punkt końcowy, 1042testowanie, 1049tworzenie, 74, 75, 1045URI, 1042uruchamianie, 1049wiązanie, 1042, 1054

ustawianieaktywne okno, 575filtry punktów przerwania, 502punkty przerwania, 258, 478, 494punkty śledzenia, 504warunki punktu przerwania, 500

usuwanienieużywane argumenty z metod obsługi

zdarzeń, 166nieużywane instrukcje Using, 380zadania, 579

utrwalanie procesu, 1116uwierzytelnianie użytkowników, 796uzupełnianie słów, 375

V

Validate, 742ValidationSummary, 793, 794Variant, 152VBA, 1130VBScript, 526VendorReservationService, 1098VerticalAlignment, 886View, 90View Call Hierarchy, 248View Class Diagram, 293

ViewportAdornment1, 698ViewportAdornment1Factory, 698ViewResult, 808ViewState, 742, 809virtual, 122VirtualPoint, 596, 601Visual, 863, 879Visual Basic, 41

automatyczne generowanie kodu do obsługiwłaściwości, 166

kontynuowanie wiersza, 167usuwanie nieużywanych argumentów z metod

obsługi zdarzeń, 166Visual Basic for Applications, 1130Visual C#, 41Visual C++, 41Visual Database Tools, 942Visual F#, 41Visual Studio 2010, 23, 30

edycje, 31strona startowa, 83subskrypcja pakietu MSDN, 35

Visual Studio 2010 Express, 32Visual Studio 2010 Image Library, 1140Visual Studio 2010 Premium, 31, 34Visual Studio 2010 Professional, 24, 31, 33Visual Studio 2010 SDK, 349Visual Studio 2010 Ultimate, 31, 34Visual Studio Add-in, 637Visual Studio Agents 2010, 39Visual Studio Code Gallery, 310Visual Studio Content Installer, 347Visual Studio Debugger, 472Visual Studio Export Template Wizard, 333Visual Studio Extensibility, 693Visual Studio Extension, 341Visual Studio Extension Manager, 341Visual Studio Gallery, 342Visual Studio Installer, 342, 540Visual Studio SDK, 693

Editor Classifier, 695szablony projektu, 694

Visual Studio Team Explorer 2010, 38Visual Studio Test Professional 2010, 38Visual Studio Tools for Office, 1130Visual styles, 206Visual Web Developer 2010 Express, 33void, 117VSCloudService.exe, 1161, 1164vsCMElement, 571

1256

Skorowidz

vsCommandExecOption, 652vsCommandExecOptionDoDefault, 652vsCommandExecOptionDoPromptUser, 652vsCommandExecOptionPromptUser, 652vsCommandExecOptionShowHelp, 652VSContent, 342

atrybuty, 344Attribute, 344Attributes, 344ContentVersion, 344definiowanie pliku, 345, 346Description, 343DisplayName, 343FileContentType, 343FileName, 343węzły, 343

VSContentInstaller.exe, 347VSI, 342

plik VSContent, 342tworzenie pakietów, 342

VSIX, 341, 349Copy to Output Directory, 351dodawanie rozszerzenia, 351edytor manifestów, 352kompilacja projektu, 353manifest, 352projekt, 350rozpowszechnianie, 354szablon projektu, 351testowanie procesu instalacji, 354

vsPaneShowHow, 577vstemplate, 336, 338, 344VSTest, 428VSTO, 1130

dodatki dla pakietu Office, 1136niestandardowe panele zadań, 1143obsługa zdarzeń kontrolek, 1141pamięć podręczna danych, 1152

vsToolBoxItemFormat, 581vsToolBoxItemFormatDotNETComponent, 582VSTS Database Edition, 962

W

W3C’s Web Content Accessibility Guidelines, 734wariancja, 174wariancja delegatów, 174warstwa prezentacji, 860wartości null, 945wartości zmiennych, 505warunki punktu przerwania, 500

WAS, 76, 1059, 1118Watch, 484, 507wątki, 515, 523WCAG, 734WCF, 23, 75, 176, 1012, 1014, 1041

projekt usługi, 75WCF Service, 717, 728WCF Service Application, 75, 1043, 1044, 1049, 1050WCF Service Host, 1049WCF Service Library, 1049, 1050, 1051, 1055WCF Service Web Role, 1167WCF Workflow Service, 1068, 1069WCF Workflow Service Application, 1043, 1065wczytywanie danych, 160wdrażanie aplikacji działających w chmurze, 1199

Publish Cloud Service, 1202Visual Studio, 1202wdrażanie w środowisku testowym, 1200

wdrażanie aplikacji na platformę Azure, 1174wdrażanie procedur składowanych, 974wdrażanie rozwiązań po stronie klienta, 534

ClickOnce, 534instalator systemu Windows, 535

Web, 1164Web 2.0, 904Web Configuration File, 728Web Deployment Tool, 549, 550

Deploy SQL, 551Include All Databases Configured in Deploy SQL

Tab, 551One-Click Publishing, 553, 554opcje wdrażania baz SQL Server, 551opcje wdrażania rozwiązań sieciowych, 551Package/Publish, 550Publish Web, 554skrypty SQL, 552uruchamianie procesu publikowania, 553

Web Form, 727web forms, 737Web Part, 776Web Platform Installer, 33Web Reference Name, 1035Web Role, 64Web Service, 727Web Service Description Language, 1016Web Service Enhancements, 1016Web Site, 907, 1017Web Site Administration Tool, 796Web User Control, 727, 802web.config, 55, 716, 717, 1018, 1050WebForm, 44

1257

Skorowidz

WebMethod, 1027webnamespace, 335WebPartManager, 777, 779WebPartManagerMain.Personalization.�ResetPersonalizationState(), 788

WebPartZone, 777, 779WebRole.cs, 1170WebService, 1020, 1027WebServiceAttribute, 1027Website, 90wersje Visual Studio 2010, 31WF, 23, 72, 177, 1062, 1063When Breakpoint Is Hit, 504When Hit, 503, 504Where, 163WHERE, 909while, 140While, 140, 1083, 1084wiadomości związane ze środowiskiem, 306wiązanie danych, 861, 909, 974

aplikacje sieciowe, 989aplikacje WPF, 986automatyczne generowanie związanych

kontrolek Windows Forms, 976DataGridView, 983DataList, 990DetailsView, 989dostosowywanie odwzorowania źródła danych, 980FormView, 989GridView, 989, 990kontrolki sieciowe, 989kontrolki źródła danych, 993modyfikacja zapytania dla źródła danych, 985modyfikacja zbiorów danych o określonym

typie, 981odwzorowywanie źródeł danych na kontrolki, 978proces wiązania danych, 975Repeater, 989ręczne wiązanie kontrolek formularzy

Windows, 982wiązanie kontrolek, 986wybór obiektów źródła danych, 978wybór źródła danych, 976XAML, 987złożone wiązanie danych, 975zmiana odwzorowywania danych tabeli, 979

wiązanie danych w WPF, 881DataContext, 882kontekst danych, 882System.Windows.Data.Binding, 881

widok, 806, 807widok Split, 56widoki (baza danych), 955wielozadaniowość, 523Win32_ComputerSystem, 226Win32_Desktop, 226Win32_LogicalDisk, 226Win32_NetworkAdapter, 226Win32_NetworkConnection, 226Win32_NTEventLogFile, 226Win32_OperatingSystem, 226Win32_Printer, 226Win32_Process, 226Win32_Processor, 226Win32_Product, 226Win32_Service, 226Win32_Share, 226Win32_SystemAccount, 226Win32_Thread, 226Window, 93, 563, 572, 573, 592

CommandBars, 590LinkedWindows, 586składowe, 573WindowFrame, 586

Window2, 563WindowHiding, 627Windows, 563, 588Windows Application, 203, 826, 976Windows Azure, 63, 1158Windows Azure Activity Log, 1204Windows Azure Cloud Service, 1165, 1166, 1170Windows Communication Foundation, 23, 74Windows Control Library, 854Windows Form Application, 46Windows Forms, 272, 822Windows Forms Designer, 275Windows Forms Designer Options, 275Windows Forms User Control, 1141Windows Live, 318Windows Management Instrumentation, 226Windows Presentation Foundation, 23, 44, 271, 860Windows Process Activation Service, 76, 1059, 1118Windows Workflow, 72, 1062, 1063

aplikacje klienckie, 1064CodeActivity, 1063czynności Collection, 1086czynności Control Flow, 1083czynności Error Handling, 1086czynności Flowchart, 1094czynności Messaging, 1089

1258

Skorowidz

Windows Workflowczynności Primitives, 1084czynności procesów, 1082czynności Runtime, 1084czynności związane z komunikatami, 1089komunikaty, 73NativeActivity, 1063obsługa transakcji, 1087okno projektowe procesów, 1067pamięć trwała, 1117proces, 72, 1063proces hosta, 1063projektowanie procesu, 73projekty, 1065silnik uruchomieniowy procesu, 1064składniki procesu, 1063sposoby komunikowania się z pamięcią trwałą, 1118stan, 73sterowanie przepływem, 1083szablony elementów procesów, 1068szablony projektów, 1065tworzenia procesów, 1069usługi uruchomieniowe procesu, 1064zarządzanie komunikatami, 1089zbiory działań, 72

Windows Workflow Foundation, 23, 1062, 1063Windows2, 563, 659

CreateLinkedWindowFrame, 586WindowsBase.dll, 860WindowsDefaultBounds, 828WindowsDefaultLocation, 828WindowVisibilityEvents, 627, 628WinForm, 44WinForms, 271With, 153witryny ASP.NET, 54, 714, 715

ASP.NET Development Server, 719ASP.NET Reports Web Site, 717ASP.NET Web Service, 716ASP.NET Web Site, 716dodawanie plików, 728dodawanie stron internetowych, 737Dynamic Data Entities Web Site, 717Dynamic Data Linq to SQL Web Site, 717Empty Web Site, 717IIS, 718język programowania, 724katalogi, 725kompozycje, 770komunikacja z serwerem sieciowym przy użyciu

protokołu HTTP, 723

lokalny egzemplarz IIS, 720mapa witryny, 728opcje projektu, 729pliki, 727położenie witryny, 717serwer roboczy, 719, 720skórki, 728, 770SSL, 722Starter Kit, 717struktura witryny, 725szablony, 716tworzenie, 715tworzenie jednolitego wyglądu i zachowania, 754udostępnianie witryny przy użyciu protokołu

FTP, 722WCF Service, 717właściwości, 729

Wizard, 793WizardDialog, 681

Category, 681ClassName, 681

wizardResult, 679wizardResultBackOut, 679wizardResultCancel, 679wizardResultFailure, 679wizardResultSuccess, 679wizualizacja danych, 510wkład w społeczność, 332

pakiety startowe, 333szablony, 333tworzenie szablonów projektów, 333

wkraczanie w kod, 488, 489właściwości, 115, 166

definiowanie, 298właściwości formularzy Windows, 827właściwości konfiguracji kompilacji, 193właściwości projektu, 204

Application, 205Build, 206Build Events, 206Compile, 207Debug, 207Publish, 208Reference Paths, 208References, 208Resources, 208Security, 208Settings, 208Signing, 209

1259

Skorowidz

właściwości rozwiązania, 190włączanie diagnozowania stron internetowych, 470WMI, 226, 227Word 2007 Document, 1136Word 2010, 51Workbook, 51Worker, 1164Worker Role, 1167workflow application, 1062Workflow Console Application, 1065, 1066, 1069WorkflowApplication, 1074WorkflowInvoker, 1074WorkflowInvoker.Invoke, 1074, 1080, 1081WorkflowServiceHost, 1075WPF, 23, 44, 47, 61, 62, 177, 271, 280, 860, 923

animacja, 862Application, 863architektura platformy, 861biblioteka klas, 863Button, 863Canvas, 871Control, 863ControlTemplate, 879DispatcherObject, 863DockPanel, 872DocumentReader, 862dostosowywanie wyglądu kontrolek, 878FlowDocumentReader, 862formularze, 49, 874Grid, 874Grid.ColumnDefinitions, 874język XAML, 863kontrolki kontenerowe, 871media, 861model programowania, 863obsługa czcionek, 862obsługa dokumentów, 862okna dialogowe, 874, 875okno projektowe, 865panele, 871połączenie kontrolki ze źródłem danych, 881projekt, 48przypisywanie stylu, 879StackPanel, 876style, 878Style, 878szablony, 878, 879TextBlock, 880tworzenie aplikacji, 871tworzenie kodu, 48

tworzenie układu, 871Visual, 863, 879wiązanie danych, 861, 881WrapPanel, 877współdziałanie z formularzami Windows, 861wygląd kontrolek, 862wypełnienie gradientem, 879XAML, 48zdarzenia przekazywane, 883zmiana szablonu przycisku, 880znaczniki, 48

WPF Application, 48, 280, 866WPF Browser Application, 48, 923WPF Custom Control Library, 49WPF User Controls, 49wpisywanie kodu, 363WrapPanel, 871, 877, 885WriteLine, 1085WS-*, 1016WSAT, 796WSDL, 1012, 1016, 1029WSDL.exe, 1030WSE, 1016wskazówki, 841wskazówki dotyczące problemów, 364wspólna specyfikacja języka, 40wspólne środowisko uruchomieniowe, 40wspólny system typów, 40współużytkowane zasoby, 328

instalacja udostępnianych zasobów, 330przechowywanie udostępnianych zasobów, 330rodzaje współużytkowanych danych, 329wyszukiwanie szablonów według technologii, 329wyszukiwanie zasobów, 328

współużytkowanie makr, 618wstawianie fragmentów kodu, 381wstawianie komentarzy do okna z tekstem, 601wstążka, 1133

dodawanie elementów, 1139elementy, 1139grupy, 1139modyfikacja, 1137obsługa zdarzeń kontrolek, 1141powierzchnia projektowa, 1138Ribbon (Visual Designer), 1137Ribbon (XML), 1137zakładki, 1139

wstrzymywanie kodu, 260wybór docelowego środowiska, 86wybór katalogu, 895

1260

Skorowidz

wybór źródła danych, 976, 977, 990wygląd kontrolek, 840wygląd strony w przeglądarce, 288wyjątki, 146, 422, 474

usługi sieciowe, 1039wykonywanie poleceń, 606

obiektowy model automatyzacji, 583wykresy, 800, 801wykrywanie typu zmiennej na podstawie

przypisania, 151wyliczenia, 120wyniki testów jednostek, 407

testy jednostek zależne od danych, 427wyniki zapytania SQL, 953wyodrębnianie interfejsów, 459

Extract Interface, 459wyodrębnianie metod, 450, 451

Extract Method, 451generowanie szkieletu metody, 457wyodrębnianie pojedynczych wierszy kodu, 456

wyrażenia lambda, 162, 163WYSIWYG, 55wyspy danych, 1150, 1151wyszukiwanie przyrostowe, 257, 577wyszukiwanie symboli, 256wyszukiwanie szablonów według technologii, 329wyszukiwanie tekstu w plikach, 253wyszukiwanie testów, 435wyświetlanie danych, 849

dane hierarchiczne, 849dane tabelaryczne, 852DataGridView, 852ImageList, 850TreeView, 849

wyświetlaniedokumenty tekstowe, 596kontrolki użytkownika, 660metody sieciowe, 1031okna narzędzi, 660podpowiedzi DataTip, 508referencje sieciowe, 1036

wywoływaniemakra, 629metody sieciowe, 1032metody z klasy bazowej, 122procesy, 1074usługi sieciowe, 1037

wyzwalacze, 960tworzenie, 960

wzbogacanie pakietu Microsoft Office, 1149wzbogacanie środowiska, 688wzorzec MVC, 805

X

XAML, 44, 48, 53, 61, 271, 280, 863, 866procesy, 1069składnia, 864wiązanie danych, 987współpraca między członkami zespołu

projektowego, 865XAML Browser Application, 48, 922XBAP, 48, 904, 922, 923Xbox, 45XDocument, 165XDR, 264, 265XElement, 165XHTML, 55, 288XML, 164, 165, 993, 1016XML (kontrolka ASP.NET), 793XML Schema Document, 1016XML Schema Explorer, 265, 266XML Schemat Document, 265XML-Data Reduced, 264XmlDataSource, 800XMLDataSource, 993XmlSerializer, 1151xml-stylesheet, 270XNA, 45Xor, 136XSD, 264, 265, 343, 1016XSLT, 269

Y

year, 335

Z

zachowanie kontrolek, 840zadania, 523, 579

przełączanie stanu ukończenia zadań, 580zadania użytkownika, 396zadania związane z komentarzami, 394

HACK, 394niestandardowe znaczniki w komentarzach, 395TODO, 394UNDONE, 394

1261

Skorowidz

zadania związane ze skrótami, 395zagnieżdżanie kontrolek użytkownika, 855zagnieżdżanie stron wzorcowych, 769zakładki, 247, 594

dodawanie, 247katalogi, 248

zależności projektu, 191zapisywanie

komunikat XML, 165obrazy, 891proces, 1077

zapytania LINQ, 156, 160, 994Entity Framework, 1006funkcje anonimowe, 162operatory, 161Order by, 163Select, 163Where, 163wyrażenia lambda, 162, 163

zapytania SQL, 951DELETE, 955diagram, 953dopracowywanie zapytań, 953INSERT, 954, 955JOIN, 954kod SQL, 953kryteria, 953SELECT, 953, 955tworzenie, 951tworzenie tabel, 955UPDATE, 955wyniki, 953złączenia, 954

zarządzanie aplikacją, 226zarządzanie arkuszami stylów, 287zarządzanie cyklem życia aplikacji, 36zarządzanie dodatkami, 653zarządzanie etykietami punktów, 499zarządzanie grupami elementów, 141zarządzanie komunikatami, 1089zarządzanie makrami, 614zarządzanie projektami, 37, 218zarządzanie projektami baz danych, 969zarządzanie przypadkami testowymi, 37zarządzanie punktami przerwania, 496, 498zarządzanie rozwiązaniami, 217zarządzanie stylami CSS, 287, 760zarządzanie ustawieniami systemu pomocy, 312zarządzanie ustawieniami środowiska IDE, 80zarządzanie wieloma oknami środowiska IDE, 105zarządzanie wymaganiami, 37

zarządzanie wynikami testów, 411zarządzanie zabezpieczeniami, 226zarządzanie zdalnymi usługami, 225zasady stylów, 755zasoby współużytkowane, 328zatrzymywanie kodu, 260zaznaczanie tekstu, 237zbiory działań, 72zbiór danych, 67

dostęp do danych, 67tworzenie, 67

zbiór danych o określonym typie, 981zdalne diagnozowanie, 513

monitor zdalnego diagnozowania, 513msvsmon.exe, 513rdbsetup.exe, 513Remote Debugging Monitor, 513uprawnienia, 513

zdarzenia, 147, 227aplikacje Windows, 47ASP.NET, 741definiowanie, 148, 298DTEEvents, 628EventArgs, 148EventHandler, 147, 149formularze Windows, 827, 828makra, 623obiektowy model automatyzacji, 608obsługa, 149OnPaint, 857strony ASP.NET, 743subskrybowanie, 149tworzenie, 147zgłaszanie, 149

zdarzenia przekazywane, 883zdarzenia bezpośrednie, 883zdarzenia przesyłane w dół, 883zdarzenia przesyłane w górę, 883

zegar, 274zestaw testów, 398zgłaszanie błędów, 323, 324zgłaszanie zdarzeń, 147, 149Zip to Exe Conversion Tool, 349złączenia, 954złożone wiązanie danych, 975zmiana

format przechowywania projektu makr, 619kolejność parametrów, 463rozmiar kontrolek, 277wersja platformy .NET, 87

1262

Skorowidz

zmiana nazw, 446Object Browser, 447Rename, 447, 449Solution Explorer, 447

zmienne, 130deklaracja, 131niejawne określanie typu, 151rzutowanie, 132wykrywanie typu zmiennej na podstawie

przypisania, 151zmień i kontynuuj, 511znaczniki HTML, 285zrzut informacji diagnostycznych, 527Zune, 71związki tabel, 948

jeden do jednego, 950wiele do wielu, 950związki zwrotne, 950

Ź

źródło danych, 852, 909, 976AccessDataSource, 993Database, 977dostosowywanie odwzorowania, 980kontrolki, 993ObjectDataSource, 993SiteMapDataSource, 993SqlDataSource, 993wybór obiektów, 978wybór źródła danych, 976XMLDataSource, 993

Ż

żądania HTTP, 807żądania SOAP, 1031

Microsoft Visual Studio - Helionpdf.helion.pl/vs21ke/vs21ke.pdf · rozszerzenia środowiska IDE...

Documents

Transcript of Microsoft Visual Studio - Helionpdf.helion.pl/vs21ke/vs21ke.pdf · rozszerzenia środowiska IDE...