Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00498 014126 11055617 na godz. na dobę w sumie
Visual Basic 2005. Wprowadzenie do programowania w .NET - książka
Visual Basic 2005. Wprowadzenie do programowania w .NET - książka
Autor: Liczba stron: 592
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-0696-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).

Wszechstronny przewodnik po świecie programowania w .NET
dla programistów języka Visual Basic

Wciąż zastanawiasz się nad przejściem z Visual Basic 6 na wersję pracującą w środowisku .NET? Najwyższa pora! Visual Basic 2005 to język, na który wielu programistów czekało od lat. Jest w pełni obiektowy, ma usprawnioną obsługę błędów, nowy model obsługi zdarzeń oraz udostępnia wiele innych funkcji, które znacznie zwiększają produktywność. Integracja z .NET pozwala korzystać w języku Visual Basic z wszystkich możliwości tej platformy, pracować we wspólnym środowisku uruchomieniowym (CLR) i używać rozbudowanej biblioteki klas .NET.

'Visual Basic 2005. Wprowadzenie do programowania w .NET' to wszechstronny przewodnik po świecie programowania w najnowszej wersji języka Visual Basic. Czytając tę książkę, dowiesz się, jakie zmiany zostały wprowadzone w wersjach języka Visual Basic zgodnych z platformą .NET. Nauczysz się wykorzystywać je do przyspieszenia i ułatwienia programowania. Poznasz udogodnienia dostępne w środowisku Visual Studio, techniki wygodnej obsługi baz danych przy użyciu ADO.NET, udoskonalone narzędzia diagnostyczne i wiele innych funkcji, które ułatwią Ci tworzenie programów wysokiej jakości.

Poznaj Visual Basic 2005 i dołącz do społeczności programistów .NET.

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

Darmowy fragment publikacji:

Visual Basic 2005. Wprowadzenie do programowania w .NET Autor: Matthew MacDonald T³umaczenie: Adam Majczak, Tomasz Walczak ISBN: 978-83-246-0696-2 Tytu³ orygina³u: The Book of Visual Basic 2005: NET Insight for Classic VB Developers Format: B5, stron: 592 Wszechstronny przewodnik po œwiecie programowania w .NET dla programistów jêzyka Visual Basic (cid:129) Jakie nowe funkcje oferuje Visual Basic 2005? (cid:129) Jak wykorzystaæ najnowsze w³aœciwoœci jêzyka Visual Basic 2005 do przyspieszenia i u³atwienia programowania? (cid:129) Jak zwiêkszyæ produktywnoœæ, wykorzystuj¹c mo¿liwoœci platformy .NET? Wci¹¿ zastanawiasz siê nad przejœciem z Visual Basic 6 na wersjê pracuj¹c¹ w œrodowisku .NET? Najwy¿sza pora! Visual Basic 2005 to jêzyk, na który wielu programistów czeka³o od lat. Jest w pe³ni obiektowy, ma usprawnion¹ obs³ugê b³êdów, nowy model obs³ugi zdarzeñ oraz udostêpnia wiele innych funkcji, które znacznie zwiêkszaj¹ produktywnoœæ. Integracja z .NET pozwala korzystaæ w jêzyku Visual Basic z wszystkich mo¿liwoœci tej platformy, pracowaæ we wspólnym œrodowisku uruchomieniowym (CLR) i u¿ywaæ rozbudowanej biblioteki klas .NET. „Visual Basic 2005. Wprowadzenie do programowania w .NET” to wszechstronny przewodnik po œwiecie programowania w najnowszej wersji jêzyka Visual Basic. Czytaj¹c tê ksi¹¿kê, dowiesz siê, jakie zmiany zosta³y wprowadzone w wersjach jêzyka Visual Basic zgodnych z platform¹ .NET. Nauczysz siê wykorzystywaæ je do przyspieszenia i u³atwienia programowania. Poznasz udogodnienia dostêpne w œrodowisku Visual Studio, techniki wygodnej obs³ugi baz danych przy u¿yciu ADO.NET, udoskonalone narzêdzia diagnostyczne i wiele innych funkcji, które u³atwi¹ Ci tworzenie programów wysokiej jakoœci. (cid:129) Mo¿liwoœci platformy .NET (cid:129) Praca w Visual Studio (cid:129) Programowanie obiektowe w Visual Basic 2005 (cid:129) Tworzenie interfejsów u¿ytkownika przy u¿yciu formularzy Windows (cid:129) Podzespo³y i komponenty (cid:129) Diagnozowanie programów w Visual Studio (cid:129) Praca z bazami danych przy u¿yciu ADO.NET (cid:129) Programowanie wielow¹tkowe (cid:129) Tworzenie aplikacji i us³ug sieciowych (cid:129) Instalowanie programów napisanych w Visual Basic 2005 Poznaj Visual Basic 2005 i do³¹cz do spo³ecznoœci programistów .NET Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści WPROWADZENIE ...................................................................................... 17 1 REWOLUCJA .NET ..................................................................................... 23 Krótka historia języka Visual Basic .........................................................................................23 Wejście w .NET .................................................................................................................24 Ograniczenia „klasycznego” Visual Basic ................................................................................25 Dziwaczna mieszanina Visual Basic ....................................................................................25 Odrębne języki ...................................................................................................................25 Bóle głowy przy rozwoju projektu .....................................................................................25 Piekło DLL .........................................................................................................................26 Niepełne wsparcie dla programowania obiektowego ........................................................26 Wizja .NET .............................................................................................................................26 Składniki .NET ....................................................................................................................27 Common Language Runtime (CLR) ...................................................................................27 Klasy .NET .........................................................................................................................28 Mówienie w tym samym języku .........................................................................................29 Dogłębna integracja języków .............................................................................................30 Przygotowana infrastruktura ..............................................................................................30 Usługi sieciowe i internet kolejnej generacji ......................................................................31 Otwarte standardy: XML, SOAP, WSDL oraz pozostałe litery alfabetu ............................31 Metadane. Czy to koniec piekła DLL? ................................................................................32 Czy VB 2005 to jeszcze wciąż VB? .........................................................................................33 Udoskonalenia, bez których nie da się żyć .........................................................................33 A teraz zmiany, które mogą frustrować .............................................................................34 Ciemne strony .NET ..........................................................................................................34 A co z COM? ......................................................................................................................35 I co dalej? ................................................................................................................................35 2 ŚRODOWISKO PROGRAMOWANIA ...........................................................37 Nowości w .NET ................................................................................................................... 38 Rozpoczynanie pracy w IDE .................................................................................................. 39 Strona początkowa ............................................................................................................ 40 Zmiana zachowania przy uruchamianiu ............................................................................. 41 Tworzenie projektu ........................................................................................................... 42 Dokumenty z zakładkami .................................................................................................. 44 Dokowane i zgrupowane okna .......................................................................................... 45 Zwiedzanie Visual Studio ....................................................................................................... 45 Wyszukiwarka rozwiązań Solution Explorer ..................................................................... 46 Przybornik: Toolbox .......................................................................................................... 47 Okno właściwości: Properties ........................................................................................... 49 Wyświetlanie kodu ............................................................................................................ 50 Dzielenie okien .................................................................................................................. 52 Lista zadań Task List .......................................................................................................... 53 Strzępki kodu: Code Snippets ............................................................................................... 55 Wstawianie strzępków ...................................................................................................... 55 Zarządzanie strzępkami ..................................................................................................... 56 Makra ..................................................................................................................................... 57 Makro IDE ......................................................................................................................... 58 Tymczasowa makroinstrukcja — Temporary Macro ........................................................ 59 Makra z inteligencją ........................................................................................................... 59 Makroinstrukcje a zdarzenia .............................................................................................. 60 Najprostszy możliwy program w środowisku .NET ............................................................. 62 Pliki tworzące projekt aplikacji MyFirstConsoleApplication .............................................. 63 Foldery projektu aplikacji MyFirstConsoleApplication ...................................................... 64 Własności projektu — Project Properties ......................................................................... 65 I co dalej? ............................................................................................................................... 67 3 PODSTAWY VB 2005 .................................................................................69 Nowości w .NET ................................................................................................................... 70 Wprowadzenie do biblioteki klas .......................................................................................... 72 Namespace ........................................................................................................................ 72 Assembly — skompilowany kod namespace ..................................................................... 75 Typy danych ...................................................................................................................... 75 Stosowanie biblioteki klas ...................................................................................................... 77 Dodanie referencji do pliku assembly ................................................................................ 78 Jak importować namespace? .............................................................................................. 80 Wykorzystanie przestrzeni namespace z biblioteki klas .................................................... 82 Szczególny obiekt — My ................................................................................................... 85 Pliki kodu ............................................................................................................................... 88 Bloki klas i modułów .......................................................................................................... 89 Bloki namespace ................................................................................................................ 90 Dodanie plików kodu ........................................................................................................ 91 6 S p i s t r e ś c i Typy danych ...........................................................................................................................91 Typy danych w namespace System ....................................................................................92 Wspólna deklaracja wielu zmiennych .................................................................................92 Inicjator VB — Initializer ....................................................................................................93 Typy danych jako obiekty ...................................................................................................93 Typ String ...........................................................................................................................94 Bardziej efektywne obiekty klasy String .............................................................................97 Czas i data ..........................................................................................................................98 Macierze .............................................................................................................................98 Macierze i interfejs IEnumerable ........................................................................................99 Wbudowane cechy macierzy ...........................................................................................100 Macierze jako typy referencyjne ......................................................................................101 Zmiany w działaniu operatorów ..........................................................................................102 Skrócony zapis operatorów przypisania ...........................................................................102 Konwersja typu zmiennej .................................................................................................103 Math, czyli nieco matematyki ...........................................................................................104 Random numbers — liczby pseudolosowe ......................................................................104 Pewne nowe reguły dostępności — Scope ......................................................................104 Logika na skróty ...............................................................................................................105 Szybkie pomijanie iteracji w pętli .....................................................................................107 Rozszerzone procedury .......................................................................................................107 Wywołanie metody ..........................................................................................................108 Poprzez wartość lub poprzez referencję: ByVal, ByRef ...................................................108 Słowo kluczowe Return ...................................................................................................109 Opcjonalne parametry .....................................................................................................110 Wartości domyślne ...........................................................................................................111 Przeciążenie metod ..........................................................................................................111 Delegaty ...........................................................................................................................113 I co dalej? ..............................................................................................................................116 4 FORMULARZE WINDOWS ....................................................................... 117 Nowości w .NET .................................................................................................................118 Rozpoczęcie pracy ...............................................................................................................119 Zasobnik komponentów: Component Tray ....................................................................120 Zindywidualizowane kreatory: Custom Designers ..........................................................120 Blokowanie obiektów sterujących ...................................................................................121 Układ graficzny obiektów sterujących .................................................................................122 Kotwiczenie .....................................................................................................................122 Dokowanie .......................................................................................................................124 Maksymalny i minimalny rozmiar okna ............................................................................126 Automatyczne przewijanie ...............................................................................................127 Podzielone okna ...............................................................................................................127 Obiekty sterujące będące pojemnikami ...........................................................................130 S p i s t r e ś c i 7 Obiekty sterujące i zdarzenia .............................................................................................. 131 Obsługiwanie więcej niż jednego zdarzenia .................................................................... 133 Przyciski Accept i Cancel ................................................................................................. 134 Badanie formularzy .NET .................................................................................................... 135 Dwa sposoby na pokazanie formularza ........................................................................... 136 Formularze i obiekt My ................................................................................................... 138 Formularze modalne ....................................................................................................... 139 Formularz startowy i tryb wyłączenia ............................................................................. 140 Zdarzenia aplikacji ........................................................................................................... 140 Osobliwości formularzy ................................................................................................... 142 Wewnętrzne działanie formularzy ....................................................................................... 144 Formularze „pod kapeluszem” Visual Basic 6 ................................................................. 144 Formularze „pod kapeluszem” w Visual Basic 2005 ........................................................ 146 Przechodzenie przez „bagno i breję” .............................................................................. 147 A co z informacjami binarnymi? ....................................................................................... 149 Dynamiczne dodawanie obiektów sterujących ................................................................... 149 Dynamiczne podłączenie obsługi zdarzenia .................................................................... 151 Interakcja pomiędzy formularzami ...................................................................................... 153 Problem z interakcją przykładowego formularza ............................................................ 153 Okna dialogowe ............................................................................................................... 155 Formularze przyporządkowane ...................................................................................... 156 Interfejsy MDI .................................................................................................................. 157 Więcej obiektów sterujących w .NET ................................................................................. 159 Paski i menu ..................................................................................................................... 160 Ikony powiadamiające ..................................................................................................... 164 Nowy rodzaj komponentów — Provider ....................................................................... 167 I co dalej? ............................................................................................................................. 168 5 PROGRAMOWANIE OBIEKTOWE .............................................................169 Nowości w .NET ................................................................................................................. 170 Wprowadzenie do programowania obiektowego ................................................................. 171 Co to jest programowanie obiektowe? ........................................................................... 172 Problemy z tradycyjnym programowaniem strukturalnym ............................................. 172 Najpierw były sobie struktury… ......................................................................................... 173 Bardzo prosta struktura danych personalnych ................................................................ 174 Jak do struktury wbudować inteligencję? ........................................................................ 175 Utworzenie instancji obiektu danej klasy ........................................................................ 177 Obiekty — rzut oka na zaplecze ..................................................................................... 178 Klasy w kawałkach ........................................................................................................... 181 Rozbudowa klasy poprzez dodanie własności ..................................................................... 182 Własności tylko do odczytu ............................................................................................. 185 Rozbudowa klasy poprzez dodanie konstruktora .................................................................. 186 Konstruktory pobierające argumenty .............................................................................. 187 Klasy z wieloma konstruktorami ..................................................................................... 188 8 S p i s t r e ś c i Konstruktor domyślny ......................................................................................................190 Destruktory ......................................................................................................................191 Mechanizm „Garbage Collection” w Visual Studio ..........................................................191 Rozbudowa klasy poprzez dodanie zdarzeń ........................................................................194 Zdarzenie w akcji, czyli jak to działa ................................................................................195 Zdarzenia o różnych sygnaturach ....................................................................................198 Numeratory .........................................................................................................................200 Jak powstał pomysł na numerację? ...................................................................................202 Co się dzieje „pod kapeluszem” w typie wyliczeniowym? ...............................................203 Stosowanie typu wyliczeniowego w połączeniu ze zdarzeniami .....................................205 Współużytkowane komponenty klas i obiektów .................................................................207 Współużytkowane metody ..............................................................................................208 Współużytkowane własności ...........................................................................................210 Zaglądamy pod maskę modułu ........................................................................................211 Ocena klas ............................................................................................................................212 Typy — obraz ogólny .......................................................................................................213 Inspekcja obiektów w naszej aplikacji ..............................................................................214 I co dalej? ..............................................................................................................................215 6 OPANOWANIE OBIEKTÓW ..................................................................... 217 Nowości w .NET .................................................................................................................218 Filozofia programowania obiektowego ................................................................................218 Idea czarnej skrzynki ........................................................................................................219 Luźne łączenie ..................................................................................................................220 Spójność ...........................................................................................................................221 Co reprezentują klasy? .....................................................................................................221 Dziedziczenie .......................................................................................................................222 Podstawy dziedziczenia ....................................................................................................223 Konstruktory w klasach potomnych ................................................................................225 Komponenty klas o statusie Protected ............................................................................227 Przysłanianie metod .........................................................................................................228 Casting .............................................................................................................................231 Klasy abstrakcyjne i słowo kluczowe MustInherit ............................................................232 Przysłanianie obowiązkowe MustOverride ......................................................................233 Dziedziczenie wielopoziomowe ......................................................................................234 Czy dziedziczenie jest dobrym pomysłem? ......................................................................235 Używanie dziedziczenia w celu rozszerzenia klas .NET ..................................................236 Interfejsy ...............................................................................................................................241 Używanie interfejsów .......................................................................................................243 Interfejsy i wsteczna kompatybilność ...............................................................................244 Używanie typowych interfejsów .NET ............................................................................245 Klasy kolekcji ........................................................................................................................251 Podstawowa kolekcja .......................................................................................................252 Klasa NuclearFamily .........................................................................................................252 S p i s t r e ś c i 9 Kolekcje wyspecjalizowane ............................................................................................. 255 Kolekcje ogólne ................................................................................................................ 255 I co dalej? ............................................................................................................................. 257 7 PLIKI SKOMPILOWANE I KOMPONENTY ...............................................259 Nowości w .NET ................................................................................................................. 260 Wprowadzenie do plików skompilowanych typu „assembly” ............................................. 261 Pliki skompilowane typu „assembly” kontra komponenty, które używają COM ............ 261 Dlaczego nigdy wcześniej nie spotkaliśmy się z tymi cechami? ....................................... 264 Postrzeganie programów jako plików skompilowanych typu „assembly” ...................... 265 Ustawianie informacji dotyczących pliku skompilowanego typu „assembly” .................. 267 Pobieranie informacji o pliku skompilowanym typu „assembly” ..................................... 270 Tworzenie komponentu .NET ............................................................................................ 273 Tworzenie projektu biblioteki klas .................................................................................. 273 Tworzenie klienta ............................................................................................................ 274 Globalny bufor plików skompilowanych GAC .................................................................... 276 GAC „pod maską” ........................................................................................................... 278 Tworzenie współdzielonego pliku skompilowanego typu „assembly” ............................ 279 Pliki strategii .................................................................................................................... 281 Tworzenie strategii wersji ............................................................................................... 282 Zasoby ................................................................................................................................. 284 Dodawanie zasobów ....................................................................................................... 284 Używanie zasobów .......................................................................................................... 286 I co dalej? ............................................................................................................................. 288 8 UODPORNIANIE NA BŁĘDY ...................................................................291 Nowości w .NET ................................................................................................................. 292 Skąd się biorą błędy? ............................................................................................................ 293 Zasady ochrony przed błędami ....................................................................................... 295 Błędy podczas kompilacji ................................................................................................. 296 Zastosowanie opcji Option Explicit i Option Strict ......................................................... 298 Numery wierszy kodu ..................................................................................................... 301 Narzędzia diagnostyczne w Visual Studio ............................................................................ 301 Podglądamy nasz program w działaniu ............................................................................ 302 Polecenia dostępne w trybie kroczącym Break Mode .................................................... 304 Okno punktów krytycznych Breakpoints ........................................................................ 305 Licznik Hit Count ............................................................................................................ 307 Okna podglądu: Autos, Locals i Watch ............................................................................ 308 Okno natychmiastowe Immediate .................................................................................. 310 Błędy w ruchu — Runtime Errors ................................................................................... 310 Strukturalna obsługa wyjątków ............................................................................................ 312 Mechanizm Error Call Stack ............................................................................................ 313 Ewolucja od mechanizmu On Error Goto ....................................................................... 314 Wyjątek jako obiekt ......................................................................................................... 315 10 S p i s t r e ś c i Filtrowanie przy użyciu wyjątku .......................................................................................317 Typy wyjątków .................................................................................................................318 Filtrowanie warunkowe ...................................................................................................319 Wygenerowanie własnego wyjątku ..................................................................................320 Udoskonalenie indywidualnej klasy wyjątków .................................................................322 Ostatnia linia obrony: zdarzenie UnhandledException .....................................................323 Programowanie defensywne ................................................................................................325 Zasady programowania defensywnego ............................................................................325 Testowanie założeń za pomocą Assert() .........................................................................326 Użycie metody Debug.WriteLine() ..................................................................................328 Śledzenie za pomocą pliku Log oraz metody Trace .........................................................329 I co dalej? ..............................................................................................................................331 9 PRACA Z DANYMI: PLIKI, DRUKOWANIE I XML .................................. 333 Nowości w .NET .................................................................................................................334 Interakcja z plikami ...............................................................................................................335 Odczytywanie i zapisywanie plików .....................................................................................336 Tworzenie pliku za pomocą obiektu My ..........................................................................336 Tworzenie pliku za pomocą klasy FileStream ..................................................................337 Klasy StreamWriter i StreamReader ................................................................................338 Klasy BinaryWriter i BinaryReader ...................................................................................339 Dostęp do plików w stylu Visual Basic .............................................................................343 Trochę więcej na temat łańcuchów .................................................................................343 Kompresja plików ............................................................................................................345 Zarządzanie plikami i folderami ...........................................................................................347 Klasa FileInfo ....................................................................................................................347 Prosta przeglądarka katalogów ........................................................................................351 „Przeglądanie” systemu plików ........................................................................................352 Serializacja obiektu ...............................................................................................................354 Zachowywanie i pobieranie obiektu zdatnego do serializacji ..........................................355 Precyzyjnie dostrojona serializacja ...................................................................................356 Klonowanie obiektów za pomocą serializacji ...................................................................357 Drukowanie i podgląd danych ..............................................................................................358 Drukowanie danych z macierzy .......................................................................................359 Drukowanie tekstu z przełamywaniem wierszy ..............................................................361 Drukowanie obrazów ......................................................................................................363 Ustawienia drukowania ....................................................................................................363 Podgląd wydruku .............................................................................................................365 Praca z rejestrem .................................................................................................................367 Pliki XML ..............................................................................................................................369 Czym tak w ogóle są pliki XML? ......................................................................................370 Pisanie prostego dokumentu XML ...................................................................................372 Odczytywanie plików XML ..............................................................................................373 Zaawansowane pliki XML ................................................................................................376 I co dalej? ..............................................................................................................................376 S p i s t r e ś c i 11 10 BAZY DANYCH I ADO.NET .....................................................................379 Nowości w .NET ................................................................................................................. 380 Wprowadzenie do ADO.NET ............................................................................................. 381 Obsługa danych relacyjnych ............................................................................................ 381 Baza danych Northwind .................................................................................................. 382 SQL Server 2005 Express Edition ................................................................................... 383 Model bazujący na dostawcach ....................................................................................... 383 Podstawowe obiekty ADO.NET ......................................................................................... 385 Dostęp do przodu w trybie tylko do odczytu ..................................................................... 386 Obiekty Connection ........................................................................................................ 387 Obiekty Command .......................................................................................................... 390 Obiekty DataReader ........................................................................................................ 392 Aktualizowanie danych za pomocą obiektów Command .................................................... 395 Dlaczego warto używać obiektów Command? ............................................................... 396 Przykładowa aktualizacja danych ..................................................................................... 396 Wywoływanie procedur składowanych ........................................................................... 398 Używanie poleceń z parametrami ................................................................................... 400 Przykład transakcji ........................................................................................................... 402 Używanie obiektów DataSet ............................................................................................... 403 Kiedy należy używać obiektów DataSet? ......................................................................... 404 Zapełnianie obiektów DataSet za pomocą obiektów DataAdapter ................................ 404 Dostęp do informacji zapisanych w obiektach DataSet ................................................... 405 Usuwanie rekordów ........................................................................................................ 406 Dodawanie informacji do obiektów DataSet ................................................................... 407 Korzystanie z wielu tabel ................................................................................................. 409 Relacje między obiektami DataTable .............................................................................. 409 Używanie obiektu DataSet do aktualizowania danych .................................................... 412 Aktualizowanie źródła danych ......................................................................................... 415 Ręczne tworzenie obiektów DataSet .............................................................................. 418 Wiązanie danych .................................................................................................................. 421 I co dalej? ............................................................................................................................. 424 11 WĄTKI .....................................................................................................427 Nowości w .NET ................................................................................................................. 428 Wprowadzenie do wątków ................................................................................................. 428 Wątki „pod maską” .......................................................................................................... 429 Porównywanie programów jedno- i wielowątkowych ................................................... 430 Skalowalność i prostota ................................................................................................... 431 Zegary a wątki ................................................................................................................. 431 Używanie komponentu BackgroundWorker do wykonywania podstawowych operacji na wątkach ........................................................ 433 Przesyłanie danych do komponentu BackgroundWorker i pobieranie ich z niego ......... 436 Śledzenie postępu ............................................................................................................ 439 Możliwość anulowania operacji ....................................................................................... 441 12 S p i s t r e ś c i Zaawansowane operacje na wątkach przy użyciu klasy Thread ..........................................442 Prosta aplikacja wielowątkowa ........................................................................................443 Przekazywanie danych do wątku .....................................................................................445 Wielowątkowość i interfejs użytkownika .........................................................................447 Podstawy zarządzania wątkami ............................................................................................449 Metody klasy Thread ........................................................................................................449 Priorytety wątków ...........................................................................................................452 Kiedy zbyt wiele to wciąż za mało? ..................................................................................452 Program wykorzystujący priorytety wątków ...................................................................452 Diagnozowanie wątków ...................................................................................................455 Synchronizacja wątków ........................................................................................................456 Potencjalne problemy z wątkami .....................................................................................456 Podstawy synchronizacji ..................................................................................................456 Przykładowy problem z synchronizacją ...........................................................................457 Rozwiązanie problemu za pomocą bloku SyncLock ........................................................460 I co dalej? ..............................................................................................................................461 12 ASP.NET I FORMULARZE SIECIOWE ....................................................... 463 Nowości w .NET .................................................................................................................464 Zarys tworzenia aplikacji sieciowych ...................................................................................464 Co było nie tak z klasyczną ASP? ......................................................................................465 Wprowadzenie do aplikacji sieciowych ................................................................................466 Tworzenie aplikacji sieciowych ............................................................................................467 Składniki projektu ASP.NET .............................................................................................469 Projektowanie formularzy sieciowych .................................................................................471 Podstawowe kontrolki .....................................................................................................471 Dodawanie kontrolek do formularzy sieciowych ............................................................472 Uruchamianie strony internetowej ..................................................................................475 Dodawanie metody obsługi zdarzenia .............................................................................477 Jak to działa? .....................................................................................................................477 Właściwość AutoPostback ...............................................................................................478 Zdarzenia kontrolek sieciowych ......................................................................................478 Formularze sieciowe „pod maską” ..................................................................................479 Stan widoku ......................................................................................................................481 Cykl przetwarzania stron .................................................................................................482 Inne kontrolki ...................................................................................................................483 Rozmyślania o stanie ............................................................................................................484 Budowa żądania ...............................................................................................................485 Wprowadzenie do problemu ...........................................................................................485 Zapisywanie dodatkowych informacji w stanie widoku ...................................................486 Przesyłanie informacji ...........................................................................................................488 Przekazywanie informacji w łańcuchach znaków zapytania .............................................488 Używanie stanu sesji ........................................................................................................491 Używanie stanu aplikacji ...................................................................................................493 Podsumowanie różnych technik zarządzania stanem ......................................................495 S p i s t r e ś c i 13 Wyświetlanie danych za pomocą wiązania .......................................................................... 495 Podstawy wiązania danych w ASP.NET .......................................................................... 496 Kontrolki działające jako źródła danych .......................................................................... 497 Instalowanie witryn internetowych ..................................................................................... 499 Instalacja IIS ...................................................................................................................... 499 Katalogi wirtualne ............................................................................................................ 501 I co dalej? ............................................................................................................................. 504 13 USŁUGI SIECIOWE ....................................................................................505 Nowości w .NET ................................................................................................................. 506 Wizja interaktywnej sieci ..................................................................................................... 506 Usługi sieciowe — model COM dla internetu? ............................................................... 507 Współczesne usługi sieciowe ........................................................................................... 507 Czy usługi sieciowe to obiekty? ....................................................................................... 508 Tworzenie pierwszej usługi sieciowej ................................................................................. 508 Przygotowywanie usługi sieciowej .................................................................................. 509 Projekt usługi sieciowej ................................................................................................... 510 Klasa usługi sieciowej ....................................................................................................... 512 Dostęp do usługi sieciowej .............................................................................................. 513 Testowanie usług sieciowych .............................................................................................. 514 Działanie usługi sieciowej ................................................................................................ 515 Stosowanie otwartych standardów ..................................................................................... 517 XML i WSDL ................................................................................................................... 517 SOAP ............................................................................................................................... 518 Konsumowanie usług sieciowych ........................................................................................ 520 Klasa pośrednicząca ......................................................................................................... 520 Tworzenie aplikacji klienckiej .......................................................................................... 521 Dodawanie referencji sieciowej ...................................................................................... 522 Sprawdzanie klasy pośredniczącej ................................................................................... 523 Używanie klasy pośredniczącej ....................................................................................... 525 Diagnozowanie projektów usług sieciowych ................................................................... 526 Asynchroniczne wywoływanie usług sieciowych ................................................................. 527 Obsługa asynchroniczności w klasie pośredniczącej ....................................................... 528 Przykładowy klient asynchroniczny ................................................................................. 529 Anulowanie asynchronicznych żądań ............................................................................... 530 I co dalej? ............................................................................................................................. 531 14 INSTALACJA I WDRAŻANIE ....................................................................533 Nowości w .NET ................................................................................................................. 534 Programy instalacyjne .......................................................................................................... 534 Wymagania aplikacji .NET ............................................................................................... 535 ClickOnce ............................................................................................................................ 536 Publikowanie w internecie lub w sieci ............................................................................. 537 Instalowanie aplikacji za pomocą ClickOnce ................................................................... 541 14 S p i s t r e ś c i Aktualizowanie aplikacji ClickOnce ..................................................................................542 Publikowanie na płytach CD ............................................................................................544 Tworzenie projektu instalacyjnego Visual Studio .................................................................545 Podstawowe opcje projektów instalacyjnych ......................................................................546 Okno File System .............................................................................................................547 Okno Registry ..................................................................................................................550 Okno File Types ...............................................................................................................551 Interfejs użytkownika .......................................................................................................553 Niestandardowe operacje ................................................................................................557 Warunki uruchamiania ......................................................................................................558 I co dalej? ..............................................................................................................................559 SKOROWIDZ ........................................................................................... 561 S p i s t r e ś c i 15 Pliki skompilowane i komponenty CZĘŚĆ SPOŚRÓD NAJISTOTNIEJSZYCH ZMIAN DOTYCZĄCYCH SPOSOBU, W JAKI PROGRAMIŚCI POSŁUGUJĄCY SIĘ VB UPRAWIAJĄ SWÓJ BIZNES W ŚWIECIE .NET, WYNIKA Z WPROWADZENIA PLIKÓW SKOMPILOWANYCH typu assembly (ang. assemblies), uogólnionego terminu oznaczającego w .NET pliki wykonywalne aplikacji (.exe) oraz skompilowane kompo- nenty. W Visual Basic 6 tworzenie i wielokrotne wykorzystywanie komponentu było często skomplikowane, zwłaszcza jeżeli chciało się współdzielić i współużytkować rezultaty swojej pracy z aplikacjami zakodowanymi w innych językach progra- mowania. Kłopoty z rejestracją w systemie Windows i konflikty wersji — które występują, gdy dwa programy oczekują różnych wersji tego samego komponentu — pojawiają się zawsze wtedy, kiedy najmniej się tego spodziewamy, a uporanie się z nimi może zająć wiele godzin. Czytając rozdział, dowiesz się, w jaki sposób .NET rozwiązuje te przyprawiające o ból głowy problemy oraz zapoznasz się z nowym, lepszym modelem współdzielenia komponentów, który oferuje .NET. Dowiesz się także wystarczająco dużo, by stawić czoła rozdziałowi 14., w któ- rym omówiono, w jaki sposób można utworzyć zindywidualizowane programy instalacyjne do rozpowszechniania gotowych aplikacji. Nowości w .NET Czy to możliwe, by nastąpił nareszcie koniec przyprawiających o ból głowy kło- potów z rozpowszechnianiem wersji, trudów związanych z wdrażaniem oraz wielokrotnych konfliktów? Niniejszy rozdział prezentuje zmiany, które poja- wiają się w nowej filozofii wdrażania Microsoftu. Niektórymi z tych zmian są: Pliki skompilowane typu assembly Jeżeli jesteś doświadczonym programistą, widziałeś już, jak COM może uła- twić ponowne wykorzystanie kodu, pozwalając programistom na tworzenie i współdzielenie oddzielnych komponentów. Być może widziałeś także, jak wiele problemów może być spowodowane przez konflikt pomiędzy różnymi współdzielonymi komponentami oraz jak zainstalowanie jednego programu powoduje uszkodzenie innego. Pliki skompilowane typu assembly są zamien- nikami Microsoftu zastępującymi komponenty i tradycyjne pliki aplikacji, zawierającymi wbudowane metadane, a zaprojektowanymi po to, by uniknąć piekła z dołączaniem dynamicznych bibliotek .DLL. Nigdy więcej rejestrowania Pojawienie się plików skompilowanych typu assembly oznacza, że już nigdy więcej nie trzeba będzie polegać na rejestrze, by zachować ważne informacje o własnych komponentach. Zamiast tego wszystkie te informacje są prze- chowywane bezpośrednio w plikach programu, co czyni prostym kopiowanie aplikacji i komponentów z jednego komputera na drugi oraz umożliwia użyt- kownikowi współdzielenie komponentów w jego programach, bez koniecz- ności martwienia się szczegółami konfiguracji. Strategia numeracji i zgodności wersji .NET zapewnia użytkownikowi pełną kontrolę nad wersjami. Tylko użyt- kownik ma możliwość decydowania o tym, którą wersję komponentu będzie wykorzystywała jego aplikacja. Jeżeli w innej aplikacji zastosuje się zaktuali- zowaną wersję współdzielonego komponentu, nadal swobodnie można uży- wać oryginalnej wersji, na której zbudowana i przetestowana została własna aplikacja, nie tracąc gwarancji niezachwianej stabilności. Zasoby Zachodzi konieczność użycia w aplikacji binarnego obrazu, jednak obawiasz się, co się stanie, gdy ktoś usunie Twój plik obrazu, przemieści go lub będzie chciał dokonać w nim zmian? Z rozdziału dowiesz się, w jaki sposób zamieścić obraz w postaci danych binarnych wewnątrz pliku skompilowanego aplikacji, gdzie nikt nie będzie mógł się do nich dostać. Co więcej, Visual Studio nadal będzie umożliwiało Ci bezproblemowe aktualizowanie go. 260 R o z d z i a ł 7 . Wprowadzenie do plików skompilowanych typu „assembly” Plik skompilowany typu assembly jest w .NET odpowiednikiem plików typu .dll lub .exe. Po prostu plik skompilowany typu „assembly” to jakieś zgrupowanie zestawu funkcji programu, które odpowiada pojedynczemu komponentowi lub aplikacji. W programach, którym przyglądaliśmy się do tej pory, wszystkie funkcje i cechy były zakodowane wewnątrz jednego pliku skompilowanego typu „assem- bly”, który po skompilowaniu stawał się plikiem .exe. Jednak jeżeli chciało się utworzyć oddzielnie dystrybuowane komponenty, trzeba było podzielić dany program na kilka oddzielnych jednostek funkcjonalnych, które stawały się na- stępnie oddzielnymi plikami skompilowanymi typu „assembly”. Pliki skompilowane typu „assembly” kontra komponenty, które używają COM Na tym etapie prawdopodobnie zastanawiasz się, dlaczego programiści potrze- bują plików skompilowanych typu „assembly”, choć istnieje już COM — system służący do tworzenia i współdzielenia komponentów, który jest umieszczony w systemie operacyjnym Windows. Tutaj .NET także dokonuje wyraźnego prze- łomu. Dzięki wprowadzeniu plików skompilowanych typu „assembly” uciążliwe problemy z konfliktami wersji, z którymi programiści borykali się przez lata, na- reszcie mają się ku końcowi. Nie jest to tylko czcza gadanina — pliki skompi- lowane typu „assembly” posiadają kilka unikalnych cech, które czynią je całkowicie niepodobnymi do czegokolwiek, czego programiści Windows używali kiedykol- wiek wcześniej. Pliki skompilowane typu „assembly” są samoopisywalne Najbardziej rewolucyjnym aspektem plików skompilowanych typu „assembly” jest fakt, że są samoopisywalne. Każdy plik skompilowany typu „assembly”, który się utworzy, zawiera jeden lub więcej plików programu oraz własny, specyficzny wykaz nazywany manifestem. Taki manifest zawiera dodatkowe informacje zwane metadanymi (ang. metadata). Metadane to „dane o danych”. Zasadniczo kod programu to dane, a metadane to informacje o programie, takie jak jego nazwa, wersja, typy dostępne publicznie oraz zależności). Manifest zastępuje bibliotekę typów i informacje z rejestru Windows, używane w połączeniu z komponentami COM. I w ten sposób przechodzimy do następnej kwestii. Pliki skompilowane typu „assembly” nie potrzebują rejestru Wszystkie informacje niezbędne do używania komponentu lub uruchamiania apli- kacji są zawarte w manifeście pliku skompilowanego typu „assembly”, który za- warty jest dokładnie wewnątrz odpowiadającego mu pliku .dll lub .exe. Nie jest możliwym utworzenie programu w .NET bez automatycznego wygenerowania manifestu i odpowiedniego pliku skompilowanego typu „assembly”. Oznacza to, że P l i k i s k o m p i l o w a n e i k o m p o n e n t y 261 można skopiować aplikacje i komponenty na dowolny inny komputer używający .NET, a one automatycznie będą na nim działać. Nie ma potrzeby bawić się regsvr32.exe czy innymi niewygodnymi narzędziami, by dodać informacje do rejestru. W Visual Basic 6 można było stosunkowo łatwo przetransferować prostą aplikację z jednego komputera na inny. Jeśli jednak jakaś aplikacja używała in- nych komponentów COM lub obiektów sterujących ActiveX, trzeba było stawić czoła kilku nowym problemom. Mianowicie zachodziła potrzeba zarejestrowa- nia tych plików na każdym komputerze, który ich używał, a proces rejestracji mógł spowodować konflikt z innymi zainstalowanymi aplikacjami. W .NET można po prostu identyfikować i kopiować potrzebne pliki — nie zachodzi po- trzeba dokonywania jakichkolwiek rejestracji. Oczywiście jeżeli zapomni się podporządkowanego, pomocniczego pliku, nadal popada się w tarapaty. Pliki typu „assembly” mogą być prywatnie współużytkowane Aplikacja Visual Basic 6 może używać dwóch ogólnych typów komponentów: tych, które zostały zaprojektowane wewnątrzzakładowo w celu współdzielenia zestawu funkcji specyficznych dla danej firmy, oraz takich, które zostały utwo- rzone (a nawet mogą być sprzedawane) przez postronnych producentów kom- ponentów lub Microsoft. Ten drugi typ komponentów wymaga pewnego rodzaju centralnego składu (ang. central repository). W tradycyjnym programowaniu wy- korzystującym komponenty COM to katalog systemowy Windows jest miej- scem, w którym w pewnym sensie w sposób niezorganizowany składowane są wszystkie te (pomocnicze) pliki. W projekcie .NET globalny bufor pliku skom- pilowanego (ang. Global Assembly Cache), czyli GAC, pełni mniej więcej tę samą funkcję. Zajmiemy się nim później w tym rozdziale. W drugim ze scenariuszy — modułach kodu specyficznych dla danej firmy — komponenty nie muszą być współdzielone przez wszystkie aplikacje i pro- gramy znajdujące się w komputerze. Mogą być używane przez zaledwie jedną aplikację lub kilka aplikacji utworzonych przez tych samych programistów. Przy projektowaniu wykorzystującym komponenty COM nie istniał łatwy sposób implementowania tej techniki. Prywatne komponenty nadal musiały być wrzu- cane do katalogu systemowego wraz ze wszystkim, co oznaczało dodatkowe etapy rejestracji, niepotrzebne informacje dodawane do rejestru (takie jak unikalny identyfikator globalny, czyli GUID) oraz stos komponentów, które nie mogły być wykorzystywane ponownie przez inne programy. Jeżeli kiedykolwiek próbowałeś przejrzeć całą listę komponentów COM i do- dać niektóre z nich do swoich projektów Visual Basic, bez wątpienia zorientowałeś się, że wiele z elementów, które pojawiają się na liście, nie stanowi w istocie przykładów współdzielonych procedur ani zasobów dostarczanych przez innych projektantów aplikacji. Zamiast tego są one zaprojektowane z myślą o używaniu ich wraz z konkretną aplikacją, która jest zainstalowana na Twoim komputerze, i w zasadzie są bezużyteczne poza tym programem. Mo
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual Basic 2005. Wprowadzenie do programowania w .NET
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ą: