Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00670 009247 10483612 na godz. na dobę w sumie
ASP.NET 2.0 AJAX. Zaawansowane programowanie - książka
ASP.NET 2.0 AJAX. Zaawansowane programowanie - książka
Autor: , Liczba stron: 328
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1300-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> ajax
Porównaj ceny (książka, ebook, audiobook).
Śmiało wkraczaj w nowoczesne technologie, aby tworzyć interaktywne aplikacje internetowe!

ASP.NET AJAX to nazwa stworzonego przez Microsoft rozwiązania AJAX. Odnosi się do zestawu technologii klienckich i serwerowych, które koncentrują się na ulepszaniu programowania WWW pod Visual Studio. Jest to jedna z najpopularniejszych, a równocześnie najbardziej docenianych - zarówno przez użytkowników, jak i programistów - technologii do tworzenia interaktywnych witryn internetowych. ASP.NET AJAX dysponuje między innymi serwerowymi usługami aplikacyjnymi, takimi jak uwierzytelnianie i przechowywanie profilu użytkownika, oraz zawiera zestaw kontrolek ułatwiających asynchroniczną aktualizację stron i korzystanie z zasobów serwera.

Książka 'ASP.NET 2.0 AJAX. Zaawansowane programowanie' szczegółowo ukazuje, na czym polega tworzenie aplikacji WWW nowej generacji. Dzięki temu podręcznikowi będziesz wiedział, jak korzystać z różnych bibliotek, jak używać zaawansowanych kontrolek z pakietu AJAX Toolkit, a także jak budować własne kontrolki. Nauczysz się asynchronicznie uaktualniać fragmenty stron i zarządzać skryptami używanymi w przeglądarce, dowiesz się, jak testować takie aplikacje i usuwać z nich błędy. Z tą książką zdobędziesz wiedzę potrzebną do kreowania nowoczesnych, interaktywnych aplikacji.

Korzystaj z nowoczesnych technologii podczas tworzenia interaktywnych aplikacji internetowych!

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

Darmowy fragment publikacji:

ASP.NET 2.0 AJAX. Zaawansowane programowanie Autor: Matt Gibbs, Dan Wahlin T‡umaczenie: Krzysztof B„bol ISBN: 978-83-246-1300-7 Tytu‡ orygina‡u: Professional ASP.NET 2.0 AJAX Format: B5, stron: 328 (cid:140)mia‡o wkraczaj w nowoczesne technologie, aby tworzy(cid:230) interaktywne aplikacje internetowe! (cid:149) Jak zarz„dza(cid:230) odwo‡aniami do strony? (cid:149) Jak osadza(cid:230) skrypty w kontrolkach serwerowych? (cid:149) Jak u¿ywa(cid:230) narzŒdzia Fiddler do kontroli komunikat(cid:243)w? ASP.NET AJAX to nazwa stworzonego przez Microsoft rozwi„zania AJAX. Odnosi siŒ do zestawu technologii klienckich i serwerowych, kt(cid:243)re koncentruj„ siŒ na ulepszaniu programowania WWW pod Visual Studio. Jest to jedna z najpopularniejszych, a r(cid:243)wnocze(cid:156)nie najbardziej docenianych (cid:150) zar(cid:243)wno przez u¿ytkownik(cid:243)w, jak i programist(cid:243)w (cid:150) technologii do tworzenia interaktywnych witryn internetowych. ASP.NET AJAX dysponuje miŒdzy innymi serwerowymi us‡ugami aplikacyjnymi, takimi jak uwierzytelnianie i przechowywanie profilu u¿ytkownika, oraz zawiera zestaw kontrolek u‡atwiaj„cych asynchroniczn„ aktualizacjŒ stron i korzystanie z zasob(cid:243)w serwera. Ksi„¿ka (cid:132)ASP.NET 2.0 AJAX. Zaawansowane programowanie(cid:148) szczeg(cid:243)‡owo ukazuje, na czym polega tworzenie aplikacji WWW nowej generacji. DziŒki temu podrŒcznikowi bŒdziesz wiedzia‡, jak korzysta(cid:230) z r(cid:243)¿nych bibliotek, jak u¿ywa(cid:230) zaawansowanych kontrolek z pakietu AJAX Toolkit, a tak¿e jak budowa(cid:230) w‡asne kontrolki. Nauczysz siŒ asynchronicznie uaktualnia(cid:230) fragmenty stron i zarz„dza(cid:230) skryptami u¿ywanymi w przegl„darce, dowiesz siŒ, jak testowa(cid:230) takie aplikacje i usuwa(cid:230) z nich b‡Œdy. Z t„ ksi„¿k„ zdobŒdziesz wiedzŒ potrzebn„ do kreowania nowoczesnych, interaktywnych aplikacji. (cid:149) CzŒ(cid:156)ciowe aktualizacje stron (cid:149) Pobieranie kodu JavaScript (cid:149) Biblioteka kliencka ASP.NET AJAX (cid:149) U¿ywanie prototyp(cid:243)w (cid:149) Elementy DOM (cid:149) U¿ycie kontrolki ScriptManager (cid:149) Dodawanie odwo‡aæ do skrypt(cid:243)w (cid:149) Zaawansowane kontrolki z pakietu AJAX Toolkit (cid:149) Efekty interfejsu u¿ytkownika (cid:149) Testowanie, debugowanie i wdra¿anie aplikacji ASP.NET AJAX Korzystaj z nowoczesnych technologii podczas tworzenia interaktywnych aplikacji internetowych! 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 autorach .................................................................................................................................................11 WstÂp ........................................................................................................................................................13 RozdziaÄ 1. Tworzenie nowej generacji aplikacji WWW .........................................................................17 Wzbogacanie aplikacji internetowych .............................................................................. 18 Kto skorzysta z technologii AJAX .................................................................................... 19 Dlaczego uĔytkownicy chcñ aplikacji AJAX .................................................................. 19 Dlaczego programiĈci chcñ stosowaè AJAX ................................................................ 20 Czym jest ASP.NET AJAX ............................................................................................... 22 Komponent ASP.NET ............................................................................................... 24 Komponent JavaScript ............................................................................................. 25 Komponent usäug sieci WWW ................................................................................... 28 Komponent dynamicznego HTML .............................................................................. 29 Inne biblioteki AJAX ...................................................................................................... 29 Zachowywanie równowagi miödzy programowaniem klienckim a serwerowym dziöki ASP.NET AJAX ............................................................................. 31 Podsumowanie ............................................................................................................ 32 RozdziaÄ 2. CzÂÊciowe aktualizacje stron .............................................................................................33 Kontrolka UpdatePanel ................................................................................................. 33 Wyzwalanie aktualizacji ............................................................................................ 36 Wywoäywanie metody Update z serwera ..................................................................... 40 Cykl Ĕycia czöĈciowej aktualizacji strony .................................................................... 41 Przestrogi i objaĈnienia zawiäoĈci zwiñzanych z UpdatePanel ....................................... 42 Kontrolka UpdateProgress ............................................................................................ 43 Automatyczne aktualizacje z kontrolkñ Timer .................................................................. 47 Zarzñdzanie odwoäaniami do strony ................................................................................ 49 Cykl wywoäania strony .............................................................................................. 50 Anulowanie wywoäania ............................................................................................. 53 Wykrywanie bäödów ................................................................................................. 54 Praca z aktualizacjami ............................................................................................. 55 AJAX a dostöpnoĈè ....................................................................................................... 56 Podsumowanie ............................................................................................................ 57 6 ASP.NET 2.0 AJAX. Zaawansowane programowanie RozdziaÄ 3. JavaScript dla programisty ASP.NET .................................................................................59 UĔycie JavaScriptu po stronie klienta ............................................................................. 60 Pobieranie kodu JavaScript do przeglñdarki ............................................................... 60 Odczuwana wydajnoĈè ............................................................................................. 61 Zasoby skryptu ....................................................................................................... 62 Typy zmiennych w JavaScripcie ...................................................................................... 63 Anomalie jözyka ........................................................................................................... 66 Co to jest równoĈè? ................................................................................................ 66 Null, undefined albo coĈ innego ............................................................................... 69 Zakres zmiennych ........................................................................................................ 70 UĔywanie prototypów .................................................................................................... 73 Wiöcej o domkniöciach ................................................................................................. 76 OdĈmiecanie .......................................................................................................... 79 Elementy DOM ........................................................................................................ 80 Unikanie wycieków pamiöci ...................................................................................... 80 Ewaluacja eval ............................................................................................................. 81 Obsäuga wyjñtków ......................................................................................................... 82 Pobieranie fragmentów äaþcucha tekstowego .................................................................. 84 Lepszy JavaScript ......................................................................................................... 85 Redukcja skryptów .................................................................................................. 85 UĔywanie zmiennych buforujñcych ............................................................................ 86 Podsumowanie ............................................................................................................ 87 RozdziaÄ 4. ZrozumieÀ bibliotek klienck¾ ASP.NET AJAX .....................................................................89 Cykl Ĕycia strony w przeglñdarce .................................................................................... 90 UĔywanie systemu typów ............................................................................................... 91 Deklarowanie przestrzeni nazw ................................................................................. 91 Tworzenie klas ........................................................................................................ 94 UĔywanie interfejsów ............................................................................................... 99 Definiowanie wyliczeþ i flag .................................................................................... 101 Base Class Library ..................................................................................................... 105 Klasa String ......................................................................................................... 105 Daty i liczby .......................................................................................................... 106 Tablice ................................................................................................................. 108 Obsäuga Intellisense ................................................................................................... 110 Bäödy i debugowanie ................................................................................................... 113 Konsola Ĉledzenia bäödów ..................................................................................... 113 Tworzenie bäödów .................................................................................................. 114 Parametry walidacyjne ........................................................................................... 115 Obiekt Browser .......................................................................................................... 117 Podsumowanie .......................................................................................................... 118 RozdziaÄ 5. UÑycie kontrolki ScriptManager .........................................................................................121 Wszechobecny ScriptManager ..................................................................................... 121 Dodawanie odwoäaþ do skryptów ............................................................................ 123 Ustawianie ScriptMode .......................................................................................... 125 Osadzanie zasobów skryptowych ............................................................................ 126 Lokalizacja skryptów .............................................................................................. 130 Globalizacja skryptów ............................................................................................ 132 Odwoäania do usäug ............................................................................................... 134 Spis treÊci 7 Usäugi aplikacyjne ASP.NET ......................................................................................... 137 Uwierzytelnianie przy uĔyciu formularzy .................................................................... 137 Usäuga profili ........................................................................................................ 140 Obsäuga bäödów ......................................................................................................... 144 DopuszczalnoĈè niestandardowych bäödów .............................................................. 144 Obsäuga bäödów w czasie asynchronicznego odesäania ............................................. 145 Limit czasowy w wywoäaniach asynchronicznych ....................................................... 146 Zmiana lokalizacji skryptów ......................................................................................... 146 Ustawianie ĈcieĔki do skryptu ................................................................................ 147 Rozwiñzywanie odwoäaþ do skryptów ....................................................................... 147 ScriptManagerProxy .............................................................................................. 148 Kompresja skryptów .............................................................................................. 148 ZgodnoĈè .................................................................................................................. 148 Podsumowanie .......................................................................................................... 149 RozdziaÄ 6. Praca w sieci z ASP.NET AJAX .............................................................................................151 Obiekt XMLHttpRequest .............................................................................................. 151 Bezpieczeþstwo XMLHttpRequest ........................................................................... 152 WäaĈciwoĈci i metody obiektu ................................................................................ 152 Wykonywanie wywoäaþ WebRequest ............................................................................. 154 Ustawianie metody HTTP ....................................................................................... 155 Ustalanie limitów czasu ......................................................................................... 157 Dodawanie niestandardowych nagäówków ............................................................... 158 Przesyäanie dodatkowych danych ............................................................................ 161 Rozwiñzywanie peänego adresu URL ........................................................................ 162 Zarzñdzanie Ĕñdaniami WWW ...................................................................................... 162 DomyĈlny limit czasu ............................................................................................. 162 Globalna obsäuga Ĕñdaþ WWW ............................................................................... 165 WebRequestExecutor ............................................................................................ 167 Przesyäanie danych ..................................................................................................... 168 Serializacja ........................................................................................................... 168 Format JSON ........................................................................................................ 169 Serializacja JSON .................................................................................................. 172 PageMethods ....................................................................................................... 176 Praca z datami ...................................................................................................... 178 Pomijanie serializacji ............................................................................................. 178 Konfiguracja serializera JSON ................................................................................. 179 Niestandardowa serializacja ................................................................................... 180 Podsumowanie .......................................................................................................... 180 RozdziaÄ 7. UsÄugi aplikacyjne w ASP.NET AJAX ...................................................................................183 Uwierzytelnianie uĔytkowników ..................................................................................... 183 Konfiguracja uwierzytelniania na bazie formularzy .................................................... 184 Niestandardowe uwierzytelnianie ............................................................................ 185 Uwierzytelnianie w kodzie JavaScript ....................................................................... 187 Dostöp do statusu uĔytkownika .............................................................................. 189 Wylogowanie ......................................................................................................... 190 Dane profilu uĔytkownika ............................................................................................ 191 Definiowanie danych profilu ................................................................................... 192 Dostöp do wäaĈciwoĈci profilu ................................................................................ 194 Dostöp do danych profilu z przeglñdarki .................................................................. 195 8 ASP.NET 2.0 AJAX. Zaawansowane programowanie Wstöpne äadowanie wäaĈciwoĈci profili .................................................................... 197 ãadowanie wäaĈciwoĈci profilu ................................................................................ 198 Zapisywanie danych profilu .................................................................................... 201 Podsumowanie .......................................................................................................... 204 RozdziaÄ 8. Zaawansowane kontrolki z pakietu AJAX Toolkit ............................................................205 Kontrolowanie ukäadu strony ....................................................................................... 206 Accordion ............................................................................................................. 206 AlwaysVisibleControlExtender ................................................................................. 209 CollapsiblePanelExtender ...................................................................................... 211 ResizableControlExtender ...................................................................................... 212 Zakäadki ............................................................................................................... 214 Efekty interfejsu uĔytkownika ....................................................................................... 216 Animacje .............................................................................................................. 217 UpdatePanelAnimationExtender .............................................................................. 218 DropShadowExtender ............................................................................................ 219 RoundedCornersExtender ...................................................................................... 220 Kontrolki pojawiajñce siö na ekranie ............................................................................ 221 CalendarExtender .................................................................................................. 221 ConfirmButtonExtender .......................................................................................... 222 HoverMenuExtender .............................................................................................. 223 PopupControlExtender ........................................................................................... 224 ModalPopupExtender ............................................................................................. 224 CascadingDropDownExtender ................................................................................. 225 Podsumowanie .......................................................................................................... 227 RozdziaÄ 9. Testowanie i debugowanie aplikacji ASP.NET AJAX ..........................................................229 Skrypty produkcyjne i diagnostyczne ............................................................................ 229 UĔywanie klasy Error ................................................................................................... 232 UĔywanie klasy Sys.Debug .......................................................................................... 235 Wykonywanie operacji Ĉledzenia ............................................................................. 236 Dokonywanie asercji .............................................................................................. 239 Wäñczanie debugowania w przeglñdarce Internet Explorer .............................................. 240 Debugowanie za pomocñ Internet Explorera i Visual Studio .NET 2005 ...................... 241 Debugowanie za pomocñ Internet Explorera i programu Microsoft Script Debugger .......... 245 Debugowanie za pomocñ Firefoksa i Firebug ................................................................. 246 Przeglñdanie komunikatów Ĕñdaþ i odpowiedzi w ASP.NET AJAX ..................................... 249 UĔywanie narzödzia Fiddler do kontroli komunikatów ................................................ 249 UĔycie programu Web Development Helper do kontroli komunikatów ......................... 252 Podsumowanie .......................................................................................................... 254 RozdziaÄ 10. WdraÑanie aplikacji ASP.NET AJAX ..................................................................................255 Instalacja poszczególnych fragmentów ......................................................................... 255 ASP.NET AJAX ....................................................................................................... 256 ASP.NET AJAX Control Toolkit ................................................................................. 256 ASP.NET Futures CTP ............................................................................................ 257 Przygotowanie do wdroĔenia na farmie serwerów WWW ............................................... 258 Ustawianie MachineKey ......................................................................................... 258 Obsäuga stanu sesji .............................................................................................. 259 Spis treÊci 9 Korzystanie z innej platformy ....................................................................................... 260 Unikanie typowych problemów w konfiguracji ................................................................ 260 Wyäñczenie debugowania ....................................................................................... 261 Wäñczenie niestandardowych bäödów ...................................................................... 261 Wyäñczenie Ĉledzenia ............................................................................................ 262 Ustalanie trybu wdroĔenia ...................................................................................... 263 Tworzenie projektów wdroĔenia w sieci WWW ................................................................ 264 Po wdroĔeniu ............................................................................................................. 266 Monitorowanie wydajnoĈci ..................................................................................... 267 Sterowanie funkcjami AJAX .................................................................................... 268 Konfiguracja IIS7 .................................................................................................. 269 Korzystanie z kompresji skryptów ................................................................................ 270 Kompresja skryptów dynamicznych ......................................................................... 270 Kompresja skryptów statycznych ............................................................................ 271 Warto rozwaĔyè uĔycie skryptów wspóädzielonych ..................................................... 272 Nie warto zmieniaè wersji zawartych w ĈcieĔkach dostöpu ........................................ 272 Podsumowanie .......................................................................................................... 273 RozdziaÄ 11. Budowanie wÄasnych kontrolek ........................................................................................275 Budowanie kontrolek klienckich ASP.NET AJAX ............................................................. 276 Rozszerzanie jözyka JavaScript ............................................................................... 276 Rejestracja przestrzeni nazw .................................................................................. 279 Tworzenie konstruktora kontrolki ............................................................................ 279 UĔywanie wzorca projektowego prototypu z notacjñ JSON ......................................... 281 Definiowanie wäaĈciwoĈci kontrolki ......................................................................... 283 Inicjalizacja kontrolki i obsäuga zdarzeþ ................................................................... 286 Definiowanie metod kontrolki ................................................................................. 289 Pozbywanie siö zasobów kontrolki .......................................................................... 299 Rejestrowanie klasy niestandardowej kontrolki ........................................................ 300 Tworzenie egzemplarza kontrolki klienckiej .............................................................. 300 Budowanie serwerowej kontrolki ASP.NET AJAX ............................................................ 303 Osadzanie skryptów w kontrolkach serwerowych ...................................................... 304 Tworzenie klasy kontrolki i implementacja IScriptControl .......................................... 305 Przesäanianie metod Render i OnPreRender ............................................................ 307 UĔycie wäasnej kontrolki ASP.NET AJAX na stronie ASP.NET ...................................... 311 Podsumowanie .......................................................................................................... 312 Skorowidz ..............................................................................................................................................313 1 Tworzenie nowej generacji aplikacji WWW Aplikacje internetowe nie byáy dotąd tak zaawansowane i interaktywne jak zwykáe progra- my. UĪytkownik koĔcowy niekoniecznie musi mieü szczegóáową wiedzĊ na temat dziaáania aplikacji, ale wie, Īe kontakt ze stroną w przeglądarce zasadniczo róĪni siĊ od korzystania z lokalnie zainstalowanego programu. Kiedy zespóá programistów przymierza siĊ do nowego projektu, jednym z pierwszych pytaĔ, na które musi odpowiedzieü, jest to, czy uĪytkownicy bĊdą w stanie zaakceptowaü ograniczenia sieci WWW, czy potrzebują instalacji tradycyjnego programu. Aplikacje WWW są dostĊpne z prawie kaĪdej przeglądarki, wáaĞciwie wszĊdzie, ale ograniczają siĊ do tego, co moĪna zrobiü z kodem znaczników i skryptami dziaáającymi w przeglądarce. Tradycyjne aplikacje, okreĞlane teĪ mianem „ciĊĪkich klientów” (ang. fat client), wymagają zainstalowania na komputerze uĪytkownika, ale pozwalają programiĞcie skorzystaü z wbu- dowanych w system operacyjny zaawansowanych moĪliwoĞci grafiki i sterowania, które niezwykle trudno zaimplementowaü w przeglądarce WWW, a takĪe wykorzystaü zasoby komputera do zadaĔ takich jak zapisywanie danych. Z drugiej strony, aplikacje internetowe wystarczy zaktualizowaü na serwerze, a uĪytkownicy automatycznie bĊdą mieli dostĊp do najnowszej wersji. O wiele trudniej zaktualizowaü zwykáy program, poniewaĪ trzeba przekonaü uĪytkowników, Īeby zainstalowali nową wersjĊ, lub wprowadziü do aplikacji inteligentny system automatycznych aktualizacji. Mówi siĊ, Īe aplikacje internetowe nie wymagają wdroĪenia, tradycyjne programy są zaĞ pracocháonne we wdroĪeniu i konfiguracji. Wybór miĊdzy nimi czĊsto charakteryzuje siĊ jako kompromis miĊdzy moĪliwoĞciami a dostĊpnoĞcią (w jĊzyku ang. gra sáów rich — bogaty i reach — siĊgaü). Aplikacje biurkowe na ogóá oferują bogatsze moĪliwoĞci w porównaniu z tym, co daje przeglądarka, ale aplikacje WWW bez wysiáku moĪesz udostĊpniü kaĪdemu uĪytkownikowi w dowolnym systemie operacyjnym. Co wiĊcej, w wielu firmach obowiązują restrykcyjne zasady instalacji oprogramowania na komputerach pracowników, czĊsto nie mają oni uprawnieĔ administratora wymaganych do instalacji nowych programów, wiĊc aplikacje internetowe są w wielu sytuacjach jedynym sensownym rozwiązaniem. 18 ASP.NET 2.0 AJAX. Zaawansowane programowanie Wzbogacanie aplikacji internetowych W minionych latach posiadanie strony WWW byáo czynnikiem wyróĪniającym firmĊ. Dzisiaj juĪ tak nie jest. Teraz sama obecnoĞü w sieci nie wystarcza. Firmy starają siĊ odróĪniü od konkurencji poprzez aplikacje WWW, które odpowiadają intuicyjnie na dziaáania klientów i przewidują ich zachowania. Niniejsza ksiąĪka ukazuje, w jaki sposób ASP.NET AJAX od- nosi siĊ do specyficznych wymagaĔ programowania WWW i zwiĊksza komfort uĪytkownika Twoich stron. W tym rozdziale wytáumaczĊ, dlaczego potrzebujemy bardziej zaawansowa- nych platform w programowaniu WWW. Opowiem o kluczowych elementach platformy ASP.NET AJAX i przedstawiĊ kilka innych opcji. Zestaw technologii leĪący u podstaw nowej generacji aplikacji internetowych nie jest wcale nowy. Artykuáy na stronach informacyjnych oraz blogi ukazują Google, Flickr i kilka in- nych serwisów jako najlepsze przykáady wykorzystywania tych technologii w niespotykany wczeĞniej sposób. Te aplikacje mają kilka unikalnych cech, ale w rzeczywistoĞci leĪące u ich podstaw technologie są znane i uĪywane przez prawie dekadĊ. Przyglądając siĊ, w jaki sposób Microsoft Exchange Server udostĊpniaá w aplikacji Outlook Web Access zaawan- sowane funkcje poczty internetowej z poziomu przeglądarki, moĪna zobaczyü, Īe koncepcja wszechobecnego dostĊpu wykorzystującego typowy zestaw funkcji przeglądarki i dostar- czającego uĪytkownikowi bogatych wraĪeĔ istniaáa w praktyce od lat. UĪytkownicy dostają naprawdĊ peánowartoĞciową aplikacjĊ bez potrzeby lokalnej instalacji i mogą korzystaü z poczty praktycznie z kaĪdego komputera. Technologie uĪywane do budowania zaawansowanych aplikacji WWW przyjĊáo siĊ okre- Ğlaü mianem AJAX (ang. Asynchronous JavaScript and XML — asynchroniczny JavaScript i XML). ChociaĪ ten akronim miáo brzmi, niewiele wyjaĞnia. Zamiast budowaü aplikacje WWW w postaci serii odsáon i przeáadowaĔ stron, programiĞci wykorzystują JavaScript do asynchronicznej komunikacji z serwerem i dynamicznego aktualizowania czĊĞci strony. Oznacza to, Īe strona potrafi dynamicznie zmieniaü wygląd podczas interakcji z uĪytkowni- kiem, a nawet moĪe wysyáaü lub pobieraü dane z serwera WWW w tle. MinĊáy dni brzyd- kiego przeáadowania czyszczącego ekran uĪytkownika i odwracającego jego uwagĊ! Teraz odsyáanie do serwera jest potrzebne tylko wtedy, gdy chcemy przejĞü na inną stronĊ. MoĪna nagiąü nawet tĊ zasadĊ. Niektóre aplikacje przekraczają tĊ granicĊ i kompletnie zmieniają wygląd ekranu uĪytkownika, tak jakby przeszáy do nowej strony, ale robią to, przesyáając dane asynchronicznie i zmieniając zawartoĞü strony bez faktycznego przejĞcia do nowego adresu URL. Akronim AJAX odnosi siĊ do XML jako formatu danych wymienianych miĊdzy klientem a serwerem, ale w rzeczywistoĞci tworzy siĊ aplikacje pobierające zwykáe fragmenty tek- stu, XML oraz JSON (ang. JavaScript Object Notation — zapis obiektów JavaScript), który omówiĊ dokáadniej w rozdziale 4. Pewna atrakcyjna cecha technologii AJAX nie jest nawet zawarta w akronimie: oprócz nieblokującej komunikacji z serwerem, programiĞci wykorzy- stują Dynamic HTML (DHTML) i Cascading Style Sheets (CSS), aby stworzyü naprawdĊ zdumiewające interfejsy uĪytkownika. Kod JavaScript dziaáający na kliencie komunikuje siĊ asynchronicznie z serwerem, a potem uĪywa DHTML do dynamicznego modyfikowania strony, tworząc zaawansowane animacje, przejĞcia i aktualizacje treĞci, w czasie gdy uĪytkow- nik kontynuuje interakcjĊ ze stroną. W wielu przypadkach uĪytkownicy nie bĊdą nawet zdawaü sobie sprawy, Īe uĪywają aplikacji internetowej! RozdziaÄ 1. Q Tworzenie nowej generacji aplikacji WWW 19 Kto skorzysta z technologii AJAX AJAX oferuje korzyĞci zarówno uĪytkownikom, jak i programistom — uĪytkownikom, po- niewaĪ redukuje konflikt „dostĊpnoĞci i moĪliwoĞci”; programistom, poniewaĪ pomaga po- konaü ograniczenia protokoáu HTTP. Dlaczego uÑytkownicy chc¾ aplikacji AJAX UĪytkownicy zazwyczaj patrzą na tradycyjne programy jako coĞ w rodzaju zobowiązania. Instalują program, zazwyczaj z páyty wyciągniĊtej z kosztowego, zafoliowanego pudeáka. Program zabiera miejsce na dysku oraz pozycjĊ w menu startowym. Byü moĪe trzeba bĊdzie go co jakiĞ czas uaktualniaü lub przejĞü póĨniej na wyĪszą wersjĊ, aby uzyskaü nowe funkcje. JeĞli program sam chce siĊ aktualizowaü, uĪytkownik jest regularnie konfrontowany z oknami dialogowymi informującymi o áatkach lub uaktualnieniach. W zamian za zainwestowany czas, pieniądze i energiĊ aplikacja odpáaca siĊ tym, Īe moĪe wykorzystaü zasoby systemu operacyjnego i komputera. Jest zaawansowana. MoĪe zapisywaü dane lokalnie, szybko re- aguje, ma interesujący i intuicyjny interfejs graficzny. Coraz wiĊcej aplikacji jest dostĊpnych z poziomu przeglądarki. Nie mają one dostĊpu do peánych zasobów sprzĊtu i systemu operacyjnego, ale nie wymagają takiego zaangaĪowania jak tradycyjne programy. Przez lata korzystanie z aplikacji WWW odbywaáo siĊ wedáug przewidywalnego wzoru. UĪytkownik klika áącze na stronie, przeglądarka migocze, a uĪyt- kownik czeka na odrysowanie ekranu (okropne przeáadowanie). Ten cykl powtarza siĊ po raz kolejny. UĪytkownik patrzy na prezentowaną stronĊ, nawiązuje z nią interakcjĊ i gdzieĞ klika. Przeglądarka potwierdza to odgáosem klikniĊcia i zaczyna kontaktowaü siĊ z serwe- rem. Ekran przeglądarki staje siĊ czysty, jakaĞ ikonka krĊci siĊ lub miga, podczas gdy uĪyt- kownik czeka, aĪ serwer zwróci nową wersjĊ strony. W wielu przypadkach ta nowa wersja jest prawie identyczna jak poprzednia, zmieniony jest tylko jej fragment. A potem cykl roz- poczyna siĊ od nowa. Powstaje wraĪenie powolnoĞci nawet przy szybkim poáączeniu z In- ternetem. Zestaw technologii AJAX zmieniá oczekiwania uĪytkowników wobec aplikacji internetowych. Kod JavaScript uruchomiony w przeglądarce wymienia dane z serwerem WWW asynchro- nicznie. Nie sáychaü odgáosu klikania, a przeglądarka nie miga. Komunikacja z serwerem nie jest blokująca, dziĊki czemu uĪytkownik moĪe dalej przeglądaü stronĊ i nawiązywaü z nią interakcjĊ. Skrypt pobiera zaktualizowane dane z serwera i dynamicznie modyfikuje stronĊ, uĪywając metodologii DHTML. UĪytkownik moĪe dalej patrzeü na stronĊ, podczas gdy w tle aktualizują siĊ jej fragmenty. AJAX daje internautom bardziej dynamiczne wra- Īenia, zbliĪając zachowanie aplikacji WWW do tradycyjnych programów. JavaScript wzbogaca doĞwiadczenia uĪytkownika dziĊki wsparciu mechanizmu „przeciągnij i upuĞü”, obsáudze modalnych okien dialogowych i pozornie natychmiastowej aktualizacji róĪnych elementów strony w zaleĪnoĞci od dziaáaĔ internauty. DuĪa czĊĞü sukcesów w wykorzystaniu technologii AJAX to zasáuga postrzeganego wzro- stu wydajnoĞci. Internauci doceniają aplikacje, które przewidują ich zachowania. JeĞli uĪy- jesz takĪe kodu JavaScript, pobierającego w tle obrazki i dane, które mogą byü potrzebne, 20 ASP.NET 2.0 AJAX. Zaawansowane programowanie uĪytkownicy dostaną szybką odpowiedĨ bez typowej przerwy towarzyszącej ich akcjom. Nikt nie chce czekaü na wymianĊ danych miĊdzy klientem a serwerem, badania pokazaáy, Īe dáugi czas pomiĊdzy dziaáaniem uĪytkownika a nastĊpującymi po nim zmianami w inter- fejsie moĪe znacznie obniĪyü produktywnoĞü i wywoáaü frustrujące wraĪenie walki z apli- kacją. UĪytkownicy chcą, by aplikacje internetowe zachowywaáy siĊ jak typowe programy, ale bez obciąĪenia związanego z instalacją. W sytuacji gdy coraz wiĊcej aplikacji korzysta z inteligentnego buforowania, przewiduje dziaáania uĪytkownika i dostarcza bogatszego interfejsu, zaciera siĊ róĪnica pomiĊdzy aplikacjami internetowymi a biurkowymi. Wymagania wzglĊdem tych pierwszych zwiĊkszają siĊ. UĪytkownicy dostrzegli juĪ, Īe moĪna uniknąü zobowiązaĔ związanych z instalacją tradycyjnego programu i wciąĪ mieü bogate, interaktyw- ne doĞwiadczenia. Dlaczego programiÊci chc¾ stosowaÀ AJAX CzĊsto pierwszym pytaniem stawianym po rozpoczĊciu projektu jest to, jaki typ aplikacji bĊdziemy tworzyü. Czy to ma byü aplikacja tradycyjna, czy moĪe internetowa? To kluczowa decyzja, poniewaĪ w przeszáoĞci narzucaáa w znacznym stopniu naturĊ aplikacji i przestrzeĔ zadaĔ związanych z jej rozwojem. Obecnie wielu programistów wybiera domyĞlnie tworzenie aplikacji WWW, jeĞli nie ma w tym wzglĊdzie Īadnych przeciwwskazaĔ. JeĞli aplikacja musi dziaáaü bez dostĊpu do sieci lub wymaga interfejsu trudnego do uzyskania w jĊzyku HTML, moĪe to wykluczaü korzystanie z przeglądarki i narzucaü wybór pisania samodzielnej aplikacji. Pisząc nowoczesne aplikacje internetowe, programiĞci mają trudnoĞci z powodu wrodzonych ograniczeĔ sieci WWW nakáadanych przez Hypertext Transfer Protocol (HTTP) i sposób, w jaki korzystają z niego przeglądarki. HTTP jest protokoáem bezstanowym. Przeglądarka WWW wywoáuje stronĊ, byü moĪe podając jakieĞ parametry áaĔcucha zapytania lub da- nych formularza, a serwer przetwarza to Īądanie i wysyáa odpowiedĨ zawierającą treĞü opi- saną w jĊzyku HTML. Serwer moĪe tylko reagowaü na informacjĊ przesáaną w bieĪącym zleceniu i nie zna, na podstawie informacji w nim zawartych, Īadnych szczegóáów na temat drogi, jaką internauta dotará do bieĪącego widoku. Podczas wizualizacji odpowiedzi poáą- czenie moĪe zostaü zerwane, a serwer nie ma Īadnych informacji, które mógáby przechowaü dla przyszáego wywoáania. Patrząc z perspektywy serwera, po prostu sáucha wywoáaĔ nad- chodzących z dowolnego miejsca i dowolnej przeglądarki, a nastĊpnie na nie reaguje. Przeglą- darka zgáasza Īądanie dostĊpu do strony i otrzymuje w odpowiedzi stronĊ HTML. UĪywa otrzymanego kodu HTML do wizualizacji interfejsu uĪytkownika. UĪytkownik nawiązuje interakcjĊ ze stroną, a w odpowiedzi przeglądarka czyĞci ekran i zgáasza do serwera nowe Īądanie zawierające pewne informacje na temat danych wprowadzonych przez uĪytkownika lub jego dziaáaĔ. Znowu zwracana jest kompletna strona HTML. Zasadniczo protokóá HTTP jest bezstanowy. Serwer otrzymuje wywoáanie i na nie odpowiada. Wywoáanie niesie ze sobą ograniczoną informacjĊ o komunikacji toczącej siĊ miĊdzy klientem a serwerem. AJAX robi to duĪo lepiej. àamie ten wzór, aktualizując fragmenty stron oddzielnie, poprzez czĊĞciowe odĞwieĪanie strony (ang. partial page rendering). Rysunek 1.1 pokazuje typo- wą, nie-AJAX-ową seriĊ interakcji przeglądarki i serwera. KaĪde wywoáanie skutkuje zwró- ceniem caáoĞci strony, a w odpowiedzi przeglądarka aktualizuje caáy widok przedstawiany uĪytkownikowi. RozdziaÄ 1. Q Tworzenie nowej generacji aplikacji WWW 21 Rysunek 1.1 Na rysunku 1.2 do polepszenia wraĪeĔ uĪytkownika zastosowano AJAX. Pierwsze wywoáa- nie jest wysyáane w celu początkowej wizualizacji strony. Potem przesyáane są asynchroniczne Īądania do serwera. Asynchroniczne wywoáanie przesyáa lub odbiera dane w tle w zupeánie niewidoczny sposób. Jest ono asynchroniczne, poniewaĪ interfejs uĪytkownika nie jest w tym czasie zablokowany, a uĪytkownik moĪe kontynuowaü interakcjĊ ze stroną podczas transfe- ru danych. Tego rodzaju wywoáania aktualizują stronĊ przyrostowo, zamiast pobieraü caá- kiem nową. Kod JavaScript uruchomiony na kliencie reaguje na nowe dane i odpowiednio aktualizuje róĪne fragmenty strony. Liczba wywoáaĔ serwera moĪe byü taka sama, a w nie- których przypadkach moĪe byü ich nawet wiĊcej, ale uĪytkownikowi wydaje siĊ, Īe aplikacja odpowiada szybciej. Nie jest zmuszany do przerwy, choüby krótkiej, i oczekiwania na serwer, gapiąc siĊ na biaáy ekran przeglądarki. Rysunek 1.2 Prawie dziesiĊü lat temu zespóá programistów serwera Microsoft Exchange stworzyá kontrol- kĊ ActiveX o nazwie XmlHttpRequest, której egzemplarze mogáy byü tworzone z poziomu JavaScriptu i wykorzystywane do komunikacji z serwerem. Mogáa ona przebiegaü bez czysz- czenia ekranu i odrysowywania strony. UĪywając obiektu XmlHttpRequest, mogáeĞ wysyáaü informacje do serwera i pobieraü je stamtąd bez potrzeby tworzenia nowej strony HTML. Kod JavaScript mógá potem dynamicznie manipulowaü zawartoĞcią HTML na komputerze klienckim, unikając irytujących migniĊü i oczekiwaĔ zazwyczaj wiązanych z przeglądaniem 22 ASP.NET 2.0 AJAX. Zaawansowane programowanie stron WWW. Ta funkcjonalnoĞü niezbyt dáugo ograniczaáa siĊ tylko do Internet Explorera. Wkrótce równieĪ inne przeglądarki zaczĊáy obsáugiwaü obiekty XmlHttpRequest. ProgramiĞci mogli juĪ zacząü pisaü bardziej zaawansowane aplikacje dostĊpne dla róĪnych systemów operacyjnych. Przeglądarki zaczĊáy teĪ uĪywaü zaawansowanego modelu DOM (ang. Document Object Model — obiektowy model dokumentu) umoĪliwiającego reprezentacjĊ przeglądarki, okna, strony i zawartych w niej elementów HTML. DOM udostĊpniaá zdarzenia i odpowiadaá na akcje uĪytkownika, pozwalając skryptom manipulowaü stroną. Dynamiczny HTML (DHTML) otworzyá drzwi do tworzenia zaawansowanych interfejsów w oknie przeglądar- ki. ProgramiĞci zaczĊli pisaü setki, a nawet tysiące wierszy kodu JavaScript, aby stworzyü bogate i atrakcyjne aplikacje niewymagające instalacji na komputerze i dostĊpne wszĊdzie z kaĪdej przeglądarki. Aplikacje WWW wzniosáy siĊ na caákiem nowy poziom zaawanso- wania. Bez bibliotek AJAX trzeba by byáo pisaü mnóstwo kodu JavaScript i szukaü báĊdów w czasami subtelnych róĪnicach miĊdzy przeglądarkami, aby osiągnąü tak wysoki poziom. Biblioteki JAVASCRIPT a AJAX ProgramiĈci mieli dostöp do technologii AJAX od lat i wielu z nich wykorzystywaäo AJAX do przesuwania granic tego, co moĔna byäo zrobiè z przeglñdarkñ. Ale najbardziej przyciñ- gajñ dziĈ do AJAX wszechstronne biblioteki skryptów i integracja z technologiami serwe- rowymi. Uäatwia to pisanie zaawansowanych aplikacji i pozwala uniknñè bycia ekspertem od róĔnych wersji JavaScriptu. Do biblioteki JavaScript na stronie HTML odwoäujemy siö, uĔywajñc znacznika script : html head script src= http://wisniewscy.pl/jakisSkrypt.js type= text/javascript /script /head ... Skrypt jest pobierany i buforowany przez przeglñdarkö. Inne strony aplikacji mogñ odwoäy- waè siö do skryptu pod tym samym adresem URL, a przeglñdarka nawet nie zada sobie trudu pobrania go ponownie z serwera. FunkcjonalnoĈè tego skryptu jest dostöpna na stronie pobranej do przeglñdarki. Biblioteka skryptów wysyäana do przeglñdarki i wyko- rzystywana do tworzenia bardziej interaktywnej aplikacji o bogatszym interfejsie jest ser- cem wszystkich bibliotek AJAX. Czym jest ASP.NET AJAX ASP.NET AJAX to nazwa stworzonego przez Microsoft rozwiązania AJAX. Odnosi siĊ do zestawu technologii klienckich i serwerowych, które koncentrują siĊ na ulepszeniu progra- mowania WWW pod Visual Studio. Inne firmy mają wáasne rozwiązania AJAX, czĊsto zu- peánie odmiennie podchodzące do zagadnienia, ale Microsoft postanowiá rozszerzyü popularną technologiĊ ASP.NET, tworząc obszerny zestaw bibliotek skryptów oraz rozszerzeĔ pro- gramistycznych po stronie serwera. Jeden z tych elementów, Microsoft AJAX Library, jest biblioteką JavaScript dziaáającą na rozmaitych przeglądarkach, sáuĪącą uproszczeniu pro- gramowania w JavaScripcie. Zapewnia moĪliwoĞü prostego pisania kodu w sposób obiekto- wy, podobnie jak w plikach kodu serwerowego ASP.NET. MoĪna wykorzystaü moĪliwoĞci RozdziaÄ 1. Q Tworzenie nowej generacji aplikacji WWW 23 Microsoft AJAX Library do operowania na DOM, dynamicznej aktualizacji fragmentów stron, asynchronicznej komunikacji z serwerem i tworzenia zaawansowanych animacji. Funk- cjonalnoĞü dostĊpną na kliencie Czytelnik pozna w rozdziaáach 6. i 7., na razie moĪe myĞleü o Microsoft AJAX Library jako o systemie typów i zestawie bibliotek klas upraszczających pisanie kodu JavaScript poprawiającego wraĪenia uĪytkownika, manipulującego DOM i ko- munikującego siĊ z serwerem WWW. Ogromną korzyĞcią z uĪywania tej biblioteki jest to, Īe opakowuje niskopoziomowe programowanie w DHTML w model obiektowy, z którym duĪo áatwiej pracowaü. Drugą czĊĞcią ASP.NET AJAX są serwerowe rozszerzenia ASP.NET 2.0 AJAX Exten- sions. Opierają siĊ na klasach i kontrolkach ASP.NET i korzystają z wysáanej do przeglądarki biblioteki Microsoft AJAX Library. DziĊki nim moĪna w prosty sposób wzbogaciü aplika- cjĊ technologiami AJAX. Poprzez zestaw standardowych usáug sieci Web ASP.NET AJAX potrafi takĪe wykorzystaü serwerowe usáugi aplikacyjne, takie jak uwierzytelnianie i prze- chowywanie profilu uĪytkownika. Rozszerzenia ASP.NET 2.0 AJAX Extensions dodają nowe zachowania do istniejących kontrolek ASP.NET, jak teĪ wprowadzają nowy zestaw kontrolek serwerowych, uáatwiających asynchroniczną aktualizacjĊ stron i korzystanie z za- sobów serwera. Serwerowe i klienckie czĊĞci ASP.NET są pokazane na rysunku 1.3. ASP.NET stanowi roz- szerzenie serwera WWW Microsoft Internet Information Services (IIS). ASP.NET AJAX rozbudowuje to wszystko, w tym równieĪ udostĊpniane przez IIS usáugi sieci Web. Microsoft AJAX Library dziaáa w przeglądarce, manipulując DOM, komunikując siĊ asynchronicznie z serwerem WWW i wykorzystując usáugi ASP.NET. Rysunek 1.3 Instalacja ASP.NET AJAX ASP.NET AJAX Extensions sñ dodatkiem do ASP.NET 2.0. ãñcze do instalatora znajduje siö na stronie http://ajax.asp.net/downloads/default.aspx?tabid=47. Po uruchomieniu zainstaluje on zestaw (ang. assembly) System.Web.Extensions.dll w buforze Global Assembly Cache (gac) Twojego komputera. ObecnoĈè w gac daje zestawowi uprawnienia niezbödne do zapewnienia peänej funkcjonalnoĈci oferowanej przez ASP.NET AJAX. JeĈli na komputerze jest obecne Visual Studio 2005 lub Visual Web Developer, instalator doda takĔe szablony projektów ASP.NET AJAX. Dziöki temu bödzie moĔna stworzyè nowñ witrynö korzystajñcñ z ASP.NET AJAX. Plik web.config i referencje kompilacji zawierajñ wszystko co niezbödne, by zaczñè budowaè aplikacje AJAX. Pakiet narzödziowy bödzie zawieraä kontrolkö UpdatePanel omówionñ w rozdziale 2. oraz kontrolkö ScriptManager opisanñ w rozdziale 5. Informacje o tym, co zawiera nowy plik web.config, zostanñ przed- stawione w rozdziale 10. 24 ASP.NET 2.0 AJAX. Zaawansowane programowanie Komponent ASP.NET Oryginalna (ASP) technologia Active Server Pages zostaáa wydana jako czĊĞü skáadowa In- ternet Information Server 3.0. Zostaáa potem ulepszona przez wsparcie transakcji i dostĊp do obiektów COM wraz z wydaniem NT 4.0 Option Pack prawie 10 lat temu. W tym czasie wiĊkszoĞü witryn internetowych skáadaáa siĊ ze statycznych stron HTML. JeĞli trafiaáy siĊ jakieĞ dynamiczne aplikacje, byáy to aplikacje typu CGI (ang. Common Gateway Interface) lub ISAPI (ang. Internet Server API) zazwyczaj napisane w C lub C++. Wraz z wydaniem Ac- tive Server Pages (ASP) programiĞci mogli zacząü uĪywaü jĊzyków JavaScript i VBScript na serwerze, wykorzystując zestaw wewnĊtrznych obiektów dostarczanych przez ASP. „Klasyczne ASP”, jak je dzisiaj nazywamy, dostarczaáo obiekt sesji, zatem programiĞci nie musieli siĊ przejmowaü bezstanową naturą HTTP. Miaáo obiekty Request i Response za- pewniające áatwy dostĊp do danych pochodzących z formularzy na kliencie oraz metodĊ zwracania zaktualizowanej informacji. Obiekty Server i Application stanowiáy sposób do- stĊpu do informacji z serwera WWW i wykorzystania wspólnego zestawu obiektów COM w caáej aplikacji. ChociaĪ klasyczne ASP byáo wielką wygraną programistów, odkryli oni szybko, Īe tworze- nie záoĪonych aplikacji staáo siĊ trudne. Brak wsparcia dla modularyzacji powodowaá, Īe aplikacje miaáy tak skomplikowane wspóázaleĪnoĞci w skryptach, Īe programiĞci czĊsto okreĞlali je jako „kod spaghetti”. W duĪym stopniu brakowaáo wsparcia dla debugowania oraz zaawansowanych narzĊdzi do projektowania aplikacji. WydajnoĞü takĪe byáa sáaba, bo ASP uĪywaáo powolnego mechanizmu wykonywania skryptów, a báĊdy skáadni mogáy byü wychwycone tylko po uruchomieniu aplikacji. ASP.NET stanowi wielki krok naprzód. Za- pewnia istniejącym aplikacjom zgodnoĞü, bo zawiera ten sam zestaw wewnĊtrznych obiektów co klasyczne ASP, ale zamiast interpretowaü JavaScript i VBScript „w locie”, ko- rzysta ze skompilowanego zbioru stron i moduáów napisanych w C# i VB.NET. Klasyczne ASP po prostu wykonywaáo skrypt po kolei od początku do koĔca strony; ASP.NET repre- zentuje model sterowany zdarzeniami, z cyklem Īycia strony, upodabniając programowanie WWW do pisania zwykáej aplikacji. Obecnie zamiast doáączaü oddzielne pliki JavaScript reprezentujące obiekty biznesowe, moĪesz stworzyü obiekty w dowolnym jĊzyku wspiera- nym przez .NET i mieü do nich dostĊp bezpoĞrednio z ASP.NET. ASP.NET z zestawu stron zawierających kod i znaczniki generuje klasĊ Page, która jest na- stĊpnie kompilowana i buforowana. Przy kaĪdym wywoáaniu strony wytwarzany jest egzem- plarz klasy i uruchamiany kompletny cykl Īycia strony. Wykonuje siĊ zestaw zdarzeĔ, z których czĊĞü jest przesáaniana przez wygenerowaną klasĊ Page. Kontrolki na stronie takĪe uczest- niczą w tym cyklu Īycia, wiąĪąc siĊ z danymi z koĔcówki bazodanowej, odpowiadając na dziaáania uĪytkownika i reagując na zmiany swojego stanu, jakie zaszáy od poprzedniej od- sáony strony. Aby odpowiedzieü na akcjĊ uĪytkownika, programista musi tylko dostarczyü dla niej procedurĊ obsáugi zdarzenia. Przykáadowo kontrolka-przycisk udostĊpnia zdarzenie Click. JeĞli ktoĞ chciaáby je wykorzystaü, nie musi pisaü kodu sprawdzającego wszystkie zmienne formularza na stronie, by dowiedzieü siĊ, Īe przycisk zostaá klikniĊty. Wystarczy, Īe doda kod przesáaniający obsáugĊ zdarzenia. Kod ten moĪe aktualizowaü HTML strony lub wáaĞciwoĞci i dane związane z innymi kontrolkami. Niniejsza ksiąĪka zakáada pewną znajomoĞü Ğrodowiska ASP.NET, niezbĊdną do zrozumienia, w jaki sposób nowe funkcje ASP.NET AJAX rozbudowują jego funkcjonalnoĞü i dostarczają Ğrodków do wzbogacenia aplikacji WWW. RozdziaÄ 1. Q Tworzenie nowej generacji aplikacji WWW 25 JeĞli Czytelnik nie zna jeszcze ASP.NET, warto zapoznaü siĊ z zestawem podrĊczników QuickStart ze strony http://www.asp.net/quickstart. Witryna ASP.NET (http://forums.asp.net/) ma takĪe liczne fora dyskusyjne, na których moĪna porozmawiaü z kolegami programującymi w ASP.NET oraz czáonkami zespoáu tworzącego tĊ platformĊ. Komponent JavaScript Technologie AJAX korzystają z powszechnego wsparcia dla JavaScriptu w nowoczesnych przeglądarkach. PoniewaĪ istnieje standard obsáugiwany przez róĪne przeglądarki, moĪesz pisaü skrypty, wiedząc, Īe bĊdą dziaáaáy. Ale nie zawsze tak byáo. W poáowie lat 90. ubiegáego wielu Netscape i Microsoft (wraz z innymi) wypracowaáy stan- dard jĊzyka skryptowego, który zastosowaáy w swoich przeglądarkach. Ten standard nazywa siĊ EcmaScript. Implementac a firmy Microsoft nosi nazwĊ JScript, ale powszechnie ten jĊzyk jest nazywany JavaScriptem, tak jak go nazwaá Netscape. (Nie ma nic wspólnego z Javą, ale widocznie ktoĞ pomyĞlaá, Īe takie skojarzenie bĊdzie korzystne dla celów marketingowych). Fragmenty kodu JavaScript są wysyáane do przeglądarki wraz z HTML i uruchamiają siĊ wewnątrz przeglądarki uĪytkownika, mając wpáyw na przetwarzanie strony na komputerze klienckim. JavaScript nie jest kompilowany; jest interpretowany. Nie ma statycznego sprawdzania zgod- noĞci typów jak w C++ czy C#. MoĪna zadeklarowaü zmienną, nie okreĞlając jej typu, a typ, do którego ona siĊ odnosi, zmieniü w dowolnej chwili. DziĊki temu áatwo zacząü progra- mowaü w JavaScripcie, ale pozwalając na podmienianie typu zmiennej w czasie wykonania skryptu, nieuchronnie naraĪamy siĊ na pewne niebezpieczeĔstwo. PoniĪszy fragment kodu pokazuje, jak áatwo zmienna moĪe odnosiü siĊ do dowolnego typu: var something = 1; something = true; something = đaēcuch ; JavaScript jest jĊzykiem dynamicznym. Typy danych mogą byü rozszerzane podczas wyko- nywania programu przez inny kod. Oznacza to, Īe moĪesz pisaü kod, który tworzy typy „w locie”. PoniewaĪ nie moĪna wyegzekwowaü bezpieczeĔstwa typów danych, Twój kod moĪe otrzymaü te typy w postaci parametrów lub zwracanych wartoĞci bez Īadnego pro- blemu. Zapewnia to ogromne moĪliwoĞci i elastycznoĞü programowania. Podstawowymi typami danych w JavaScripcie są áaĔcuchy tekstowe, liczby, wartoĞci lo- giczne i funkcje. Istnieje takĪe wsparcie dla obiektów i tablic, które są kolekcjami typów pod- stawowych. JĊzyk zawiera kilka dodatkowych obiektów uwaĪanych za niezbĊdne do wielu zadaĔ. MoĪna tu wymieniü wsparcie dla wyraĪeĔ regularnych oraz operacji na datach i czasie. Do áączenia áaĔcuchów tekstowych w jĊzyku JavaScript uĪywa siĊ operatora „plus”: var theEnd = KONIEC. var result = Poczætek, + ħrodek i + theEnd; W powyĪszym przykáadzie zmienna result jest obecnie áaĔcuchem tekstowym: „Poczætek, ħrodek i KONIEC.”. 26 ASP.NET 2.0 AJAX. Zaawansowane programowanie Interpretery JavaScript uĪywają do zapisu liczb standardu zmiennoprzecinkowego IEEE. Nie wchodząc w szczegóáy, moĪna przyjąü, Īe w wiĊkszoĞci zadaĔ nie bĊdzie z tym problemów. Typ Boolean w jĊzyku JavaScript jest prawie tym, czego moĪna by siĊ spodziewaü, ale nie- zupeánie. Typ ten okreĞla, czy dane wyraĪenie jest prawdziwe, czy nie, jednak wzoruje siĊ na jĊzyku C, uĪywając wartoĞci caákowitych 0 i 1. JavaScript dopuszcza zmienne niemające wartoĞci, zmienna moĪe byü po prostu nieokreĞlona, co moĪe prowadziü do niespodziewanych rezultatów. W poniĪszym fragmencie JavaScriptu zadeklarowane są trzy zmienne. Wszystkie z porównaĔ zwracają wartoĞü true. script type= text/javascript var one = 1; var zero = 0; var undefinedVar; if(one) { alert( 1 ma wartoħè prawdziwæ ); } if(!zero) { alert( 0 ma wartoħè fađszywæ ); } if (!undefinedVar) { // ten test mówi nam, Īe undefinedVar albo zawiera 0, // albo jest naprawdĊ niezdefiniowana, w obu przypadkach ma wartoĞü faászywą alert( undefinedVar ma wartoħè fađszywæ ); } if (one != zero) { alert( jeden i zero nie sæ tym samym ); } /script MoĪesz sprawdziü, czy zmienna zostaáa zdefiniowana, w nastĊpujący sposób: if ( typeof(undefinedVar ) == undefined ) { alert( undefinedVar jest niezdefiniowane ); } Zmienne mogą mieü teĪ wartoĞü null i róĪnią siĊ wówczas od niezdefiniowanych, bo null jest jednak pewną wartoĞcią. Funkcje w JavaScripcie są równieĪ prawdziwymi typami. Mogą przyjmowaü argumenty i zwra- caü wartoĞü. Funkcje mogą byü przekazywane do innych funkcji oraz tworzone dynamicznie przez kod skryptowy. Oto dwie równowaĪne definicje funkcji o nazwie Add pobierającej dwie zmiennej i zwracającej rezultat zastosowania operatora „plus”. ProszĊ zauwaĪyü, Īe nie powiedziaáem, Īe przyjmuje dwie liczby. Warto pamiĊtaü, Īe zmienne JavaScript nie mają okreĞlonego typu, wiĊc mógábym równie dobrze przesáaü dwa áaĔcuchy znakowe, a funkcja Add by je poáączyáa. script type= text/javascript function Add(x, y) { RozdziaÄ 1. Q Tworzenie nowej generacji aplikacji WWW 27 return x + y; } var AddAgain = function(x, y) { return x + y; }; /script Po stworzeniu funkcji jednym z powyĪszych sposobów moĪna ją wywoáaü w danym (lub dowolnym zagnieĪdĪonym w stosunku do niego) zakresie w celu wykonania dodawania. ĩaden z tych sposobów tworzenia funkcji nie ma przewagi nad drugim. MoĪna po prostu wybraü bardziej odpowiadający. script type= text/javascript var result = Add(36, 24); alert(result); // wyĞwietla 60 var stringResult = Add( Witaj , cie. ); alert(stringResult); // wyĞwietla Witajcie. /script Obiekty i tablice są tylko kolekcjami innych typów. Typy tablicowe nie wymagają, by wartoĞci w nich przechowywane miaáy nazwĊ; zamiast tego są dostĊpne przez indeks. WartoĞci przechowywane w obiekcie są okreĞlane przez nazwy pola lub wáaĞciwoĞci. Obiekty mogą teĪ zawieraü funkcje (które mogą byü akcesorami, funkcjami dającymi publiczny dostĊp do lokalnych zmiennych), co pozwala tworzyü w kodzie JavaScript struktury danych reprezen- tujące rzeczywiste obiekty. W tym swego rodzaju programowaniu obiektowym brakuje koncepcji dziedziczenia typów. Microsoft AJAX Library dostarcza zestaw klas i rekomen- dowanych wzorców programowania, pozwalających uzyskaü w jĊzyku JavaScript dziedzicze- nie, czyniąc bardziej naturalnym przechodzenie pomiĊdzy JavaScriptem a innymi jĊzykami wy- sokiego poziomu. PoniĪszy fragment kodu zawiera definicjĊ obiektu Album przechowującego i zwracającego tytuá i autora albumu muzycznego. Do przechowywania informacji o kilku albumach uĪyta jest tablica: script type = text/javascript // zdefiniuj obiekt o nazwie Album - proszĊ zauwaĪyü, Īe nie ma on zdefiniowanego typu Album = function (title, artist) { var _title = title; var _artist = artist; this.get_title = function() { return _title; } this.get_artist = function() {return _artist; } } // utwórz egzemplarz obiektu, wywoáując konstruktora var albumA = new Album( Na wylot , Fisz ); var albumB = new Album( Polepione dļwiúki , Fisz ); // utwórz tablicĊ przechowującą te egzemplarze (równieĪ bez okreĞlonego typu) var albumArray = new Array(); albumArray[0] = albumA; albumArray[1] = albumB; // przejdĨ kolejno po tablicy, by pokazaü tytuáy albumów for(var i = 0; i albumArray.length; i++) { alert((albumArray[i]).get_title()); // wywoáaj akcesor get_title } /script 28 ASP.NET 2.0 AJAX. Zaawansowane programowanie Komponent usÄug sieci WWW Zasadnicza koncepcja usáug sieci WWW ma ogromne moĪliwoĞci, wciąĪ siĊ rozwija i ewolu- uje. Oryginalny standard SOAP (ang. Simple Object Access Protocol — protokóá proste- go dostĊpu do obiektów) polega na wykorzystaniu protokoáu HTTP do przesyáania danych w formacie XML z klienta do serwera i odbierania tak samo uformowanych danych. MoĪe siĊ to odbywaü z poziomu przeglądarki WWW przy uĪyciu obiektu XmlHttpRequest lub bezpo- Ğrednio z aplikacji biurkowej lub innego serwera. Zanim usáugi sieci WWW zostaáy powszech- nie przyjĊte, nierzadko zdarzaáo siĊ tworzenie programów, które pobieraáy stronĊ jako dokument HTML i wyciągaáy z niej potrzebne dane. Ta technika nosi nazwĊ przechwytywania danych ekranowych (ang. screen-scraping). Powoduje ona róĪnorakie frustracje, poniewaĪ strony są wciąĪ uaktualniane, a klienty przechwytujące dane ekranowe, by dotrzymaü kroku zmianom, muszą wciąĪ modyfikowaü kod analizujący skáadniĊ, tak by odpowiadaá nowemu kodowi HTML strony Ĩródáowej. Prowadziáo to do frustracji, gdyĪ witryny prezentujące dane za pomocą wizualnych stron HTML áatwo byáo modyfikowaü, a to zaáamywaáo program przechwytujący dane ekranowe, który spodziewaá siĊ danych w oryginalnym formacie. Usáugi sieci WWW zostaáy pomyĞlane jako niewizualna metoda przesyáania danych przez sieü WWW i w naturalny sposób izolują zdalne wywoáywanie metod od warstwy prezentacji. Obecnie, zamiast przechwytywaü dane ekranowe, moĪesz wywoáaü usáugĊ sieci WWW i otrzymaü dane w formacie XML áatwym do uĪycia przez program. DziĊki przesyáaniu czystych danych tekstowych w formacie XML i usuniĊciu elementów wizu- alnych informacjĊ przesyáaną przez usáugi sieci WWW duĪo áatwiej zanalizowaü skáadniowo niĪ HTML. A poniewaĪ XML moĪe zawieraü osadzony schemat, kod moĪe go sprawdziü i wy- korzystaü do ustalenia uĪytych struktur i typów danych. MoĪesz rozszerzaü schemat wysyáa- ny ze zwracanymi danymi, nie martwiąc siĊ, Īe aplikacje konsumenckie przestaną dziaáaü. DziĊki temu czytniki XML mogą w pewnym stopniu tolerowaü modyfikacje, które z pew- noĞcią sprawiáyby programiĞcie przechwytującemu dane ekranowe wiele zmartwieĔ. Schemat danych moĪe byü rozszerzany bez potrzeby aktualizacji wszystkich aplikacji kon- sumenckich. Mogą one w prosty sposób pozyskaü te czĊĞci dokumentu XML, które chcą przetwarzaü, i zignorowaü resztĊ. Przekroczono teĪ granicĊ prostych formatów XML. Inaczej niĪ w poprzednich implementacjach usáug sieci WWW, obecnie moĪna zdefiniowaü kon- trakty usáug sieci WWW, aby zastosowaü wybrany format danych i uĪyü dowolnego z licznych protokoáów sieciowych. Czynnikiem napĊdzającym koncepcjĊ usáug sieci WWW jest moĪ- liwoĞü áatwego dostĊpu do danych z róĪnych aplikacji w luĨno powiązany sposób, a nowa warstwa komunikacyjna Microsoft Windows Communication Foundation wprowadziáa tĊ koncepcjĊ na nowy poziom, umoĪliwiając okreĞlenie w kontrakcie protokoáów sieciowych, reguá wdraĪania i infrastruktury logowania, a takĪe zapewniając wsparcie dla transakcji. ASP.NET AJAX dostarcza zestaw obiektów zastĊpczych (ang. proxy object) w celu zapewnie- nia dostĊpu do niektórych nowych usáug sieci WWW wbudowanych w ASP.NET. Dane profilu, usáugi czáonkostwa i zarządzanie rolami mogą byü áatwo dostĊpne z poziomu klienta. Pro- gramiĞci nie muszą tworzyü wáasnej infrastruktury wsparcia dla tych podstawowych usáug aplikacyjnych. Wystarczy dodaü kilka wierszy kodu, by wykorzystaü zasoby serwera z poziomu kodu JavaScript uruchomionego w przeglądarce. DziĊki temu bardzo wzrósá zasiĊg ASP.NET, obejmując zarówno klienta, jak i serwer. PoniewaĪ biblioteki JavaScript zaprojektowano RozdziaÄ 1. Q Tworzenie nowej generacji aplikacji WWW 29 tak, by byáy áatwe w uĪyciu dla programistów znających programowanie w .NET po stronie serwera, caáa ta dodatkowa funkcjonalnoĞü jest wygodnie opakowana i áatwa do wykorzy- stania. Komponent Dynamicznego HTML Dynamiczny HTML nie jest oddzielną technologią, ale uĪyciem zestawu technologii w okreĞlo- ny sposób. Po wywoáaniu serwera WWW przeglądarka otrzymuje dokument HTML. Na- stĊpnie rysuje stronĊ, a uĪytkownik moĪe ją zobaczyü. Przeglądarka udostĊpnia równieĪ Document Object Model (DOM) reprezentujący strukturĊ wyĞwietlanego HTML. Do DOM moĪe mieü dostĊp kod JavaScript, który jest osadzony w stronie albo strona do niego odsy- áa. Na wygląd HTML wpáywa zastosowa
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ASP.NET 2.0 AJAX. Zaawansowane programowanie
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ą: