Delphi 8 .NET. Kompendium programisty

Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG 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. 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.

http://helion.pl/view/2547w



http://helion.pl/add/2547w/dl8nkp




mailto:[email protected]

http://helion.pl/view/2547w/dl8nkp.htm

Spis treściTematyka książki......................................................................................................................................... 19

Część I ........................................................................................................................................... 21

Rozdział 1. Wstęp do programowania.........................................................................................................................23Dawno, dawno temu…......................................................................................................23Czym jest programowanie?...............................................................................................24Języki programowania.......................................................................................................25

Asembler .....................................................................................................................26Fortran.........................................................................................................................27C .................................................................................................................................27C++ .............................................................................................................................27Perl ..............................................................................................................................27PHP .............................................................................................................................28Turbo Pascal................................................................................................................28Java .............................................................................................................................28C# ...............................................................................................................................29

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

.NET Framework ........................................................................................................34Produkty dla programistów.........................................................................................35Integracja językowa ....................................................................................................35Język pośredni IL........................................................................................................37Wspólna specyfikacja języka......................................................................................38

6 Delphi 8 .NET. Kompendium programisty

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

Instalacja Delphi................................................................................................................43Wersje Delphi .............................................................................................................44Cennik .........................................................................................................................44Wymagania Delphi .....................................................................................................45Instalacja .....................................................................................................................45Polskie znaki ...............................................................................................................45

Jak się uczyć? ....................................................................................................................46FAQ...................................................................................................................................47Przydatne odnośniki ..........................................................................................................49Podsumowanie ..................................................................................................................49

Rozdział 2. Projektowanie wizualne............................................................................................................................. 51Podstawowe okna Delphi ..................................................................................................51

Welcome Page ............................................................................................................52Okno główne...............................................................................................................53Projektant formularzy .................................................................................................54Paleta narzędzi ............................................................................................................54Inspektor obiektów......................................................................................................56Menedżer projektu ......................................................................................................57Edytor kodu.................................................................................................................59Ukrywanie okna ..........................................................................................................60

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

Spis treści 7

Przemieszczanie ikon..................................................................................................73Menu palety narzędzi ..................................................................................................73

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

Projektant formularzy........................................................................................................83Siatka pomocnicza ......................................................................................................84Usuwanie, kopiowanie i wklejanie .............................................................................85Zaznaczanie wielu komponentów...............................................................................85Menu projektanta formularzy .....................................................................................87Pasek narzędziowy Align............................................................................................87Pasek narzędziowy Spacing........................................................................................88Pasek narzędziowy Position........................................................................................89Opcje projektanta formularzy .....................................................................................89

Projekty .............................................................................................................................90Opcje projektu.............................................................................................................90

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

Zapisywanie projektu................................................................................................120Po kompilacji… ........................................................................................................121

Najprostszy program .......................................................................................................122Podstawowa składnia ......................................................................................................122

Czytanie kodu ...........................................................................................................122Wielkość liter ............................................................................................................123Pamiętaj o średniku! .................................................................................................123


Bloki begin i end.......................................................................................................123Dyrektywa program ..................................................................................................124

Komentarze .....................................................................................................................125Umiejętne komentowanie .........................................................................................126

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

Używanie zmiennych ......................................................................................................136Łączenie danych........................................................................................................137

Tablice danych ................................................................................................................138Tablice jako stałe ......................................................................................................139Tablice wielowymiarowe..........................................................................................140Tablice dynamiczne ..................................................................................................142Polecenia Low i High................................................................................................143

Operatory.........................................................................................................................144Operatory przypisania...............................................................................................144Operatory porównania ..............................................................................................144Operatory logiczne....................................................................................................145Operatory arytmetyczne............................................................................................146Operatory bitowe ......................................................................................................148Pozostałe operatory...................................................................................................148

Instrukcje warunkowe .....................................................................................................149Instrukcja if..then.......................................................................................................149Instrukcja case..of .....................................................................................................152Instrukcja else ...........................................................................................................155

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

Aliasy typów ...................................................................................................................171Rekordy ...........................................................................................................................171

Przekazywanie rekordów jako parametrów procedury.............................................172Deklarowanie rekordu jako zmiennej .......................................................................173Instrukcja packed ......................................................................................................173Deklarowanie tablic rekordowych ............................................................................174Deklarowanie dynamicznych tablic rekordowych....................................................174

Spis treści 9

Instrukcja wiążąca with...................................................................................................175Programowanie strukturalne ...........................................................................................176Moduły ............................................................................................................................176

Tworzenie nowego modułu.......................................................................................176Budowa modułu ........................................................................................................177Włączanie modułu ....................................................................................................178Funkcje wbudowane .................................................................................................178Sekcje Initialization oraz Finalization ......................................................................179Dyrektywa forward ...................................................................................................180

Konwersja typów.............................................................................................................182Rzutowanie......................................................................................................................182

Parametry nieokreślone.............................................................................................184Pętle.................................................................................................................................184

Pętla for..do...............................................................................................................185Pętla while..do...........................................................................................................187Pętla repeat..until ......................................................................................................188Procedura Continue...................................................................................................189Procedura Break........................................................................................................189

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

Schematy blokowe ....................................................................................................198Przykład — obliczanie silni ......................................................................................200

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

FAQ.................................................................................................................................210Podsumowanie ................................................................................................................211

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


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

Spis treści 11

Wyjątki ............................................................................................................................280Słowo kluczowe try..except ......................................................................................280Słowo kluczowe try..finally ......................................................................................281Słowo kluczowe raise ...............................................................................................282Klasa Exception ........................................................................................................283Selektywna obsługa wyjątków..................................................................................284Zdarzenie OnException ............................................................................................284

Menedżer projektu...........................................................................................................287Model View ..............................................................................................................288Data Explorer ............................................................................................................288

Programowanie w .NET..................................................................................................288Wspólny model programowania ...............................................................................288Klasa System.Object .................................................................................................288Główne przestrzenie nazw ........................................................................................290Komponenty .NET....................................................................................................291Atrybuty podzespołu.................................................................................................294Mechanizm Reflection ..............................................................................................297

Identyfikatory ..................................................................................................................310Aplikacje .NET................................................................................................................311

Deasembler .NET......................................................................................................311Global Assembly Cache Tool ...................................................................................312WinCV ......................................................................................................................314Narzędzie konfiguracji .NET Framework.................................................................315PEVerify — narzędzie weryfikacji ...........................................................................315

Eksplorator modułów ......................................................................................................316Opcje eksploratora ....................................................................................................317


Rozdział 5. Wykrywanie błędów w aplikacjach ..................................................................................................321Rodzaje błędów...............................................................................................................322Opcje kompilatora ...........................................................................................................323Częste błędy programisty ................................................................................................325

Niezainicjowane zmienne obiektowe .......................................................................325Zwalnianie obiektów.................................................................................................326Tablice.......................................................................................................................326

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


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

WinFX.......................................................................................................................357Brakujące komponenty....................................................................................................357

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

Edytor pól........................................................................................................................442Pola obliczeniowe .....................................................................................................443Pola przeglądowe ......................................................................................................445

BDE Administrator .........................................................................................................445Tworzenie aliasu .......................................................................................................446

Praca z tabelami ..............................................................................................................447Tworzenie tabel.........................................................................................................447Tworzenie kolumn w kodzie programu ....................................................................447

Filtrowanie tabel..............................................................................................................449Wykorzystanie właściwości Filter ............................................................................450Zdarzenie OnFilterRecord ........................................................................................451

Wyszukiwanie rekordów.................................................................................................452Metoda Locate ..........................................................................................................453Metoda FindKey .......................................................................................................454

Przykładowa aplikacja.....................................................................................................454Założenia...................................................................................................................455Tworzenie interfejsu .................................................................................................455Kod źródłowy aplikacji.............................................................................................460Ćwiczenia dodatkowe ...............................................................................................471

Zakładki...........................................................................................................................471Pozostałe komponenty bazodanowe................................................................................472

Komponent TDbGrid ................................................................................................472Komponent TDbNavigator .......................................................................................473Komponent TDbText ................................................................................................473Komponent TDbEdit.................................................................................................474Komponent TDbMemo.............................................................................................474Komponent TDbRichEdit .........................................................................................474Komponent TDbImage .............................................................................................475Komponent TDbCheckBox ......................................................................................475



Rozdział 8. dbExpress .....................................................................................................................................................479Architektura klient-serwer...............................................................................................479

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


Rozdział 9. IBX.................................................................................................................................................................. 545Dlaczego IBX? ................................................................................................................545

Zalety IBX ................................................................................................................546Komponenty IBX ............................................................................................................546

Komponent TIBDatabase..........................................................................................547TIBDataSet ...............................................................................................................550Komponenty reprezentujące dane.............................................................................553TIBSQLMonitor .......................................................................................................554Komponenty administracyjne ...................................................................................554

Spis treści 15

Łą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

Sterowniki zarządzane.....................................................................................................578BDP.NET ........................................................................................................................579

Łączenie z bazą InterBase.........................................................................................579Komponent BdpCommand .......................................................................................582Komponent BdpDataAdapter....................................................................................583Wyświetlanie zwartości tabeli ..................................................................................585Praca z danymi..........................................................................................................585

Dystrybucja aplikacji BDP.NET.....................................................................................588MySQL w ADO.NET .....................................................................................................588

Korzystanie ze sterownika MySQL..........................................................................589Komponenty wizualne ..............................................................................................595


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


DTD.................................................................................................................................609Deklaracja elementu..................................................................................................610Deklaracja atrybutu...................................................................................................610DTD w osobnym pliku..............................................................................................612

Encje tekstowe.................................................................................................................613XSD.................................................................................................................................614

Nagłówek XSD .........................................................................................................614Elementy XSD ..........................................................................................................615Typy danych..............................................................................................................615Typy proste ...............................................................................................................616

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

Narzędzia.........................................................................................................................643Pakiet Indy.......................................................................................................................644

Protokół HTTP..........................................................................................................644Przestrzeń nazw System.Net ...........................................................................................655

Żądanie i odpowiedź .................................................................................................655DNS oraz adres IP.....................................................................................................661

Korzystanie z gniazd .......................................................................................................663Przestrzeń System.Net.Sockets.................................................................................663Tworzenie aplikacji-serwera.....................................................................................664Tworzenie aplikacji-klienta ......................................................................................668


Rozdział 13. ASP.NET...................................................................................................................................................... 673Dynamiczne strony WWW .............................................................................................673

CGI............................................................................................................................674PHP ...........................................................................................................................675ASP ...........................................................................................................................676ASP.NET ..................................................................................................................676

Spis treści 17

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


Rozdział 14. Usługi sieciowe ........................................................................................................................................... 733Czym są usługi sieciowe? ...............................................................................................733Działanie usług sieciowych.............................................................................................735

HTTP.........................................................................................................................735XML..........................................................................................................................735Infrastruktura usług sieciowych................................................................................735

Użycie usług sieciowych.................................................................................................738Wyszukiwarka google.com.......................................................................................738Interfejs aplikacji ......................................................................................................740Ładowanie usługi sieciowej ......................................................................................740Korzystanie z usługi Web .........................................................................................742


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


Dodatki.......................................................................................................................................771

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

Skorowidz .....................................................................................................................................................801

Delphi bardziej zaawansowane

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.

Listing 4.1. Podstawowy kod modułu WinForms

��

��

��

�� !��"#$%&'()�*� �� *+��,�� ---�.��/��---�$ 0�� ,��1� ��---�.-��/�� 2�� ---�.��/��---�$ 0�� 3�� 4��---��3 �� 3�� 3��3��3 �� ---�.-��/�� '��5 �� "#%)�$%&'()+�� ---�.��/��---�� 1 �� ---�.-��/�� 2�6�� !��, �� ,�� "�7�,�� +��1��

��8�� 1��2�$�� $ 0�� 9��1�� (� ��!!:

��

216 Część I

"#$%&'()�*�� *+---�.��/---�$ 0�� 3�� 44��---��3 �� 3�� 3��3��3 �� ---�.-��/�� '��5 �� 1 �� 2�� 5 �2�� 5 �� ;<<��;<<!�� =��2��*��*� ��"#%)�$%&'()+

�� 2�6�� !�1 ��3 ��1 �� ./��3 �� !�� 3 �� !� ��

�� 1 ��3 �� --��--�$ 0�� --��'��5 �� --��--��(�(2�9�� '��5 �� -- ��

��

Należy już na samym początku zaznaczyć, że składnia modułu WinForms znacząco różni sięod standardowego VCL.NET (listing 4.2).

Listing 4.2. Kod formularza w VCL.NET

��>��?�

��

�� >��@�� &��3��

�� ?�� !��,�� "�7�,�� +��1��"�7�1�� +��


,��?2��?�

��

"#$�A��+

��

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:

�� ?�� !��,�� "�7�,�� +��1��"�7�1�� +��

W tym momencie zadeklarowany został nowy typ — !"��, który jest klasą wywodzącą się

z kolei z klasy bazowej !"��.

Wskazówka

W VCL.NET nazwy wszystkich klas zaczynają się od litery !.

Zmienna wskazująca na klasę

Poniżej deklaracji klasy, jeszcze w sekcji ��, zadeklarowana jest standardowo zmien-

na, która wskazuje na nasz typ — !"��:

,��?2��?�

Plik *.nfm

Komponenty umieszczane na formularzu mogą mieć różne właściwości. Te dane muszą być

gdzieś przechowywane. W VCL.NET miejscem, gdzie zapisywane są te informacje, jest plik

*.nfm (w poprzednich wersjach Delphi plik miał rozszerzenie *.dfm), którego zawartość zo-

stała przedstawiona na listingu 4.3.

Listing 4.3. Zawartość pliku *.nfm

�1B ��?2��?��*��?*��6�� 3�� %�9>C�D�E9$�%�� =��E ��3��4??��)� ��*��3��*�� 8:��E ��3��F<��3��;FG


��C ��?;��?;��7�= ��7 '��3��HI�� =�E ��3��?; ��

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.


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.

Listing 4.4. Kod modułu

��>��?�

��

�� @��>��&��3�� 6��@��6��@��

�� ?�� !��6��?2��6�� 6��?��J � �� 2��(1B ��!��,�� "�7�,�� +��1��"�7�1�� +��

,��?2��?�

��

"#$�A��+

222 Część I

�� ?�6��?��J � �� 2��(1B ��!�,��3��E ��3��2�'�� 1 ��"��5��5��K��BM� ��5 �J�KL��J�KL��5��+��3�2��?��3�4�?<<��E ��3��2��?�E ��3��4�N<�

��$��5 ��--��

"�� 3��K��O�K��K��C ��+��6��?�C ��2��$�� 3!��6��?��2��$�� E ��3�!� ��

��

Szerokość i wysokość formularza odczytujemy z właściwości /��0 oraz 1��20�, a następnie

przypisujemy te wartości do zmiennych zadeklarowanych wcześniej: "��/��0 oraz "��1��20�:

��3�2��?��3�4�?<<��E ��3��2��?�E ��3��4�N<�

Zwróć uwagę, że dodatkowo odjęliśmy od tych wartości odpowiednio liczby 100 i 50, tak aby

zachować pewien margines podczas losowania liczb.

Następnie wylosowane wartości posłużą jako nowe współrzędne położenia komponentu !#��:

��6��?�C ��2��$�� 3!��6��?��2��$�� E ��3�!�

Wiesz już, dlaczego odjęliśmy 100 i 50 od wartości zmiennej "��/��0 i "��1��20�? Zakła-

dając, że szerokość formularza to 500, program będzie losował jedynie z zakresu od 0 do 400,

tak aby nie wylosował liczby 500 — gdyby tak się stało, to komponent nie zmieściłby się cał-

kowicie w oknie formularza (jego krawędź wystawałaby poza obszar formularza). Wszystko

dlatego, że właściwość 3�� określa pozycję lewej krawędzi komponentu względem formularza.

Zmiany kosmetyczne

1. W inspektorze obiektów zmień właściwość /��0 oraz 1��20� formularza na 455.

2. Zmień właściwość �� przycisku (#��) na 6��*��(��7.

Działanie programu przedstawione zostało na rysunku 4.1.

Lista zdarzeń w inspektorze obiektów

Wspominaliśmy wcześniej o zakładce Events inspektora obiektów. Po wykonaniu wcześniej-

szego ćwiczenia na liście Events przy pozycji 8��* będzie widniał napis: #��* (ry-

sunek 4.2).


Rysunek 4.1. Program w trakcie działania

Rysunek 4.2. Inspektor obiektów z wygenerowanym zdarzeniem OnClick

Po zaznaczeniu zdarzenia 8��* zostanie ono podświetlone na szaro. Po przeniesieniu kursora

nad tekst, powinien on zmienić kształt. W tym miejscu po podwójnym kliknięciu zostaniesz

przeniesiony do deklaracji zdarzenia 8��*. Tak samo jest z generowaniem innych zdarzeń

— np. 8�6�) �9�.

Jedno zdarzenie dla kilku obiektów

Czasami może zajść potrzeba „podpięcia” tego samego zdarzenia 8��* (lub jakiegokolwiek

innego) w kilku przyciskach lub innych komponentach.

224 Część I

W takim wypadku po zaznaczeniu wybranej pozycji, np. 8��*, po prawej stronie pojawia

się strzałka, po naciśnięciu której rozwija się lista z dostępnymi w programie zdarzeniami.

Możesz dla swojego komponentu wybrać dowolne zdarzenie.

Generowanie pozostałych zdarzeń

Możesz korzystać ze wszystkich zdarzeń, jakie w obrębie danego komponentu oferuje Ci Delphi.

Przykładowo, zdarzenie 8��:� umożliwia Ci oprogramowanie zdarzenia przesuwania

kursora nad obiektem. Innymi słowy, możesz odpowiednio na taką sytuację zareagować.

Jak odbywa się generowanie zdarzeń z poziomu inspektora obiektów? Zaznacz zdarzenie,

niech to będzie 8��:�, klikając je. Po prawej stronie pojawi się lista rozwijalna, która na

razie jest pusta. Przesuń kursor nad białe pole — kursor powinien zmienić swój kształt. W tym

momencie kliknij dwukrotnie — spowoduje to wygenerowanie zdarzenia 8��:�.

�� 1�� , � �� 2��(1B ��3��2��3�� P��Q2�'�� !�1 ��

��

Wskazówka

W niniejszej książce dla określenia nazw komponentów będę posługiwał się

prawidłowym określeniem z literą T na początku — np. !#�� czy !3,��. Są to

prawidłowe nazwy dla komponentów VCL, chociaż wiele osób nadaje komponentom

nazwy pozbawione tej litery — #��, 3,��.

Jeżeli wygenerowane zdarzenie pozostanie puste, tj. nie będzie zawierało żadnego

kodu, zostanie ono usunięte podczas kompilacji lub zapisu projektu.

Edytor koduZanim przystąpimy do dalszej pracy, wypadałoby, abyś poznał główne narzędzie pracy uży-

wane w tym rozdziale — edytor kodu (rysunek 4.3).

Edytor kodu to zwykły edytor tekstów. Podzielony jest na zakładki, co daje możliwość jedno-

czesnej edycji wielu plików. W przypadku gdy mamy do czynienia z kodem źródłowym

formularza, okno dodatkowo jest podzielone na dole na dwie zakładki — Code (pisanie kodu)

oraz Design (projektowanie wizualne).

Trzeba przyznać, że w nowej wersji edytor kodu uległ zmianie — przede wszystkim dzięki

dodaniu nowych opcji i możliwości.


Rysunek 4.3. Edytor kodu

Ukrywanie kodu

Jedną z nowości jest możliwość ukrywania fragmentu kodu. W takim przypadku po lewej

stronie edytora wyświetlone zostaną małe ikonki, których kliknięcie spowoduje rozwinięcie

ukrytego fragmentu. Jest to dość ciekawe rozwiązanie — umożliwia zwiększenie przejrzysto-

ści w kodzie i schowanie fragmentu, który nas nie interesuje.

Wszystko to odbywa się za sprawą dyrektywy ;<=�$>8+?, którą należy wstawić przed blokiem,

który chcemy ukryć. Wygląda to następująco:

"#$%&'()�R)�5�� S+--�J��J�T��3� ��J�L"#%)�$%&'()+

Po wpisaniu takich instrukcji możliwe będzie ukrycie danych zapisanych pomiędzy tymi dy-

rektywami.

Makra

Mówiąc ogólnie, makra (również wprowadzone jako nowość w Delphi 8) umożliwiają „na-

grywanie” pewnych operacji dokonanych w kodzie źródłowym, a następnie ich „odtwarzanie”.

Wszystkie trzy przyciski z tym związane znajdują się w lewym dolnym rogu edytora kodu.

226 Część I

Przeprowadź pewien eksperyment potwierdzający moje słowa: kliknij przycisk Record Macro

(środkowy przycisk) i wpisz w edytorze kodu tekst:

�3�� *)��J��*!�

Po wpisaniu kliknij przycisk Stop Recording Macro. Od tej pory aktywny powinien być

pierwszy przycisk — Playback Macro. Po jego kliknięciu w edytorze kodu ponownie zostanie

wstawiona nagrana instrukcja.

Delphi 8 .NET. Kompendium programisty

Technology

Transcript of Delphi 8 .NET. Kompendium programisty