Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00152 013973 11052404 na godz. na dobę w sumie
ASP.NET 2.0. Projektowanie aplikacji internetowych - książka
ASP.NET 2.0. Projektowanie aplikacji internetowych - książka
Autor: Liczba stron: 928
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1128-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj nowoczesne technologie tworzenia aplikacji sieciowych

Wprowadzenie na rynek technologii .NET 2.0 zrewolucjonizowało sposób projektowania i tworzenia aplikacji internetowych. Arsenał programistów wzbogacił się o narzędzia cechujące się niespotykaną dotychczas wydajnością i elastycznością. Potężna biblioteka gotowych komponentów, nowe mechanizmy dostępu do danych, udoskonalone techniki zabezpieczania i personalizowania aplikacji oraz ich uruchamiania w środowisku produkcyjnym -- wszystko to sprawiło, że budowanie nowoczesnych systemów działających w sieci stało się łatwe i szybkie. Jednak wraz ze wzrostem możliwości wzrosła także ilość wiedzy, którą musi przyswoić sobie programista zamierzający korzystać z technologii .NET 2.0.

Książka 'ASP.NET 2.0. Projektowanie aplikacji internetowych' to doskonały podręcznik, za którego pomocą opanujesz niesamowite możliwości platformy .NET 2.0 w zakresie budowania systemów sieciowych. Dowiesz się, jak działają aplikacje ASP.NET, jak tworzyć formularze na stronach WWW i korzystać ze standardowych kontrolek udostępnianych przez platformę .NET 2.0. Nauczysz się łączyć aplikacje z bazami danych za pomocą mechanizmu ADO.NET oraz wyświetlać dane na stronach z wykorzystaniem kontrolek. Przeczytasz także o technikach projektowania złożonych aplikacji, o zarządzaniu sesjami, zabezpieczaniu aplikacji, stosowaniu mechanizmów personalizacji oraz wdrażaniu aplikacji w środowisku produkcyjnym.

Opanuj do perfekcji zasady wykorzystywania technologii .NET 2.0
w programowaniu aplikacji sieciowych!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

ASP.NET 2.0. Projektowanie aplikacji internetowych Autor: Randy Connolly T‡umaczenie: Pawe‡ Gonera, Ireneusz Jak(cid:243)bik ISBN: 978-83-246-1128-7 Tytu‡ orygina‡u: Core Internet Application Development with ASP.NET 2.0 Format: B5, stron: 928 oprawa twarda Poznaj nowoczesne technologie tworzenia aplikacji sieciowych (cid:149) Jak wykorzystywa(cid:230) kontrolki .NET? (cid:149) W jaki spos(cid:243)b pobiera(cid:230) i wy(cid:156)wietla(cid:230) dane z bazy? (cid:149) Jak zabezpiecza(cid:230) i personalizowa(cid:230) aplikacje? Wprowadzenie na rynek technologii .NET 2.0 zrewolucjonizowa‡o spos(cid:243)b projektowania i tworzenia aplikacji internetowych. Arsena‡ programist(cid:243)w wzbogaci‡ siŒ o narzŒdzia cechuj„ce siŒ niespotykan„ dotychczas wydajno(cid:156)ci„ i elastyczno(cid:156)ci„. PotŒ¿na biblioteka gotowych komponent(cid:243)w, nowe mechanizmy dostŒpu do danych, udoskonalone techniki zabezpieczania i personalizowania aplikacji oraz ich uruchamiania w (cid:156)rodowisku produkcyjnym (cid:150) wszystko to sprawi‡o, ¿e budowanie nowoczesnych system(cid:243)w dzia‡aj„cych w sieci sta‡o siŒ ‡atwe i szybkie. Jednak wraz ze wzrostem mo¿liwo(cid:156)ci wzros‡a tak¿e ilo(cid:156)(cid:230) wiedzy, kt(cid:243)r„ musi przyswoi(cid:230) sobie programista zamierzaj„cy korzysta(cid:230) z technologii .NET 2.0. Ksi„¿ka (cid:132)ASP.NET 2.0. Projektowanie aplikacji internetowych(cid:148) to doskona‡y podrŒcznik, za kt(cid:243)rego pomoc„ opanujesz niesamowite mo¿liwo(cid:156)ci platformy .NET 2.0 w zakresie budowania system(cid:243)w sieciowych. Dowiesz siŒ, jak dzia‡aj„ aplikacje ASP.NET, jak tworzy(cid:230) formularze na stronach WWW i korzysta(cid:230) ze standardowych kontrolek udostŒpnianych przez platformŒ .NET 2.0. Nauczysz siŒ ‡„czy(cid:230) aplikacje z bazami danych za pomoc„ mechanizmu ADO.NET oraz wy(cid:156)wietla(cid:230) dane na stronach z wykorzystaniem kontrolek. Przeczytasz tak¿e o technikach projektowania z‡o¿onych aplikacji, o zarz„dzaniu sesjami, zabezpieczaniu aplikacji, stosowaniu mechanizm(cid:243)w personalizacji oraz wdra¿aniu aplikacji w (cid:156)rodowisku produkcyjnym. (cid:149) Tworzenie formularzy (cid:149) Model zdarzeæ ASP.NET (cid:149) Stosowanie kontrolek serwera .NET (cid:149) Obs‡uga wyj„tk(cid:243)w (cid:149) Zarz„dzanie wygl„dem witryny WWW (cid:149) Operacje na danych z wykorzystaniem ADO.NET (cid:149) Projektowanie aplikacji .NET (cid:149) Uwierzytelnianie u¿ytkownik(cid:243)w (cid:149) Tworzenie us‡ug sieciowych (cid:149) Technologia ASP.NET AJAX Opanuj do perfekcji zasady wykorzystywania technologii .NET 2.0 w programowaniu aplikacji sieciowych! Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści O autorze ..................................................................................................................................................15 Wstęp ........................................................................................................................................................17 Część I ASP.NET 23 Rozdział 1. Wstęp do ASP.NET .................................................................................................................. 25 Dlaczego ASP.NET? ...................................................................................................... 25 Statyczna a dynamiczna zawartość stron WWW ......................................................... 26 Konkurencyjne dynamiczne technologie serwera ........................................................ 26 Zalety ASP.NET ....................................................................................................... 29 .NET Framework ........................................................................................................... 30 Składniki .NET Framework ....................................................................................... 31 Wykonywanie .NET .................................................................................................. 35 Formularze WWW ASP.NET ............................................................................................ 36 Język C# ................................................................................................................ 40 Struktura aplikacji internetowej ................................................................................ 41 Visual Studio 2005 ...................................................................................................... 43 Projekty WWW Visual Studio .................................................................................... 45 Opcje serwera WWW ............................................................................................... 45 Samouczek: tworzenie formularzy WWW ASP.NET ........................................................... 48 Tworzenie witryny WWW w Visual Studio .................................................................... 48 Dodawanie nowego formularza WWW ........................................................................ 50 Dodawanie kodu HTML do formularza WWW .............................................................. 50 Dodawanie logiki programowej ................................................................................. 57 Obsługa błędów ...................................................................................................... 60 Użycie debugera Visual Studio ................................................................................. 63 Podsumowanie ............................................................................................................ 66 Ćwiczenia .................................................................................................................... 66 Najważniejsze zagadnienia ............................................................................................ 66 Odnośniki .................................................................................................................... 67 6 ASP.NET 2.0. Projektowanie aplikacji internetowych Rozdział 2. Sposób działania ASP.NET ....................................................................................................69 Model zdarzeń ASP.NET ................................................................................................ 69 Przesłanie danych ................................................................................................... 71 Stan widoku oraz stan kontrolki ............................................................................... 73 Cykl życia strony ..................................................................................................... 74 Kompilacja kodu ASP.NET ............................................................................................. 85 Kolejność kompilacji ............................................................................................... 88 Klasa Page .................................................................................................................. 90 Request ................................................................................................................. 90 Response ............................................................................................................... 91 Server .................................................................................................................... 92 Cykl życia aplikacji ASP.NET .......................................................................................... 93 Użytkownik żąda przesłania zasobu ASP.NET z serwera .............................................. 93 Tworzenie podstawowych obiektów ASP.NET dla żądania ............................................ 98 Przypisywanie obiektu HttpApplication do żądania ...................................................... 99 Przetwarzanie żądania z użyciem potoku HttpApplication .......................................... 101 Podsumowanie .......................................................................................................... 104 Ćwiczenia .................................................................................................................. 104 Najważniejsze zagadnienia .......................................................................................... 104 Odnośniki .................................................................................................................. 105 Rozdział 3. Wykorzystanie standardowych kontrolek serwera WWW .............................................107 Wprowadzenie do kontrolek serwera ............................................................................ 107 Kontrolki HTML serwera ......................................................................................... 108 Kontrolki serwera WWW ......................................................................................... 108 Kontrolki sprawdzające poprawność ....................................................................... 108 Kontrolki użytkownika ............................................................................................ 109 Własne kontrolki serwera ....................................................................................... 109 Przegląd kontrolek serwera WWW ................................................................................ 109 Wspólne składniki ................................................................................................. 109 Programowe manipulowanie właściwościami ........................................................... 113 Najważniejsze standardowe kontrolki serwera WWW ..................................................... 115 Kontrolka Label .................................................................................................... 115 Kontrolka Literal ................................................................................................... 117 Kontrolka TextBox ................................................................................................. 119 Kontrolki przycisków .............................................................................................. 122 Kontrolka CheckBox .............................................................................................. 128 Kontrolka RadioButton .......................................................................................... 131 Kontrolki list ......................................................................................................... 132 Kontrolka Image ................................................................................................... 141 Kontrolka ImageMap ............................................................................................. 143 Kontrolka HyperLink .............................................................................................. 146 Kontrolka HiddenField ........................................................................................... 147 Kontrolka Table .................................................................................................... 149 Kontrolka Calendar ............................................................................................... 156 Podsumowanie .......................................................................................................... 171 Ćwiczenia .................................................................................................................. 171 Najważniejsze zagadnienia .......................................................................................... 172 Odnośniki .................................................................................................................. 172 Spis treści 7 Rozdział 4. Dodatkowe standardowe kontrolki serwera WWW .........................................................173 Przegląd dodatkowych standardowych kontrolek serwera WWW ...................................... 173 Kontrolka Panel ......................................................................................................... 175 Kontrolki MultiView oraz View ...................................................................................... 182 Nawigacja pomiędzy widokami ............................................................................... 185 Tworzenie paneli z zakładkami przy użyciu MultiView ................................................ 185 Kontrolka Wizard ........................................................................................................ 190 Zastosowanie kontrolki Wizard ............................................................................... 194 Opis układu kreatora Wizard .................................................................................. 196 Dostosowywanie kreatora ...................................................................................... 198 Obsługa zdarzeń kreatora ...................................................................................... 206 Kontrolka FileUpload .................................................................................................. 208 Przetwarzanie przesłanego pliku ............................................................................. 211 Ograniczanie wielkości przesyłanego pliku ............................................................... 212 Kontrolka PlaceHolder ................................................................................................ 212 Tworzenie przeglądarki plików ................................................................................ 213 Kontrolka AdRotator ................................................................................................... 220 Plik XML z danymi reklam ...................................................................................... 221 Wyświetlanie reklam z bazy danych ......................................................................... 222 Programowanie kontrolki AdRotator ........................................................................ 223 Kontrolka XML ........................................................................................................... 224 Tworzenie pliku XSLT ............................................................................................. 226 Programowanie kontrolki XML ................................................................................ 228 Podsumowanie .......................................................................................................... 233 Ćwiczenia .................................................................................................................. 235 Najważniejsze zagadnienia .......................................................................................... 236 Odnośniki .................................................................................................................. 236 Rozdział 5. Obsługa wyjątków i kontrolki sprawdzania poprawności ..............................................237 Obsługa błędów ......................................................................................................... 237 Obsługa wyjątków .NET .......................................................................................... 238 Obsługa wyjątków na poziomie klasy przy wykorzystaniu bloku try…catch .................. 239 Obsługa wyjątków na poziomie strony ..................................................................... 242 Obsługa wyjątków na poziomie aplikacji .................................................................. 243 Użycie kontrolek serwera sprawdzających poprawność .................................................. 249 Proces kontroli poprawności formularza w ASP.NET ................................................. 251 Kontrolka RequiredFieldValidator ............................................................................ 257 Kontrolka ValidationSummary ................................................................................ 258 Kontrolka CompareValidator .................................................................................. 260 Kontrolka RangeValidator ...................................................................................... 262 Kontrolka RegularExpressionValidator ..................................................................... 263 Kontrolka CustomValidator .................................................................................... 270 Grupy kontroli poprawności .................................................................................... 275 Podsumowanie .......................................................................................................... 280 Ćwiczenia .................................................................................................................. 280 Najważniejsze zagadnienia .......................................................................................... 282 Odnośniki .................................................................................................................. 282 8 ASP.NET 2.0. Projektowanie aplikacji internetowych Rozdział 6. Dostosowywanie wyglądu witryny i zarządzanie nim ....................................................283 Zmiana wyglądu kontrolek serwera .............................................................................. 283 Zastosowanie wspólnych właściwości formatujących ................................................ 283 Użycie CSS dla kontrolek ....................................................................................... 285 Właściwości wyglądu, CSS i ASP.NET ...................................................................... 290 Użycie tematów i motywów .......................................................................................... 290 Definiowanie motywów .......................................................................................... 292 Tworzenie tematów w Visual Studio ........................................................................ 292 Stosowanie tematu ............................................................................................... 294 Jak działają tematy ................................................................................................ 294 Przesłanianie tematów .......................................................................................... 295 Motywy nazwane ................................................................................................... 296 Tematy i obrazy ..................................................................................................... 297 Tematy i CSS ........................................................................................................ 297 Dynamiczne ustawianie tematu .............................................................................. 300 Tworzenie przykładowej strony z dwoma tematami ................................................... 302 Strony wzorcowe ........................................................................................................ 310 Definiowanie strony wzorcowej ............................................................................... 313 Zagnieżdżone strony wzorcowe ............................................................................... 316 Jak działają strony wzorcowe? ................................................................................ 318 Programowanie strony wzorcowej ........................................................................... 320 Strony wzorcowe i tematy ...................................................................................... 322 Kontrolki użytkownika ................................................................................................. 328 Tworzenie i modyfikacja kontrolek użytkownika ........................................................ 328 Dodawanie danych i funkcji do kontrolki użytkownika ............................................... 330 Podsumowanie .......................................................................................................... 331 Ćwiczenia .................................................................................................................. 332 Najważniejsze zagadnienia .......................................................................................... 333 Odnośniki .................................................................................................................. 333 Rozdział 7. Nawigacja w witrynie ASP.NET ..........................................................................................335 Przedstawienie nawigacji w witrynie ASP.NET ................................................................ 335 Model dostawcy .................................................................................................... 337 Mapa witryny XML ...................................................................................................... 337 Korzystanie z mapy witryny XML ............................................................................. 340 Programowanie mapy witryny ................................................................................. 343 Korzystanie z różnych map witryny .......................................................................... 345 Inne funkcje mapy witryny ...................................................................................... 348 Kontrolka SiteMapPath ............................................................................................... 348 Nadawanie stylu kontrolce SiteMapPath ................................................................. 349 Integracja ciągów zapytania z SiteMapPath ............................................................. 353 Kontrolka Menu ......................................................................................................... 356 Zastosowanie kontrolki Menu ................................................................................ 358 Zmiana wyglądu kontrolki Menu ............................................................................. 361 Obsługa zdarzeń menu .......................................................................................... 369 Kontrolka TreeView ..................................................................................................... 375 Opis kontrolki TreeView ......................................................................................... 376 Zastosowanie kontrolki TreeView ............................................................................ 378 Zmiana wyglądu kontrolki TreeView ........................................................................ 380 Zastosowanie innych danych w kontrolce TreeView .................................................. 382 Odpowiadanie na zdarzenia kontrolki TreeView ........................................................ 386 Spis treści 9 Podsumowanie .......................................................................................................... 392 Ćwiczenia .................................................................................................................. 392 Najważniejsze zagadnienia .......................................................................................... 392 Odnośniki .................................................................................................................. 394 Część II Operacje na danych 395 Rozdział 8. Łączenie i reprezentacja danych ......................................................................................397 Podstawy dołączania danych ....................................................................................... 397 Jak korzystać z dołączania danych? ........................................................................ 398 Co może być źródłem danych? ............................................................................... 398 Wykorzystanie kolekcji ................................................................................................ 400 Interfejsy kolekcji .................................................................................................. 400 Użycie standardowych kolekcji ............................................................................... 401 ArrayList ............................................................................................................... 405 Typy ogólne .......................................................................................................... 408 Kolekcje słownikowe ............................................................................................. 412 Tworzenie własnych kolekcji ogólnych ..................................................................... 414 DataSet ..................................................................................................................... 418 Użycie obiektu DataTable ....................................................................................... 419 Zastosowanie obiektu DataSet ............................................................................... 425 Relacje między obiektami DataTable ....................................................................... 429 Integracja XML z DataSet ....................................................................................... 431 Wybór kontenera danych ............................................................................................. 438 Kolekcje .NET jako kontenery danych ...................................................................... 439 Własne kolekcje jako kontenery danych .................................................................. 439 Obiekty DataSet jako kontenery danych .................................................................. 440 Typowane obiekty DataSet jako kontenery danych ................................................... 441 Podsumowanie .......................................................................................................... 442 Ćwiczenia .................................................................................................................. 442 Najważniejsze zagadnienia .......................................................................................... 443 Odnośniki .................................................................................................................. 443 Rozdział 9. Zastosowanie ADO.NET .......................................................................................................445 Wprowadzenie do ADO.NET ......................................................................................... 445 Wybór dostawcy danych ......................................................................................... 449 Klasy dostawcy danych .......................................................................................... 449 Klasy DbConnection ................................................................................................... 450 Ciągi połączenia .................................................................................................... 450 Programowanie DbConnection ................................................................................ 451 Przechowywanie ciągów połączenia ......................................................................... 454 Pule połączeń ....................................................................................................... 455 Klasy DbCommand ..................................................................................................... 455 Tworzenie obiektu DbCommand ............................................................................. 456 Polecenia SQL do pobierania, dodawania, modyfikowania i usuwania danych ............. 457 Procedury składowane ........................................................................................... 458 Wykonywanie połączeń za pomocą obiektu DbCommand .......................................... 459 Wykorzystanie klasy DbParameter .......................................................................... 460 Użycie transakcji ................................................................................................... 463 10 ASP.NET 2.0. Projektowanie aplikacji internetowych Klasy DbDataReader .................................................................................................. 467 Programowanie DbDataReader ............................................................................... 468 Niejawne zamykanie połączenia ............................................................................. 470 Samouczek: odczytywanie i modyfikowanie danych .................................................. 471 Klasy DbDataAdapter .................................................................................................. 479 Wypełnianie obiektu DataSet ................................................................................. 480 Modyfikowanie danych ........................................................................................... 483 Tworzenie kodu ADO.NET niezależnego od dostawcy danych .......................................... 485 Kontrolki źródła danych ............................................................................................... 488 Użycie parametrów ................................................................................................ 491 Modyfikowanie danych ........................................................................................... 494 Jak działają kontrolki źródeł danych? ...................................................................... 494 Użycie ObjectDataSource ....................................................................................... 495 Podsumowanie .......................................................................................................... 505 Ćwiczenia .................................................................................................................. 505 Najważniejsze zagadnienia .......................................................................................... 506 Odnośniki .................................................................................................................. 507 Rozdział 10. Kontrolki danych ...............................................................................................................509 Wprowadzenie do wielowartościowych kontrolek danych ................................................ 509 Zrozumieć szablony ............................................................................................... 513 Wyrażenia wiązania danych .................................................................................... 513 Kontrolka DataList ..................................................................................................... 517 Używanie szablonów ogólnych ................................................................................ 520 Łączenie stron za pomocą kontrolki DataList ........................................................... 523 Kontrolka Repeater .................................................................................................... 524 Kontrolka FormView .................................................................................................... 526 Przechodzenie między rekordami ............................................................................ 529 Modyfikowanie danych ........................................................................................... 532 Kontrolka DetailsView ................................................................................................. 540 Dostosowywanie pól kontrolki DetailsView .............................................................. 541 Modyfikowanie danych kontrolki DetailsView ........................................................... 546 Kontrolka GridView ..................................................................................................... 550 Dostosowywanie kolumn kontrolki GridView ............................................................ 550 Wybieranie wierszy ................................................................................................ 560 Stronicowanie w kontrolce GridView ........................................................................ 565 Sortowanie w kontrolce GridView ............................................................................ 568 Edycja danych w kontrolce GridView ........................................................................ 570 Pozostałe funkcje kontrolki GridView ....................................................................... 574 Podsumowanie .......................................................................................................... 581 Ćwiczenia .................................................................................................................. 581 Najważniejsze zagadnienia .......................................................................................... 582 Odnośniki .................................................................................................................. 583 Rozdział 11. Projektowanie oraz implementacja aplikacji sieciowych ..............................................585 Projektowanie aplikacji ............................................................................................... 586 Korzystanie z warstw ............................................................................................. 587 Skutki podziału na warstwy .................................................................................... 589 Model dwuwarstwowy ................................................................................................. 590 Spis treści 11 Model trójwarstwowy .................................................................................................. 592 Projektowanie oraz implementacja obiektu biznesowego .......................................... 594 Programowe używanie obiektu biznesowego ............................................................ 602 Używanie obiektów biznesowych z kontrolką ObjectDataSource ................................. 603 Model czterowarstwowy .............................................................................................. 606 Projektowanie architektury czterowarstwowej ........................................................... 606 Modyfikowanie warstwy dostępu do danych ............................................................. 609 Tworzenie złożonej encji domeny ............................................................................ 613 Tworzenie warstwy logiki aplikacji ........................................................................... 615 Użycie architektury w warstwie prezentacji ............................................................... 618 Podsumowanie .......................................................................................................... 627 Ćwiczenia .................................................................................................................. 628 Najważniejsze zagadnienia .......................................................................................... 628 Odnośniki .................................................................................................................. 629 Rozdział 12. Zarządzanie stanem w środowisku ASP.NET ...................................................................631 Stan przechowywany po stronie klienta ........................................................................ 632 Stan widoku ......................................................................................................... 632 Stan kontrolek ...................................................................................................... 636 Pola ukryte ........................................................................................................... 636 Łańcuchy zapytań .................................................................................................. 636 Cookies ............................................................................................................... 637 Stan aplikacji ............................................................................................................. 638 Plik Global.asax .................................................................................................... 639 Stan sesji .................................................................................................................. 641 Jak działa stan sesji? ............................................................................................ 642 Dostawcy stanu sesji ............................................................................................ 644 Właściwości profilu ............................................................................................... 650 Pamięć podręczna środowiska ASP.NET ....................................................................... 650 Buforowanie danych aplikacji ................................................................................. 651 Zależności pamięci podręcznej ............................................................................... 655 Buforowanie zwracanych stron ............................................................................... 657 Podsumowanie .......................................................................................................... 660 Ćwiczenia .................................................................................................................. 660 Najważniejsze zagadnienia .......................................................................................... 661 Odnośniki .................................................................................................................. 661 Część III Implementacja aplikacji sieciowych 663 Rozdział 13. Bezpieczeństwo, członkostwo i zarządzanie rolami ......................................................665 Wprowadzenie do zagadnień bezpieczeństwa w środowisku ASP.NET ............................. 666 Omówienie bezpieczeństwa w serwerze IIS .............................................................. 667 Proces bezpieczeństwa w środowisku ASP.NET ....................................................... 670 Bezpieczeństwo bazujące na uprawnieniach kodu oraz poziomy zaufania środowiska ASP.NET ........................................................................................... 672 Uwierzytelnianie w środowisku ASP.NET .................................................................. 675 Uwierzytelnianie formularzy ......................................................................................... 676 Korzystanie z uwierzytelniania formularzy ................................................................ 676 Tworzenie formularza logowania ............................................................................. 679 Jak działa uwierzytelnianie formularzy? ................................................................... 684 Używanie biletów uwierzytelniania bez cookies ........................................................ 687 12 ASP.NET 2.0. Projektowanie aplikacji internetowych Model dostawcy ......................................................................................................... 689 Architektura modelu dostawcy ................................................................................ 690 Tworzenie dostawców niestandardowych ................................................................. 692 Członkostwo .............................................................................................................. 699 Omówienie systemu członkowskiego ...................................................................... 699 Konfiguracja dostawcy SqlMembershipProvider ....................................................... 700 Używanie interfejsu API członkostwa ....................................................................... 702 Zarządzanie rolami ..................................................................................................... 708 Dostawca ról ........................................................................................................ 709 Zarządzanie rolami ................................................................................................ 709 Używanie interfejsu API zarządzania rolami .............................................................. 712 Kontrolki logowania .................................................................................................... 717 Kontrolka Login ..................................................................................................... 718 Kontrolka LoginName ............................................................................................ 723 Kontrolka LoginStatus ........................................................................................... 723 Kontrolka LoginView .............................................................................................. 724 Kontrolka ChangePassword ................................................................................... 726 Kontrolka PasswordRecovery ................................................................................. 727 Kontrolka CreateUserWizard .................................................................................. 729 Podsumowanie .......................................................................................................... 729 Ćwiczenia .................................................................................................................. 730 Najważniejsze zagadnienia .......................................................................................... 731 Odnośniki .................................................................................................................. 732 Rozdział 14. Personalizacja za pomocą profili oraz składników Web Part .......................................733 Profile środowiska ASP.NET ........................................................................................ 733 Definiowanie profili ............................................................................................... 734 Użycie danych profilu ............................................................................................. 735 Jak działają profile? ............................................................................................... 739 Zapisywanie i odczytywanie danych profilu ............................................................... 741 Używanie typów niestandardowych .......................................................................... 742 Praca z użytkownikami anonimowymi ...................................................................... 745 Kiedy używać profili? ............................................................................................. 749 Składniki Web Part ..................................................................................................... 751 Składniki Web Part, strefy Web Part oraz menedżer składników Web Part .................. 753 Tworzenie składników Web Part i korzystanie z nich ................................................. 756 Konstruowanie składników Web Part z kontrolek użytkownika ................................... 762 Tworzenie składników Web Part na podstawie kontrolek niestandardowych ................ 766 Zmiana trybów wyświetlania ................................................................................... 769 Tryb projektowania ................................................................................................ 771 Tryb katalogu ........................................................................................................ 773 Tryb edycji ............................................................................................................ 774 Połączenia składników Web Part ............................................................................ 780 Podsumowanie .......................................................................................................... 791 Ćwiczenia .................................................................................................................. 792 Najważniejsze zagadnienia .......................................................................................... 793 Odnośniki .................................................................................................................. 794 Spis treści 13 Rozdział 15. Usługi WWW ......................................................................................................................795 Wprowadzenie do usług WWW ..................................................................................... 795 Zalety usług WWW ................................................................................................ 797 Konsumowanie usług WWW ........................................................................................ 798 Jak konsumować usługę WWW za pomocą programu Visual Studio? ......................... 799 Konsumowanie usług WWW w kontrolce użytkownika ............................................... 803 Konsumowanie usługi WWW Amazon ...................................................................... 806 Konsumowanie usług WWW a wydajność ................................................................ 814 Asynchroniczne usługi WWW .................................................................................. 817 Tworzenie usług WWW ................................................................................................ 822 Tworzenie prostej usługi z cytatami ......................................................................... 824 Testowanie usługi z cytatami ................................................................................. 828 Tworzenie fasady usługi WWW dla klasy biznesowej lub klasy logiki aplikacji .............. 830 Wskazówki dotyczące tworzenia usług WWW ........................................................... 831 Podsumowanie .......................................................................................................... 833 Ćwiczenia .................................................................................................................. 833 Najważniejsze zagadnienia .......................................................................................... 834 Odnośniki .................................................................................................................. 834 Rozdział 16. Internacjonalizacja i wdrażanie ......................................................................................837 Internacjonalizacja aplikacji WWW ................................................................................ 837 Wprowadzenie do plików z zasobami ...................................................................... 839 Generowanie plików z zasobami ............................................................................. 839 Lokalizacja plików z zasobami ................................................................................ 843 Zasoby globalne .................................................................................................... 848 Ustawienia kultury na poziomie strony .................................................................... 849 Wdrażanie ................................................................................................................. 854 Ręczne kopiowanie plików z komputera programisty na komputer docelowy ............... 855 Prekompilacja witryn WWW .................................................................................... 857 Tworzenie programu instalacyjnego za pomocą narzędzia Web Setup Project ............. 861 Podsumowanie .......................................................................................................... 867 Ćwiczenia .................................................................................................................. 867 Najważniejsze zagadnienia .......................................................................................... 867 Odnośniki .................................................................................................................. 868 Dodatki ............................................................................................................................. 869 Dodatek A Rzut oka na technologię ASP.NET AJAX ................................................................................871 Skorowidz .............................................................................................................................................893 11 Projektowanie oraz implementacja aplikacji sieciowych „Projekt… jest poznaniem związków zachodzących między różnymi rzeczami… Nie możesz wynaleźć projektu. Poznajesz go — w czwartym wymiarze. To znaczy swoją krwią i kośćmi, ale też swoimi oczami”. — D.H. Lawrence, Art Morality Środowisko ASP.NET jest na tyle dobrze wyposażoną technologią projektowania, że może być kuszące skupienie się wyłącznie na poszczególnych funkcjach, które wchodzą w jej skład. W niniejszym rozdziale środek ciężkości zostanie przesunięty z konkretnych kontrolek i klas na niektóre zagadnienia związane z tworzeniem w środowisku ASP.NET nieco bardziej złożonych aplikacji sieciowych. Rozdział rozpocznie się omówieniem modelu aplikacji sie- ciowych oraz niektórych często spotykanych modeli warstwowych tego typu aplikacji, po czym zostanie opisana implementacja przykładowej architektury warstwowej. Chociaż dobry projekt rzeczywiście nie musi być, jak to twierdzi Lawrence, wyłącznie wy- nikiem racjonalnego rozumowania, istnieje całkiem pokaźna literatura na temat projekto- wania oprogramowania, która dostarcza wielu wskazówek i nauk, które mogą być przydatne podczas projektowania aplikacji sieciowych. Szczegółowe omówienie zagadnienia współ- czesnego projektowania oprogramowania wykracza poza zakres tej książki. W materiałach do- datkowych, wymienionych pod koniec niniejszego rozdziału, wskazano kilka szczególnie przydatnych prac poświęconych temu bardzo obszernemu zagadnieniu. Główną natomiast rolą tego rozdziału jest omówienie różnych, najlepszych podejść do projektowania aplikacji sieciowych, a następnie zilustrowanie ich kilkoma przykładowymi implementacjami tych projektów. 586 Część II (cid:81) Operacje na danych Projektowanie aplikacji Środowisko ASP.NET dysponuje wieloma funkcjami, które wspomagają szybkie projekto- wanie aplikacji sieciowych. Wydajne deklaracyjne kontrolki umożliwiają programistom tworzenie wyszukanych interfejsów służących do wyświetlania i edycji danych przy małym nakładzie programowania lub w ogóle bez konieczności pisania kodu. Wygoda korzystania z programu Visual Studio Designer i jego moc także zachęcają programistów do szybkiej implementacji stron WWW. Środowisko ASP.NET i Visual Studio zdają się mówić: „Nie marnuj czasu na projektowanie i planowanie; bierz się do przeciągania i upuszczania i za- kończ projekt!”. Taka możliwość szybkiego opracowania strony jest zachęcająca zwłaszcza podczas tworzenia witryny WWW z ograniczoną liczbą przypadków użycia, czyli niewiel- kim zakresem wymogów funkcjonalnych. Funkcjonalności wielu „prawdziwych” aplikacji sieciowych nie da się jednak opisać za pomocą zaledwie kilku przypadków użycia. W rzeczywistości mogą być dziesiątki, a nawet setki opisanych przypadków, które wymagają wysiłku wielu programistów poświęcających sporo czasu, aby je wszystkie zaimplementować. To właśnie podczas pracy nad takim ro- dzajem aplikacji sieciowych szybki styl programowania może w rzeczywistości spowolnić ogół procesów tworzenia aplikacji. Prawdziwe projekty programistyczne są wyjątkowo wrażliwe na zmiany wymagań; projekty sieciowe są chyba jeszcze bardziej wrażliwe. Oznacza to, że funkcje aplikacji sieciowej są rzadko w pełni określone przed rozpoczęciem projektowania. Dodawane są nowe funkcje, a z innych się rezygnuje. Zmienia się model danych oraz wymogi co do ich przechowywa- nia. W miarę przemieszczania się projektu przez poszczególne etapy cyklu projektowania środowisko uruchomieniowe zmienia się począwszy od laptopa programisty, przez serwer testowy, serwer docelowy, a skończywszy być może na farmie serwerów sieciowych. Pro- gramista może początkowo testować program z bazą danych programu Access, po czym przenieść dane do serwera SQL, a następnie, po fuzji firm, powrócić do bazy danych Oracle. Na kilka tygodni przed testowaniem alfa klient może wprowadzić zmiany, które w przy- padku pewnych informacji spowodują konieczność pracy z zewnętrzną usługą zamiast z lo- kalną bazą danych. Analitycy użyteczności mogą mocno skrytykować strony witryny, co może spowodować konieczność wprowadzenia zmian w interfejsie użytkownika. To właśnie w takim środowisku programowania sieciowego zwyczaje szybkiego opracowy- wania projektów mogą przynieść więcej szkód niż korzyści. Przestrzeganie jednak zasad prawidłowego projektowania oprogramowania może w tym samym środowisku zwrócić się w postaci całkiem wymiernych zysków. Poświęcenie czasu na utworzenie dobrze zaprojek- towanej infrastruktury aplikacji może sprawić, że aplikacje sieciowe będą łatwiejsze do mo- dyfikowania i w pielęgnacji, prostsze w rozbudowie i poszerzaniu ich funkcjonalności, mniej podatne na błędy, a także łatwiejsze w tworzeniu. W pierwszym podrozdziale niniejszego rozdziału podjęto próbę rzucenia nieco światła na proces projektowania tego typu infra- struktury aplikacji. Rozdział 11. (cid:81) Projektowanie oraz implementacja aplikacji sieciowych 587 Korzystanie z warstw Jedną z najważniejszych zalet środowiska ASP.NET w porównaniu z czysto skryptowymi technologiami, takimi jak ASP albo PHP, jest możliwość tworzenia bardziej elastycznych aplikacji za pomocą aktualnie obowiązujących dobrych praktyk projektowania obiektowo zo- rientowanego oprogramowania. Prawdopodobnie najważniejsza z tych praktyk polega na podzieleniu projektu aplikacji na dyskretne warstwy logiczne. Czym jest warstwa? Warstwa to po prostu grupa klas, które są spokrewnione funkcjonalnie lub logicznie. Używanie warstw jest sposobem na organizowanie projektu oprogramowania w grupy klas, które służą wspólnemu celowi. Warstwa zatem nie jest rzeczą lecz zasadą or- ganizacji. Oznacza to, że warstwy są sposobem na projektowanie aplikacji. Powodem, dla którego tak wielu programistów aplikacji przyjęło warstwy jako zasadę or- ganizacji swoich aplikacji, jest fakt, że warstwa nie stanowi dowolnej grupy klas. Każda war- stwa aplikacji powinna być spójna (czyli klasy powinny dotyczyć mniej więcej tego samego i mieć zbliżony poziom abstrakcji). Spójne warstwy i klasy są zazwyczaj łatwiejsze do zro- zumienia, wielokrotnego używania i pielęgnowania. Celem dzielenia na warstwy jest rozdzielenie funkcji oprogramowania między klasy w taki sposób, aby zminimalizować skojarzenia danej klasy z innymi klasami. Skojarzenie odnosi się do liczby klas, z której korzysta określona klasa. Kiedy pewna klasa korzysta z innej klasy, jest od niej zależna. Wszelkie zmiany wprowadzone w interfejsie używanej klasy mogą mieć wpływ na klasę od niej zależną. Kiedy klasy aplikacji są silnie skojarzone, zmiana w jed- nej klasie może mieć wpływ na wiele innych klas. Zredukowanie skojarzeń sprawia, że projekt staje się elastyczniejszy i łatwiej rozszerzalny. Pewien stopień skojarzeń jest oczywiście niezbędny w każdej aplikacji — w przeciwnym razie klasy nie wchodziłyby we wzajemne interakcje. Organizując klasy aplikacji w warstwy, można mieć nadzieję na uzyskanie mniejszego stopnia skojarzeń niż w przypadku, gdyby podział na warstwy nie był przyjętą zasadą organizacji. Warstwa może zależeć od interfejsu innej warstwy, jednak powinna być niezależna od jej implementacji. Przy takim podejściu każda warstwa cechuje się ściśle ograniczoną liczbą zależności. Zależ- ność (znana także jako relacja korzystania) to taki związek między dwoma elementami, w któ- rym zmiana w jednym elemencie ma wpływ na drugi element. Na rysunku 11.1 poszczególne warstwy są zależne tylko od warstw, które znajdują się „poniżej”, to znaczy od warstw, które są bardziej „niskopoziomowe” czy też bardziej zależne od elementów zewnętrznych, takich jak bazy danych albo usługi sieciowe. Proszę zwrócić uwagę, co oznacza zależność w odniesieniu do warstw. Oznacza mianowi- cie, że klasy w warstwie „powyżej” korzystają z klas i metod warstwy (lub warstw) „poniżej”, ale już nie vice versa. Rzeczywiście, jeśli zależności zachodzą między wszystkimi warstwami w obie strony, traci się całkowicie korzyści z podziału na warstwy. 588 Część II (cid:81) Operacje na danych Rysunek 11.1. Wizualizacja warstw Schemat warstw pokazany na rysunku 11.1 jest otwartym (luźnym) schematem podziału na warstwy, ponieważ niektóre warstwy zależą od więcej niż jednej innej warstwy. W schemacie zamkniętym (nieprzejrzystym) każda warstwa zależy tylko od jednej niż- szej warstwy. Chociaż schemat zamknięty byłby idealny, to jednak w praktyce jest on czasami trudny do osiągnięcia. Jak zauważył Martin Fowler w swojej książce Architektura systemów zarządzania przedsiębiorstwem. Wzorce projektowe, „większość (architektur warstwowych) jest w większości nieprzejrzysta”. Na koniec muszę jeszcze wspomnieć, że niektórzy autorzy używają terminu poziom w tym samym znaczeniu, w jakim ja używam terminu warstwa. Większość jednak współczesnej literatury na temat architektury i projektowania oprogramowania używa terminu poziom w zupełnie innym znaczeniu. Znaczenie to odnosi się do granic procesu. Różne poziomy naj- częściej oznaczają różne miejsca w sieci. Typowa aplikacja sieciowa może być na przykład rozpatrywana jako architektura trójpoziomowa: stacja robocza użytkownika jest poziomem interfejsu użytkownika, serwer sieciowy jest poziomem aplikacji, a system zarządzania bazą danych działający na odrębnym serwerze danych jest poziomem bazy danych, co pokazano na rysunku 11.2. W dalszej części niniejszej książki termin poziom będzie używany w tym drugim znaczeniu, z kolei słowo warstwa będzie odnosić się do pojęciowego grupowania klas w obrębie aplikacji. Rozdział 11. (cid:81) Projektowanie oraz implementacja aplikacji sieciowych 589 Rysunek 11.2. Poziomy Skutki podziału na warstwy Istnieje wiele korzyści, które może przynieść projektowanie aplikacji z użyciem warstw. Pierwszą i najważniejszą zaletą korzystania z warstw jest fakt, że wynikowa aplikacja powin- na być o wiele bardziej elastyczna i adaptowalna dzięki niższemu ogólnemu poziomowi sko- jarzeń w aplikacji. Jeśli niski poziom skojarzeń łączy się z wysokim stopniem spójności w obrębie warstwy (łącznie z dobrze określonym interfejsem dostępu do warstwy), pro- gramista powinien mieć możliwość modyfikowania, poszerzania lub wzbogacania warstwy bez wywierania nadmiernego wpływu na resztę aplikacji. Jak zauważył Craig Larman w swojej książce Agile and Interactive Development, modyfikowanie i pielęgnacja aplikacji zwykle zabiera większość czasu poświęconego na jej opracowanie. W rezultacie zwiększenie możli- wości pielęgnowania aplikacji jest istotną zaletą. Inna korzyść podziału na warstwy polega na możliwości ponownego użycia danej warstwy w innych aplikacjach, zwłaszcza jeśli została ona zaprojektowana z myślą o wielokrotnym użyciu. Autor używał w dziesiątkach aplikacji sieciowych nieco bardziej złożonych wersji warstw, które zostaną zaimplementowane w dalszej części tego rozdziału. Wreszcie kolejną zaletą warstw jest możliwość testowania funkcji aplikacji zawartych w warstwie odrębnie i niezależnie od innych warstw. Używanie warstw ma jednak też swoje wady. Jedna z nich polega na tym, że aplikacja może stać się nieco trudniejsza w zrozumieniu i opracowaniu dla programistów, którzy znają je- dynie model projektowania oparty na języku skryptowym strony. Chociaż zazwyczaj warto ponieść taki koszt, to jednak w przypadku bardzo prostych aplikacji sieciowych, składają- cych się zaledwie z kilku stron, używanie wielu warstw abstrakcji prawdopodobnie nie będzie opłacalne. Inna wada korzystania z warstw polega na tym, że dodatkowe poziomy abstrakcji mogą spo- wodować spadek wydajności wykonywania się programu. Biorąc jednak pod uwagę czas poświęcany na komunikowanie się komputerów w sieci, dodatkowy czas przeznaczony na komunikację między obiektami w komputerze jest względnie nieistotny. Ostatnią wadą podziału na warstwy jest trudność w ustanowieniu prawidłowego schematu podziału, który zostanie zastosowany. Jeśli w aplikacji jest za mało warstw, a każda warstwa ma za dużo obowiązków, wówczas osiągnięcie pełni korzyści z podziału na warstwy może być niemożliwe. Jeśli z kolei w aplikacji jest za wiele warstw, zapewne będzie ona zbyt 590 Część II (cid:81) Operacje na danych skomplikowana, a tym samym mniej elastyczna i trudniejsza do zrozumienia. W następnych kilku podrozdziałach spróbuję odnieść się do tych wad, analizując kilka przykładowych ar- chitektur warstwowych. Kiedy należy nadać nazwy modelom podziału na warstwy, okazuje się, że brakuje standar- dowego nazewnictwa. Analizując literaturę, można odnieść wrażenie, że istnieją dziesiątki różnych schematów dzielenia na warstwy. W tym przypadku będzie jednak inaczej. Jak za- uważa Eric Evans w swojej książce Domain-Driven Design, przemysł oprogramowania zo- rientowanego obiektowo dzięki swojemu doświadczeniu i przyjętym konwencjom zbliżył się do architektur warstwowych, łącznie z wypracowaniem zbioru w miarę standardowych warstw, które jednak nie mają standardowych nazw. W następnych trzech podrozdziałach zostaną omó- wione trzy najczęściej spotykane modele warstw. Model dwuwarstwowy Pokazano już w poprzednim rozdziale, że jest możliwe utworzenie sterowanej danymi apli- kacji sieciowej ASP.NET niemal zupełnie bez konieczności programowania dzięki kontrolce SqlDataSource oraz innym kontrolkom danych, takim jak DetailsView i GridView. Niemniej, jak już wspomniano w rozdziale 9., wielu programistów nie lubi umieszczać szczegółów dostępu do bazy danych w formularzach WWW, nawet jeśli dzieje się to w deklaracyjnych formach kontrolki SqlDataSource. W rozdziale 9. utworzono serię spokrewnionych klas, które obsługiwały dostęp do bazy danych za pośrednictwem programowania w technologii ADO.NET, a następnie użyto ich w formularzach WWW, korzystając z kontrolki Object- DataSource. Był to przykład architektury dwuwarstwowej. W modelu dwuwarstwowym szczegóły dostępu do danych są zawarte w odrębnych klasach, które są różne od samych formularzy WWW. Dwie warstwy występujące w takim modelu można nazwać warstwą prezentacji oraz warstwą dostępu do danych. Warstwa prezentacji udostępnia interfejs użytkownika aplikacji oraz obsługuje interakcję między użytkownikiem i aplikacją. W tej książce warstwa prezentacji składa się ze stron ASP.NET wraz z ich klasami z kodem ukrytym oraz dodatkowymi kontrolkami użytkownika lub kontrolkami niestandardowymi. Warstwa dostępu do danych udostępnia komunikację z systemami zewnętrznymi, takimi jak bazy danych, systemami rozpowszechniania komu- nikatów lub zewnętrzne usługi WWW, co pokazano na rysunku 11.3. Warstwa dostępu do danych z rozdziału 9. zawierała cały kod ADO.NET. Każda z klas warstwy była odpowiedzialna za tworzenie, odczytywanie, aktu
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ASP.NET 2.0. Projektowanie aplikacji internetowych
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: