Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: [email protected]PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ IDZ DO IDZ DO ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG KATALOG KSI¥¯EK KATALOG KSI¥¯EK TWÓJ KOSZYK TWÓJ KOSZYK CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE O NOWOCIACH ZAMÓW INFORMACJE O NOWOCIACH ZAMÓW CENNIK ZAMÓW CENNI K CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE SPIS TRECI SPIS TRECI DODAJ DO KOSZYKA DODAJ DO KOSZYKA KATALOG ONLINE KATALOG ONLINE Delphi 8 .NET. Kompendium programisty Autor: Adam Boduch ISBN: 83-7361-485-0 Format: B5, stron: 840 Poznaj najnowsz¹ wersjê Delphi i stwórz aplikacjê dla platformy .NET W dobie tak dynamicznego rozwoju technologii informatycznych mo¿liwoæ szybkiego stworzenia aplikacji jest du¿ym atutem. Dlatego powstaj¹ coraz bardziej rozbudowane rodowiska programistyczne, umo¿liwiaj¹ce skonstruowanie aplikacji z „cegie³ek”, które mo¿na wykorzystywaæ wielokrotnie. Wród tych rodowisk programistycznych zas³u¿on¹ popularnoæ zyska³o Delphi, dostêpne obecnie w wersji 8. Wygodny i czytelny interfejs, jêzyk programowania oparty na znanym i popularnym Pascalu, mo¿liwoæ ³atwego po³¹czenia siê z dowoln¹ baz¹ danych oraz rozbudowany mechanizm tworzenia aplikacji wieloplatformowych to g³ówne zalety tego rodowiska. Ksi¹¿ka „Delphi 8 .NET. Kompendium programisty” to przewodnik po najnowszej wersji rodowiska Delphi, uwzglêdniaj¹cy jego nowe mo¿liwoci zwi¹zane z tworzeniem aplikacji dla platformy .NET. Zawiera opis rodowiska programistycznego i jêzyka ObjectPascal. Przedstawia sposoby pisania aplikacji po³¹czonych z bazami danych i korzystaj¹cych z technologii XML. Opisuje równie¿ podstawowe zasady wykorzystywania w tworzonych programach protoko³ów sieciowych, takich jak HTTP i SMTP. Ksi¹¿ka jest doskona³a zarówno dla pocz¹tkuj¹cych programistów Delphi, jak i dla tych, którzy chc¹ poszerzyæ swoj¹ wiedzê o zasady tworzenia aplikacji dla platformy .NET. • Zasady tworzenia aplikacji dla platformy .NET • Wizualne projektowanie aplikacji • Mechanizm komponentów • Projektowanie interfejsu u¿ytkownika i menu • Programowanie w jêzyku ObjectPascal • Korzystanie z procedur i funkcji • Zasady projektowania obiektowego • Programowanie oparte na zdarzeniach • Wykrywanie i usuwanie b³êdów w aplikacjach • Korzystanie z baz danych • Jêzyk SQL • Wykorzystywanie technologii XML w aplikacjach • Programowanie sieciowe i ASP.NET • Us³ugi sieciowe Cennym ród³em informacji jest dodatek, zawieraj¹cy praktyczne wskazówki dotycz¹ce zasad pisania czytelnego i przejrzystego kodu.
Poznaj najnowszą wersję Delphi i twórz aplikacje dla platformy .NET
W dobie tak dynamicznego rozwoju technologii informatycznych możliwość szybkiego stworzenia aplikacji jest dużym atutem. Dlatego powstają coraz bardziej rozbudowane środowiska programistyczne, umożliwiające skonstruowanie aplikacji z "cegiełek", które można wykorzystywać wielokrotnie. Wśród tych środowisk programistycznych zasłużoną popularność zyskało Delphi, dostępne obecnie w wersji 8. Wygodny i czytelny interfejs, język programowania oparty na znanym i popularnym Pascalu, możliwość łatwego połączenia się z dowolną bazą danych oraz rozbudowany mechanizm tworzenia aplikacji wieloplatformowych to główne zalety tego środowiska.
Książka "Delphi 8 .NET. Kompendium programisty" to przewodnik po najnowszej wersji środowiska Delphi, uwzględniający jego nowe możliwości związane z tworzeniem aplikacji dla platformy .NET. Zawiera opis środowiska programistycznego i języka ObjectPascal. Przedstawia sposoby pisania aplikacji połączonych z bazami danych i korzystających z technologii XML. Opisuje również podstawowe zasady wykorzystywania w tworzonych programach protokołów sieciowych, takich jak HTTP i SMTP. Książka jest doskonała zarówno dla początkujących programistów Delphi, jak i dla tych, którzy chcą poszerzyć swoją wiedzę o zasady tworzenia aplikacji dla platformy .NET.
* Zasady tworzenia aplikacji dla platformy .NET * Wizualne projektowanie aplikacji * Mechanizm komponentów * Projektowanie interfejsu użytkownika i menu * Programowanie w języku ObjectPascal * Korzystanie z procedur i funkcji * Zasady projektowania obiektowego * Programowanie oparte na zdarzeniach * Wykrywanie i usuwanie błędów w aplikacjach * Korzystanie z baz danych * Język SQL * Wykorzystywanie technologii XML w aplikacjach * Programowanie sieciowe i ASP.NET * Usługi sieciowe
Cennym źródłem informacji jest dodatek, zawierający praktyczne wskazówki dotyczące zasad pisania czytelnego i przejrzystego kodu.
Przekonasz się, że wizualne projektowanie aplikacji zdecydowanie przyspieszy Twoją pracę.
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Część I ........................................................................................................................................... 21
Rozdział 1. Wstęp do programowania.........................................................................................................................23Dawno, dawno temu…......................................................................................................23Czym jest programowanie?...............................................................................................24Języki programowania.......................................................................................................25
Kilka słów o kompilatorach ..............................................................................................29Działanie kompilatorów..............................................................................................30Który kompilator wybrać? ..........................................................................................31
Dzień programisty .............................................................................................................31Delphi ................................................................................................................................31
Object Pascal...............................................................................................................32Delphi — czy warto? ..................................................................................................32
Czego wymagamy od Czytelnika?....................................................................................33Delphi 8 .NET ...................................................................................................................33.NET ..................................................................................................................................34
Wspólny system typów...............................................................................................38Wspólny język wykonywania .....................................................................................38Metadane.....................................................................................................................39Działanie CLR ............................................................................................................39Zarządzanie aplikacją..................................................................................................40Podzespoły ..................................................................................................................41Biblioteka klas ............................................................................................................41Usługi sieciowe...........................................................................................................41Konkluzja....................................................................................................................43
Jak się uczyć? ....................................................................................................................46FAQ...................................................................................................................................47Przydatne odnośniki ..........................................................................................................49Podsumowanie ..................................................................................................................49
Pierwszy projekt................................................................................................................61Tworzenie projektu .....................................................................................................61Zapisywanie projektu..................................................................................................61Uruchamianie programu .............................................................................................62Zamykanie programu ..................................................................................................63Otwieranie projektu ....................................................................................................63
Kompilacja projektu..........................................................................................................63Pliki projektu .....................................................................................................................64Podstawowe paski narzędzi...............................................................................................65
Pasek Standard ............................................................................................................65Pasek View..................................................................................................................66Pasek Debug................................................................................................................66Pasek Desktop.............................................................................................................67Pasek Custom..............................................................................................................68Pozostałe paski narzędzi .............................................................................................68
Repozytorium obiektów ....................................................................................................68Dodawanie projektu do repozytorium ........................................................................69Ustawienia repozytorium............................................................................................70
Praca z paletą narzędzi ......................................................................................................71Umieszczanie komponentów na formularzu...............................................................71Umieszczanie kilku komponentów naraz ...................................................................72Przycisk Categories.....................................................................................................72Szukanie obiektu.........................................................................................................72
Praca z komponentami ......................................................................................................75.NET............................................................................................................................76Windows Forms i VCL.NET ......................................................................................76Komponent..................................................................................................................78Sterowanie komponentem...........................................................................................79
Praca z inspektorem obiektów...........................................................................................79Edycja właściwości .....................................................................................................80Zdarzenia.....................................................................................................................82Menu inspektora obiektów..........................................................................................82Opcje inspektora obiektów .........................................................................................83
Edytor WYSIWYG ...........................................................................................................97Projektant strony WWW.............................................................................................98Inspektor obiektów......................................................................................................98Dodatkowe paski narzędzi ..........................................................................................98Edycja pozostałych plików........................................................................................100Opcje HTML w Delphi.............................................................................................100
Projektowanie interfejsu..................................................................................................101Paski narzędziowe.....................................................................................................101Ikony dla paska narzędzi...........................................................................................103Menu narzędzi...........................................................................................................104Menu podręczne........................................................................................................106Pozostałe elementy interfejsu ...................................................................................106
Kilka wersji językowych programu ................................................................................110Tworzenie angielskiej wersji językowej ...................................................................110Tłumaczenie projektu................................................................................................112Kompilacja projektu..................................................................................................113Opcje Translation Manager.......................................................................................114
Opcje środowiska ............................................................................................................115FAQ.................................................................................................................................116Podsumowanie ................................................................................................................117
Rozdział 3. Język Delphi................................................................................................................................................ 119Aplikacje konsolowe .......................................................................................................120
Najprostszy program .......................................................................................................122Podstawowa składnia ......................................................................................................122
Czytanie kodu ...........................................................................................................122Wielkość liter ............................................................................................................123Pamiętaj o średniku! .................................................................................................123
8 Delphi 8 .NET. Kompendium programisty
Bloki begin i end.......................................................................................................123Dyrektywa program ..................................................................................................124
Wypisywanie tekstu ........................................................................................................126Położenie instrukcji...................................................................................................128Instrukcja Writeln .....................................................................................................128
Zmienne...........................................................................................................................129Deklaracja zmiennych...............................................................................................129Typy zmiennych........................................................................................................130Deklaracja kilku zmiennych .....................................................................................131Przydział danych.......................................................................................................132Deklaracja zakresu danych .......................................................................................134Restrykcje w nazewnictwie.......................................................................................135
Stałe.................................................................................................................................135Domyślne typy stałych..............................................................................................135
Tablice danych ................................................................................................................138Tablice jako stałe ......................................................................................................139Tablice wielowymiarowe..........................................................................................140Tablice dynamiczne ..................................................................................................142Polecenia Low i High................................................................................................143
Programowanie proceduralne..........................................................................................158Procedury i funkcje .........................................................................................................158
Procedury ..................................................................................................................158Funkcje......................................................................................................................161Zmienne lokalne........................................................................................................162Parametry procedur i funkcji ....................................................................................163Parametry domyślne..................................................................................................165Przeciążanie funkcji i procedur.................................................................................166Przekazywanie parametrów do procedur i funkcji....................................................167Procedury zagnieżdżone ...........................................................................................169
Własne typy danych ........................................................................................................169Tablice jako nowy typ...............................................................................................170
Zbiory ..............................................................................................................................190Przypisywanie elementów zbioru .............................................................................191Odczytywanie elementów ze zbioru .........................................................................192Dodawanie i odejmowanie elementów zbioru..........................................................193
Typy wariantowe.............................................................................................................193VarType, VarTypeAsText ........................................................................................194VarToStr ...................................................................................................................195VarIs*........................................................................................................................195
Pliki dołączane ................................................................................................................195Etykiety ...........................................................................................................................196Dyrektywy ostrzegawcze ................................................................................................197Wstęp do algorytmiki ......................................................................................................198
Funkcje konsolowe w .NET............................................................................................203Przykład — odczyt zawartości pliku ........................................................................204
Efektywny kod ................................................................................................................206Instrukcje warunkowe...............................................................................................206Typ Boolean w tablicach ..........................................................................................207Zbiory........................................................................................................................209Łączenie znaków w łańcuchach................................................................................209
Rozdział 4. Delphi bardziej zaawansowane .............................................................................................................213Na czym polega programowanie obiektowe? .................................................................214Biblioteki wizualne .........................................................................................................214Podstawowy kod formularza...........................................................................................215Formularz w VCL.NET...................................................................................................217
Sekcja uses ................................................................................................................217Klasa .........................................................................................................................218Zmienna wskazująca na klasę...................................................................................218Plik *.nfm..................................................................................................................218Generowanie kodu ....................................................................................................219Nazwy komponentów ...............................................................................................219
10 Delphi 8 .NET. Kompendium programisty
Programowanie zdarzeniowe ..........................................................................................220Generowanie zdarzeń................................................................................................220Lista zdarzeń w inspektorze obiektów......................................................................222Jedno zdarzenie dla kilku obiektów..........................................................................223
Edytor kodu .....................................................................................................................224Ukrywanie kodu........................................................................................................225Makra ........................................................................................................................225Code Insight ..............................................................................................................226Code Completion ......................................................................................................227Menu podręczne edytora kodu..................................................................................227Opcje edytora kodu ...................................................................................................229Skrawki kodu ............................................................................................................234
To-Do List .......................................................................................................................235Generowanie komentarza TODO .............................................................................236Menu podręczne okna ...............................................................................................237
Szablony kodu .................................................................................................................237Klasy................................................................................................................................238
Składnia klasy ...........................................................................................................239Do czego służą klasy?...............................................................................................239Hermetyzacja ............................................................................................................240Dziedziczenie............................................................................................................240Polimorfizm ..............................................................................................................241Instancja klasy...........................................................................................................241Konstruktor ...............................................................................................................241Destruktor .................................................................................................................242Pola ...........................................................................................................................242Metody ......................................................................................................................243Tworzenie konstruktorów i destruktorów.................................................................244Destruktory w .NET..................................................................................................247Poziomy dostępu do klasy ........................................................................................251Dziedziczenie............................................................................................................253Przeciążanie metod ...................................................................................................254Typy metod ...............................................................................................................254Przedefiniowanie metod............................................................................................256Typy zagnieżdżone ...................................................................................................260Parametr Self.............................................................................................................261Brak konstruktora......................................................................................................261Brak instancji klasy...................................................................................................263Class helpers .............................................................................................................264Klasy zaplombowane ................................................................................................265Słowo kluczowe static...............................................................................................266Właściwości ..............................................................................................................267
Parametr Sender procedury zdarzeniowej.......................................................................270Przechwytywanie informacji o naciśniętym klawiszu..............................................270Obsługa parametru Sender........................................................................................272
Operatory is i as...............................................................................................................273Metody w rekordach........................................................................................................274Interfejsy..........................................................................................................................275Przeładowanie operatorów ..............................................................................................277
Jakie operatory można przeładować? .......................................................................277Deklaracja operatorów..............................................................................................279Binary i Unary...........................................................................................................279
Wskaźniki a .NET ...........................................................................................................327Rejestry .....................................................................................................................328Stos............................................................................................................................328Sterta .........................................................................................................................329Do czego służą wskaźniki? .......................................................................................329
Debuger Delphi ...............................................................................................................329Interfejs Debug..........................................................................................................330Opcje projektu...........................................................................................................330Punkty przerwań .......................................................................................................332Polecenie Run to Cursor ...........................................................................................337Podgląd zmiennych...................................................................................................337Inspektor śledzenia....................................................................................................340Evaluate/Modify .......................................................................................................341Okno Call Stack ........................................................................................................342Okno Local Variables ...............................................................................................343Okno Thread Status...................................................................................................344Okno Event Log........................................................................................................345
12 Delphi 8 .NET. Kompendium programisty
Okno modułów..........................................................................................................346Okno deasemblacji....................................................................................................346Polecenie Go to Address...........................................................................................347Okno Message View.................................................................................................347
Praca krokowa.................................................................................................................348Ikony na gutterze.......................................................................................................348Przekraczanie i wkraczanie.......................................................................................349
Opcje debugera................................................................................................................350Strona Borland .NET Debugger................................................................................351Zakładka Language Exceptions ................................................................................351Zakładka Event Log..................................................................................................352
Menu związane z debugerem ..........................................................................................352FAQ.................................................................................................................................354Podsumowanie ................................................................................................................354
Rozdział 6. Migracja do .NET......................................................................................................................................355Czy warto przechodzić do .NET? ...................................................................................356Ewolucja platform programistycznych ...........................................................................356
Zmiany we właściwościach ......................................................................................358Elementy języka ..............................................................................................................358
Wszystko jest klasą!..................................................................................................358Przestrzenie nazw......................................................................................................361Kompilacja warunkowa ............................................................................................363Brakujące elementy...................................................................................................364Łańcuchy w Delphi ...................................................................................................373Komunikaty...............................................................................................................378Destruktory ...............................................................................................................379
WinForms........................................................................................................................380Brak pliku *.dfm/*.nfm.............................................................................................380VCL i WinForms ......................................................................................................385
Platform Invoke...............................................................................................................386Wywołanie tradycyjne ..............................................................................................387Użycie atrybutu DLLImport .....................................................................................388Parametry wyjściowe ................................................................................................388Dane wskaźnikowe ...................................................................................................390Pobieranie danych z bufora.......................................................................................391Kod zarządzany i niezarządzany...............................................................................392Używanie funkcji Win32 ..........................................................................................393Marshaling ................................................................................................................394Wady PInvoke...........................................................................................................406
.NET a obiekty COM ......................................................................................................406Terminologia COM...................................................................................................406Mechanizm COM Callable Wrappers.......................................................................408Przykładowy podzespół ............................................................................................408Utworzenie biblioteki typu .......................................................................................411Użycie biblioteki typu...............................................................................................412Korzystanie z klasy COM.........................................................................................414Kontrolki COM w aplikacjach .NET........................................................................417
Aplikacje sieciowe ..........................................................................................................418Bazy danych ....................................................................................................................419FAQ.................................................................................................................................419Podsumowanie ................................................................................................................420
Spis treści 13
Część II .......................................................................................................................................421
Rozdział 7. Bazodanowa architektura Delphi....................................................................................................... 423Czym jest baza danych? ..................................................................................................423Działanie baz danych ......................................................................................................424Rozwiązania alternatywne...............................................................................................425Baza danych kontra własny mechanizm .........................................................................426Rodzaje baz danych.........................................................................................................427
Bazy proste................................................................................................................427Relacyjne bazy danych .............................................................................................427Bazy danych typu klient-serwer................................................................................428Wielowarstwowa architektura baz danych ...............................................................429
Borland Database Engine ................................................................................................429Sterowniki bazy danych............................................................................................430Zbiory danych ...........................................................................................................430Komponenty bazodanowe.........................................................................................431
Praca z komponentami ....................................................................................................435Otwieranie i zamykanie zbioru danych.....................................................................435Przemieszczanie się wśród rekordów .......................................................................435Modyfikacja zawartości ............................................................................................437Pola rekordu bazy danych.........................................................................................439
Praca z tabelami ..............................................................................................................447Tworzenie tabel.........................................................................................................447Tworzenie kolumn w kodzie programu ....................................................................447
Filtrowanie tabel..............................................................................................................449Wykorzystanie właściwości Filter ............................................................................450Zdarzenie OnFilterRecord ........................................................................................451
Klient.........................................................................................................................480Serwer .......................................................................................................................480Klient-serwer oraz bazy lokalne ...............................................................................481
Język SQL .......................................................................................................................481Baza MySQL ............................................................................................................482InterBase ...................................................................................................................482
Schemat tworzenia aplikacji klient-serwer .....................................................................483Analiza ......................................................................................................................483Projekt .......................................................................................................................483Budowa .....................................................................................................................483
Programowanie w SQL-u................................................................................................484Klient MySQL ..........................................................................................................484Tworzenie bazy danych ............................................................................................486Tworzenie tabel.........................................................................................................487Zmiana struktury tabeli .............................................................................................493Indeksy......................................................................................................................495Dodawanie rekordów................................................................................................498Wyświetlanie informacji ...........................................................................................500Uaktualnianie zawartości ..........................................................................................505Usuwanie danych z tabeli .........................................................................................506Eksport i import bazy................................................................................................506
Aplikacja zarządzająca MySQL......................................................................................507Praca z programem MySQL Control Center ............................................................508Praca z tabelami ........................................................................................................509
InterBase..........................................................................................................................511Uruchomienie............................................................................................................512Program IBConsole...................................................................................................512MySQL a InterBase ..................................................................................................516Tworzenie tabel InterBase ........................................................................................525
dbExpress ........................................................................................................................526dbExpress kontra BDE..............................................................................................527Połączenie z bazą danych..........................................................................................527Komponent TSQLDataSet ........................................................................................533Komponent TSQLMonitor........................................................................................537Pozostałe komponenty dbExpress.............................................................................540Dystrybucja aplikacji dbExpress...............................................................................540
Okno Data Explorer ........................................................................................................540Wprowadzanie zmian w tabeli..................................................................................541Edytor połączeń ........................................................................................................541
Łączenie ze zdalnym serwerem.......................................................................................554Przykład wykorzystania IBX ..........................................................................................555
Tworzenie bazy danych ............................................................................................556Piszemy aplikację Helion DB!..................................................................................562
Rozdział 10. ADO.NET i BDP.NET.......................................................................................................................... 567Czym jest ADO? .............................................................................................................567Terminologia ...................................................................................................................568Warstwy dostępu .............................................................................................................569Architektura baz danych..................................................................................................570ADO.NET .......................................................................................................................570
Architektura ADO.NET............................................................................................571Źródło danych ...........................................................................................................571Dostarczyciel danych ................................................................................................571Zbiory danych ...........................................................................................................572
ADO.NET w praktyce.....................................................................................................572Łączenie ze źródłem ODBC .....................................................................................573Łączenie ze źródłem OleDB .....................................................................................574Wysyłanie zapytań (MS Access) ..............................................................................575
Część III ......................................................................................................................................599
Rozdział 11. XML ...............................................................................................................................................................601Niezależność XML-a.......................................................................................................602XHTML...........................................................................................................................602Budowa dokumentu.........................................................................................................602
Prolog........................................................................................................................603Znaczniki...................................................................................................................604Atrybuty ....................................................................................................................606Podstawowa terminologia.........................................................................................606Węzeł główny ...........................................................................................................607Komentarze ...............................................................................................................607Przestrzenie nazw......................................................................................................607Składnia przestrzeni nazw.........................................................................................608Przestrzenie nazw i atrybuty .....................................................................................608
16 Delphi 8 .NET. Kompendium programisty
DTD.................................................................................................................................609Deklaracja elementu..................................................................................................610Deklaracja atrybutu...................................................................................................610DTD w osobnym pliku..............................................................................................612
XML a bazy danych ........................................................................................................619XSL .................................................................................................................................619DOM ...............................................................................................................................620SAX.................................................................................................................................621Korzystanie z System.XML ............................................................................................621
Ładowanie pliku XML..............................................................................................621Odczyt dowolnego elementu.....................................................................................622Odczyt wartości atrybutów .......................................................................................624Tworzenie pliku XML ..............................................................................................627Eksport danych do postaci XML ..............................................................................632Modyfikacja plików..................................................................................................634
Rozdział 12. Programowanie sieciowe......................................................................................................................... 639Odrobina teorii ................................................................................................................640
IP ..............................................................................................................................640TCP ...........................................................................................................................641Porty..........................................................................................................................641HTTP.........................................................................................................................641HTTPS ......................................................................................................................642FTP............................................................................................................................642SMTP ........................................................................................................................643
Żądanie i odpowiedź .................................................................................................655DNS oraz adres IP.....................................................................................................661
Korzystanie z gniazd .......................................................................................................663Przestrzeń System.Net.Sockets.................................................................................663Tworzenie aplikacji-serwera.....................................................................................664Tworzenie aplikacji-klienta ......................................................................................668
ASP i ASP.NET ..............................................................................................................677Zmiany w kodzie.......................................................................................................677Kompilacja kodu.......................................................................................................677Migracja do ASP.NET..............................................................................................677Zgodność ze standardem XHTML............................................................................680
Narzędzia.........................................................................................................................681Edytor........................................................................................................................681Serwer .......................................................................................................................682Instalacja ASP.NET ..................................................................................................683Co trzeba umieć?.......................................................................................................684
ASP.NET w Delphi .........................................................................................................684Elementy interfejsu ...................................................................................................685Pierwszy projekt........................................................................................................686Opcje ASP.NET........................................................................................................687
Web Forms ......................................................................................................................687Przestrzeń nazw System.Web.UI..............................................................................687
Praca z ASP.NET ............................................................................................................688Kontrolki działające po stronie serwera....................................................................688Zdarzenia komponentów...........................................................................................690Kontrolki Web Forms ...............................................................................................693Code Behind..............................................................................................................698Kontrolki użytkownika .............................................................................................700Tworzenie kontrolek w Delphi .................................................................................701Komponenty .NET w ASP.NET...............................................................................706Konfiguracja stron ASP.NET ...................................................................................714Sesje ..........................................................................................................................716Wysyłanie e-maili .....................................................................................................721Monitorowanie stron ASP.NET................................................................................722Pamięć podręczna .....................................................................................................723
Bazy danych w ASP.NET ...............................................................................................724Łączenie się z bazą....................................................................................................724Kontrolki bazodanowe ..............................................................................................726
Technologie internetowe .................................................................................................729Komponenty HTML Producer..................................................................................729WebBroker................................................................................................................729Internet Express ........................................................................................................730WebSnap ...................................................................................................................730IntraWeb ...................................................................................................................730ASP.NET ..................................................................................................................730
Użycie usług sieciowych.................................................................................................738Wyszukiwarka google.com.......................................................................................738Interfejs aplikacji ......................................................................................................740Ładowanie usługi sieciowej ......................................................................................740Korzystanie z usługi Web .........................................................................................742
18 Delphi 8 .NET. Kompendium programisty
Usługi sieciowe w Delphi ...............................................................................................748Tworzenie usługi sieciowej.......................................................................................749Podgląd usługi sieciowej...........................................................................................751Usługa Web na stronie ASP.NET.............................................................................754Plik źródłowy *.asmx................................................................................................757
Bezpieczeństwo usług sieciowych ..................................................................................757Bazy danych ....................................................................................................................759
Projektowanie usługi.................................................................................................759Sprawdzanie usługi sieciowej ...................................................................................766Usługa sieciowa w aplikacji ASP.NET ....................................................................767
Dodatek A Akronimy ..................................................................................................................................................... 773
Dodatek B Spis przestrzeni nazw .NET.................................................................................................................. 775
Dodatek C Słowniczek....................................................................................................................................................779
Dodatek D Zasady pisania kodu ................................................................................................................................ 793Stosowanie wcięć ............................................................................................................794Instrukcje begin i end ......................................................................................................794„Styl wielbłądzi” w nazwach procedur ...........................................................................795Stosuj wielkie litery.........................................................................................................795Parametry procedur .........................................................................................................796Instrukcja if .....................................................................................................................796Instrukcja case .................................................................................................................796Obsługa wyjątków...........................................................................................................797Klasy................................................................................................................................797Komentarze .....................................................................................................................797Pliki i nazwy formularzy .................................................................................................798Notacja węgierska ...........................................................................................................798Czy warto?.......................................................................................................................799
Jak dotąd mówiliśmy o programowaniu strukturalnym, proceduralnym, ale nie wspomnieli-
śmy o obiektach. Idea programowania obiektowego jest teraz niezwykle istotna oraz bardzo
popularna. Większość języków wysokiego poziomu, np. Delphi, C++, C#, Java, Python, PHP
i inne, umożliwia tworzenie obiektów. Na przykład dobry skądinąd C nie umożliwiał progra-
mowania obiektowego. I to jest wielka wada tych języków w obecnych czasach.
Rozdział niniejszy poświęcony będzie przede wszystkim opisowi tworzenia klas w Delphi.
Omówimy także nowości wprowadzone do Delphi za sprawą .NET, a także zwrócimy uwagę
na wiele narzędzi i opcji Delphi związanych z edycją kodu źródłowego.
W tym rozdziale:
� nauczysz się korzystać z edytora kodu,
� poznasz opcje edytora kodu,
� dowiesz się, czym jest programowanie obiektowe i jak tworzyć klasy,
� poznasz nowe elementy języka programowania wprowadzone za sprawą .NET,
� zapoznasz się z podstawowymi ideami programowania na platformie .NET,
� dowiesz się, czym są wyjątki,
� zostaną Ci przedstawione podstawowe narzędzia dołączone do pakietu .NET
Framework.
214 Część I
Na czym polega programowanie obiektowe?Programy rozrastają się coraz bardziej i bardziej. Tak samo jak kiedyś nie wystarczała ideaprogramowania proceduralnego, teraz nie wystarcza już programowanie strukturalne.
Koncepcja programowania obiektowego pojawiła się już w latach 60. za sprawą języka Simula 67zaprojektowanego przez naukowców z Oslo w celu przeprowadzania symulacji zachowaniasię statków. Jednakże idea programowania obiektowego swoją popularyzację zawdzięcza ję-zykowi SmallTalk. Połowa lat 80. to czas, kiedy programowanie obiektowe stało się dominu-jącą techniką — głównie za sprawą C++. Wtedy to też w wielu innych językach pojawiła sięmożliwość tworzenia obiektów.
Można powiedzieć, że klasa to „paczuszka”, pewien element programu, który wykonuje jakieśfunkcje. Klasa zawiera metody (procedury i funkcje) współdziałające ze sobą w celu wykonaniajakiegoś zadania. Programowanie obiektowe przyczyniło się do tego, że takie „podprogramy”jak klasy mogą być wykorzystywane w wielu innych projektach — ułatwia to jeszcze bardziejzarządzanie i konserwację kodu.
Załóżmy, że napisałeś klasę do obsługi poczty (wysyłanie i odbieranie). Klasa może mieć proce-dury ������� (połącz), ������ (wyślij e-mail), ��������� (rozłącz). Z kolei procedura �������może wywoływać inną, np. ����� (która też jest procedurą znajdującą się w klasie), wyświe-tlającą błąd w razie niepowodzenia i zapisującą odpowiedni tekst w dzienniku programu (czyli,inaczej mówiąc, w logach — plikach z rozszerzeniem *.log). Teraz taką klasę możesz wyko-rzystać w wielu swoich aplikacjach — wystarczy skopiować fragment kodu i już gotowa jestobsługa błędów, łączenie itp. Taką klasę możesz udostępnić innym użytkownikom lub swoimwspółpracownikom. Taki inny użytkownik nie musi wiedzieć, jak działa klasa — ważne jest dlaniego, co ona robi (wysyła e-maile). Użytkownik musi jedynie wiedzieć, że istnieje metoda ��������, która połączy go z danym serwerem oraz musi mieć świadomość obecności kilku innychprocedur. To wszystko — nie interesuje go obsługa błędów — nie musi nawet zdawać sobiesprawy z jej istnienia.
Można by oczywiście utworzyć nowy moduł, a w module umieścić także procedury �������,������ oraz ���������, ����� i resztę potrzebnego kodu. Jednak w takim przypadku metodyi zmienne (zmienne także mogą być elementami danej klasy) nie oddziałują na siebie w takimstopniu. Przykładowo, użytkownik korzystający z takiego kodu będzie miał dostęp do tychzmiennych, do których nie powinien go mieć. Będzie mógł też wywołać swobodnie procedurę����� — a nie powinien, bo może to spowodować niepożądane skutki. Dzięki klasom możeszsprawić, iż taka procedura ����� nie będzie dostępna poza klasą; jej elementy (zmienne) teżbędą nie do odczytania przez przyszłego użytkownika.
Biblioteki wizualneW rzeczywistości biblioteki takie jak VCL.NET (ang. Visual Component Library) to szereg mo-dułów i klas współpracujących ze sobą. Dzięki idei programowania obiektowego to wszystkodziała bardzo sprawnie i jest nad wyraz czytelne. Głównie dzięki funkcji dziedziczenia, która
Rozdział 4. � Delphi bardziej zaawansowane 215
polega na rozszerzeniu funkcjonalności klas. Klasa potomna może dziedziczyć po klasie ba-zowej, przejmując od niej całą funkcjonalność, ale jednocześnie można rozszerzyć ją o nowefunkcje. Tak samo zbudowana jest biblioteka VCL — w oparciu o dziedziczenie szeregu klas.
Podstawowy kod formularzaPoprzednio zajmowaliśmy się jedynie Windows Forms, ale od strony wizualnej, czyli głównieprojektantem formularzy. Nie zajmowaliśmy się szczegółami takimi jak kod źródłowy for-mularza. Po otwarciu nowego projektu WinForms na pierwszym planie pojawi się czysty for-mularz. Klawiszem F12 przejdź do edytora kodu. Podstawowy kod modułu źródłowegoprzedstawiony został na listingu 4.1.
Na pierwszy rzut oka widać wyraźną różnicę pomiędzy kodem formularza WinForms a VCL.NET. Przede wszystkim ten drugi jest prostszy i krótszy.
Na razie omówimy podstawowe części kodu formularza w VCL.NET, gdyż jest on prostszyi może ułatwić użytkownikowi zrozumienie znaczenia poszczególnych elementów.
Formularz w VCL.NETModuły i ich budowa zostały szczegółowo omówione w poprzednim rozdziale poświęconymelementom języka Delphi. Zapamiętaj! Każdemu formularzowi odpowiada jeden moduł z od-powiednim kodem, lecz to stwierdzenie nie działa w drugą stronę — moduł niekonieczniemusi być formularzem.
Podczas projektowania wizualnego Delphi samodzielnie edytuje kod źródłowy, dodając lubzmieniając odpowiednie elementy — dzięki temu projektowanie staje się szybsze, a my niemusimy martwić się o szczegóły związane z dodaniem jakiegoś potrzebnego elementu.
Kod źródłowy formularza (modułu) składa się także ze standardowych sekcji i słów kluczo-wych typu: ����, ��������, ����, �������������.
Sekcja uses
Podczas tworzenia nowego projektu Delphi doda do sekcji ���� standardowe moduły koniecz-ne do prawidłowego działania aplikacji. W tych modułach znajdują się deklaracje odpowied-nich klas, dzięki czemu projekt może zostać skompilowany. Przykładowo, doprowadź sekcję���� do takiego wyglądu:
�� �����������
Po próbie kompilacji Delphi już na początku wyświetli błąd: ���������������������������
����������������� !"��� . Komunikat mówi o tym, że nazwa !"��� nie jest rozpoznawana
dla kompilatora. Stało się tak dlatego, że usunęliśmy z sekcji ���� moduł "����, który zawierał
deklarację typu !"���.
218 Część I
Klasa
Poniższy fragment w kodzie źródłowym jest deklaracją klasy, o której tyle mówiliśmy:
Praktycznie nigdy nie zachodzi potrzeba, aby ręcznie edytować ten plik. To zadanie należy już do
Delphi, które dokonuje zapisu i odczytu danych właśnie z tego pliku. Pliki *.nfm zawierają infor-
macje na temat formularza, jego właściwości, komponentów oraz właściwości komponentów.
W pliku źródłowym formularza znajduje się dyrektywa każąca kompilatorowi dołączyć do
projektu plik *.nfm:
"#$�A���+
Jest to specjalna instrukcja — na pierwszy rzut oka wyglądająca jak komentarz, jednak jest
informacją dla kompilatora o włączeniu do projektu wszystkich plików z rozszerzeniem *.nfm.
Generowanie kodu
Powróć do projektanta formularzy. Odszukaj na palecie narzędzi komponent #$��� i umieść
go na formularzu. Z powrotem przejdź do edytora kodu — zauważ, że Delphi w sekcji ����
dodało nowe moduły: #������%���$���� oraz #������%��� #$����, które są wymagane do
prawidłowego skompilowania aplikacji. Dodało również nową linijkę w klasie "����:
�6&��?2���6&���
Dzięki temu oszczędzamy na czasie, nie musząc wpisywać tego ręcznie.
Powyższa linia w klasie "���� identyfikuje komponent typu ! #$��� o nazwie #$����. Delphi
automatycznie nadaje własne nazwy tworzonym komponentem, przypisując im kolejne nume-
ry: #$����, #$���& itd. Jeżeli na formularzu umieścisz kilka komponentów typu !#�����, to
Delphi nazwie je odpowiednio: #������, #�����& itd.
Nazwy komponentów
Nazwa komponentu jest symboliczna. Z punktu widzenia kompilatora nie jest ważne, czy kompo-
nent nazywa się #������ czy !�'����("(�)#������*+�����. Ważne jest jedynie to, aby nazwa
była unikalna, a więc nie mogą istnieć dwa komponenty o tej samej nazwie. W nazwie kompo-
nentu nie mogą być użyte polskie znaki; nie może także zaczynać się ona od cyfry. W nazew-
nictwie komponentu istnieją takie same reguły co w deklaracji zmiennej.
Nazwę komponentu można zmienić, korzystając z inspektora obiektu. Znajdź właściwość +��,
której możesz nadać nową wartość będącą nazwą komponentu. Po zmianie nazwy Delphi
uaktualni również wszelkie wpisy w kodzie źródłowym związane z tą nazwą.
220 Część I
Wskazówka
Nigdy nie pozostawiaj domyślnych nazw komponentów, jakie nadaje Delphi
(tzn. #������, #�����& itd.). W późniejszym czasie łatwo jest się pogubić w takim
nazewnictwie. Staraj się nazywać komponenty opisowo — to znaczy tak,
aby opisywały rolę, jaką pełnią. Jeżeli, przykładowo, masz komponent, który
wyświetla informacje o autorze programu, nazwij go ,��-,���; w przypadku
przycisku, który będzie zamykał program — niech będzie to nazwa ,�������.
Programowanie zdarzenioweProgramy napisane w Delphi są programami zdarzeniowymi, które wykonują pewne czynności
pod wpływem nakazu użytkownika. Co to oznacza? Kiedy program jest uruchamiany, nastę-
puje jego załadowanie do pamięci, rezerwowanie pamięci itp. Następnie program taki czeka
na zadania. Projektując nasze aplikacje wizualne, programujemy pewne zdarzenia, na jakie ma
reagować program — np. kliknięcie przyciskiem myszy w obszarze komponentu. Jeżeli apli-
kacja odbierze takie zdarzenie (użytkownik kliknie w obszarze komponentu), podejmowane
jest pewne działanie. To samo tyczy się innych przypadków — poruszanie myszą, wprowa-
dzanie tekstu z klawiatury itp.
Generowanie zdarzeń
W kodzie źródłowym modułu nie możesz ręcznieumieszczać instrukcji wykonujących pewne
czynności (pomijamy tu sekcję �������.���� oraz �����.����) — wszystko musi być za-
warte w procedurach zdarzeniowych.
1. Utwórz nowy projekt VCL.NET.
2. Umieść na formularzu komponent !#�����.
3. Kliknij dwukrotnie w przycisk (komponent !#�����).
W tym momencie Delphi powinno wygenerować w kodzie źródłowym zdarzenie i przenieść
Cię do edytora kodu, natomiast kursor ustawić w ciele procedury:
��� �� ����?�6�����?����J � �� 2��(1B ��!�1 ���
���
Właśnie we wnętrzu tej procedury należy umieścić kod, który będzie wykonywany po naci-
śnięciu w trakcie działania programu przycisku. W naszym przykładzie spowodujemy tym
zmianę właściwości komponentu.
Rozdział 4. � Delphi bardziej zaawansowane 221
Przykładowy program
Jak dotąd zmieniałeś właściwości komponentu jedynie z poziomu inspektora obiektów. Powi-nieneś wiedzieć, że jest to możliwe także z poziomu kodu źródłowego za pomocą operatoraodwołania (�).
Nasz przykładowy program zmieniał będzie pozycję przycisku na formularzu. Nowa pozycjabędzie losowana i ustawiana za każdym razem, gdy użytkownik kliknie przycisk.
Każda kontrolka wizualna w VCL.NET posiada właściwość /���0 (szerokość), 1��20� (wyso-kość), 3��� (pozioma pozycja na formularzu), !�� (pionowa pozycja na formularzu). Tak więcnadanie nowej wartości dla właściwości z poziomu kodu wygląda następująco:
6�����?�����3�2��?<<��--��5 �J�KL�J���� ���
Do konkretnych właściwości odwołujemy się za pomocą operatora odwołania (kropka), a warto-ści nadajemy tak jak zwykłym zmiennym.
Rozwiązanie
Przy każdorazowym naciśnięciu przycisku program powinien losować nową wartość z zakre-su i ustawiać komponent na tej wylosowanej wartości. Pytanie: jaki to będzie zakres? Szero-kość i wysokość formularza!
Listing 4.4 przedstawia kod całego modułu programu.