1
Język F# w praktyce
Marian Mysior
Wydanie pierwsze, Toruń 2012
ISBN: 978-83-61744-47-4
Wszelkie prawa zastrzeżone!
Autor oraz wydawnictwo dołożyli wszelkich starań, by informacje zawarte w tej publikacji
były kompletne, rzetelne i prawdziwe. Autor oraz wydawnictwo EscapeMagazine.pl nie
ponoszą żadnej odpowiedzialności za ewentualne szkody wynikające z wykorzystania infor-
macji zawartych w publikacji lub użytkowania tej publikacji.
Wszystkie znaki występujące w publikacji są zastrzeżonymi znakami firmowymi bądź towaro-
wymi ich właścicieli.
Rozpowszechnianie całości lub fragmentu (innego niż udostępniony przez wydawnictwo)
w jakiejkolwiek postaci, bez pisemnej zgody wydawnictwa, jest zabronione.
Zostań Partnerem wydawnictwa i zarabiaj na legalnym rozpowszechnianiu wydawanych
przez nas publikacji:
http://EscapeMagazine.pl/pp
bezpłatny fragment
Wydawnictwo EscapeMagazine.pl
http://www.EscapeMagazine.pl
3
Spis treści
Wprowadzenie
Wstęp. Co jest potrzebne, skąd to pobrać i jak zainstalować?
Interaktywna konsola F#
Visual Studio 2010 Shell
LINQPad
Rozdział 1. Praca w różnych środowiskach
1.1. Wyprowadzanie komunikatów
Ćwiczenie 1. Drukujemy komunikaty na konsoli
Ćwiczenie 2. Testujemy kod w programie LINQPad
Ćwiczenie 3. Tworzymy pierwsze okno F# w Visual Studio
1.2. Wprowadzanie danych 21
Ćwiczenie 4. Wprowadzamy dane z konsoli 21
Ćwiczenie 5. Wprowadzamy dane w LINQPad 21
Ćwiczenie 6. Wprowadzamy dane w oknach Windows 22
Rozdział 2. Podstawy języka 27
2.1. Stałe, zmienne, typy danych 27
Ćwiczenie 7. Poznajemy właściwości języka 27
Ćwiczenie 8. Badamy typy danych 30
Ćwiczenie 9. Identyfikatory, zmienne? 33
2.2. Funkcje 37
Ćwiczenie 10. Definiujemy funkcję 37
Ćwiczenie 11. Wartości funkcji 38
Ćwiczenie 12. Tworzymy funkcję rekurencyjną 39
Ćwiczenie 13. Funkcja anonimowa 40
Ćwiczenie 14. Funkcje wyższego rzędu 41
Ćwiczenie 15. Wykorzystujemy operatory „>>” i „|>” 42
Ćwiczenie 16. Argumenty częściowe 42
Rozdział 3. Struktury danych 44
3.1. Łańcuchy znaków 44
Ćwiczenie 17. Formatujemy łańcuchy 45
Ćwiczenie 18. Formatujemy inaczej 48
3.2. Krotki 51
Ćwiczenie 19. Stosujemy krotki 51
3.3. Sekwencje 53
Ćwiczenie 20. Wykorzystujemy sekwencje 53
3.4. Opcje 56
4
Ćwiczenie 21. Używamy opcji 56
3.5. Listy 58
Ćwiczenie 22. Działamy na listach 58
3.6. Tablice 63
Ćwiczenie 23. Zmieniamy zawartości tablic 63
3.7. Rekordy 66
Ćwiczenie 24. Tworzymy rekordy 66
3.8. Rzutowanie i konwersje typów 68
Rozdział 4. Sterowanie zachowaniem programu 70
4.1. Okna komunikatów 71
Ćwiczenie 25. Wyprowadzamy komunikaty 71
4.2. Instrukcja warunkowa 77
Ćwiczenie 26. Sprawdzamy w kalendarzu 77
4.3. Instrukcje powtarzania 83
Ćwiczenie 27. Drukujemy tablicę funkcji 83
Ćwiczenie 28. Wprowadzamy hasło 86
4.4. Kontrola poprawności danych 89
Ćwiczenie 29. Maskujemy wprowadzanie danych 89
Ćwiczenie 30. Obsługujemy zdarzenia Validating i Validated 92
Ćwiczenie 31. Stosujemy strukturalną obsługę błędów 96
Ćwiczenie 32. Zgłaszamy własny wyjątek 100
Rozdział 5. Kontrolki, zdarzenia 104
Ćwiczenie 33. Urozmaicamy listę kontrolek 104
Ćwiczenie 34. Kontrolki nadzorują pobieranie danych 109
Rozdział 6. Grafika 115
6.1. Podstawowe obiekty i metody graficzne 115
Ćwiczenie 35. Rysujemy typowe obiekty graficzne 115
6.2. Wykorzystanie plików graficznych 120
Ćwiczenie 36. Przeglądamy pliki graficzne 120
6.3. Animacja 125
Ćwiczenie 37. Wprawiamy w ruch kontrolkę PictureBox 125
Ćwiczenie 38. Kolejne fazy ruchu odczytujemy z plików 127
Ćwiczenie 39. Poruszamy Ziemię 129
Rozdział 7. Interfejs użytkownika 133
7.1. Menu 133
Ćwiczenie 40. Tworzymy edytor tekstu 133
7.2. Pasek narzędzi 138
Ćwiczenie 41. Dodajemy pasek narzędzi 138
7.3. Pasek stanu 141
Ćwiczenie 42. Dodajemy do edytora pasek stanu 141
7.4. Obsługa plików 143
5
43. Odczytujemy i zapisujemy pliki 144
Rozdział 8. Bazy danych 148
Ćwiczenie 44. Odczytujemy dane z bazy 149
Ćwiczenie 45. Używamy plików XML 153
Rozdział 9. Klasy 156
9.1. Pierwsze klasy 157
Ćwiczenie 46. Definiujemy własną, bezpieczną klasę 158
Ćwiczenie 47. Zapewniamy swobodny dostęp do pól 159
9.2. Hermetyzacja 162
Ćwiczenie 48. Instalujemy akcesory 162
9.3. Dziedziczenie 165
Ćwiczenie 49. Tworzymy klasę dziedziczącą 165
9.4. Metody wirtualne 168
Ćwiczenie 50. Wywołujemy właściwe metody 168
Rozdział 10. Jeszcze raz funkcje 175
Ćwiczenie 51. Obliczamy pierwiastki równania kwadratowego 175
Ćwiczenie 52. Szukamy liczb pierwszych 176
Ćwiczenie 53. Całkujemy numerycznie 178
Ćwiczenie 54. Używamy jednostek miar 179
Ćwiczenie 55. Drukujemy słownie wartości liczbowe 182
Zakończenie 185
6
Wprowadzenie
Język F# opracowany został przez australijskiego informatyka Don Syme’a, pracującego
w Microsoft Research. Jest wariantem języka ML i w dużej mierze zgodny z dialektem tego
języka o nazwie Objective Caml. Pierwsza wersja została udostępniona na przełomie 2004/
2005 roku. Obecnie rozwijany jest w Microsoft Developer Division.
F# (F Sharp) jest językiem programowania, łączącym cechy języka imperatywnego (proce-
duralnego) oraz funkcyjnego. Jest częścią platformy .NET, firmy Microsoft. F# jest językiem
wieloparadygmatycznym, ponieważ wspiera programowanie funkcyjne, imperatywne i sto-
suje obiektowy styl programowania.
Programowanie funkcyjne (lub funkcjonalne) jest istotną cechą tego języka. Filozofia i meto-
dyka programowania funkcyjnego, będąca odmianą programowania deklaratywnego, w któ-
rej funkcje należą do wartości podstawowych, kładzie nacisk na wartościowanie (często re-
kurencyjnych) funkcji, a nie na wykonywanie poleceń.
F# jest jednym z najnowszych języków funkcyjnych. Jest przeniesieniem języka Objective
Caml na platformę .NET.
Książka skierowana jest do Czytelników chcących poznać podstawy języka F# i pracę w środo-
wisku Visual Studio. Nie wymaga znajomości wstępnej tego języka ani innych narzędzi
programistycznych. Korzystna może jednak być znajomość innych języków programowania,
np. C++, C#, Pascal. Zamieszczone w niej ćwiczenia, składnie poleceń i tabele mogą również
służyć jako pomoc dla bardziej zaawansowanych programistów.
Pliki do pobrania, zawierające ćwiczenia prezentowane w książce, umieszczone są na stronie
Wydawnictwa.
Wszystkie pliki zostały uruchomione i sprawdzone pod systemem operacyjnym Microsoft
Windows (XP i 7).
7
Wstęp.
Co jest potrzebne, skąd to pobrać
i jak zainstalować?
Do pracy z językiem F#, jako minimum, wystarcza interpreter lub kompilator tego języka.
Warto jednak również użyć środowiska Visual Studio, dostarczającego wielu dodatkowych
elementów usprawniających pracę.
Potrzebne zasoby znajdziemy na stronie:
http://msdn.microsoft.com/en-us/fsharp/default
Ćwiczenia wykonywać będziemy używając następujących narzędzi:
• Interaktywna konsola F#
• Visual Studio 2010 Shell
• LINQPad
Wszystkie programy udostępniane są bezpłatnie. Można je pobrać z podanych dalej stron
internetowych.
Interaktywna konsola F#
Najnowsza wersja konsoli zawarta w pakiecie F# November 2010 Community Technology
Preview (CTP) jest do pobrania pod adresem:
http://www.microsoft.com/downloads/en/details.aspx?FamilyID=effc5bc4-c3df-4172-ad1c-
bc62935861c5&displaylang=en
W skład pakietu wchodzi:
• Interaktywny interpreter – fsi.exe
• Wierszowy kompilator – fsc.exe i biblioteki komponentów
• Komponenty dla środowiska Visual Studio 2008 i Visual Studio 2010
• Biblioteka FSharp.Core dla Silverlight 2.0, 3.0 i Windows Phone 7
Po zainstalowaniu programu konsolę można uruchomić korzystając z przycisku Start.
8
Rysunek 1. Interaktywna konsola
Polecenia wpisane bezpośrednio do konsoli zostają zinterpretowane po wprowadzeniu
dwóch znaków „;” i potwierdzeniu klawiszem „Enter”.
Kompilator wierszowy można uruchomić wpisując w wierszu polecenia sekwencję:
fsc nazwa.fs (zakładamy, że kompilator i plik źródłowy są w bieżącym folderze).
Plik nazwa.fs powinien zawierać kod źródłowy napisany w języku F#. Do przygotowania
pliku można użyć dowolnego edytora ASCII/ANSI, np. Notatnika. W wyniku kompilacji
powstanie plik wykonywalny nazwa.exe.
Więcej opcji uruchamiania kompilatora można uzyskać, wpisując w wierszu poleceń
komendę:
fsc --help
Visual Studio 2010 Shell
Visual Studio integruje wiele środowisk programistycznych w postaci jednolitego interfejsu
(IDE). Udostępnia środowisko, z którego korzystać mogą różne języki programowania. Micro-
soft dostosował do platformy .NET (którą wykorzystuje Visual Studio) od lat znany
i popularny język Visual Basic. VB .NET jest teraz w pełni obiektowym językiem progra-
mowania. Dla użytkowników języków rodziny C opracowano na platformę .NET język C#
(„C sharp”). Jest to nowoczesny, obiektowy język programowania, korzystający z wielu
konstrukcji C++, ale bez zbędnych naleciałości historycznych. Visual C++ jest także obecny na
tej platformie. Dołączył do nich F#.
Wybór języka programowania jest rzeczą drugorzędną – to jedna z zalet środowiska .NET.
Integracja wielu języków w jednym środowisku powoduje, że nie trzeba tracić czasu na
uczenie się od początku nowych języków, aby tworzyć, uruchamiać i rozwijać aplikacje.
9
Visual C#, Visual Basic, IronPython, czy Visual F# na platformie .NET dają nam podobne
możliwości. Użycie zmiennych, klas, ich właściwości i metod jest w nich prawie identyczne.
Środowisko .NET (tzw. framework) oferuje wspólne typy danych (Common Type System)
i biblioteki klas (.NET Class Framework).
Potrzeby obecnych użytkowników oprogramowania wymagają, aby aplikacje dysponowały
graficznymi interfejsami (były okienkowe). To z kolei rodzi wymagania względem środowisk
programistycznych, które muszą być odpowiednio efektywne. Archaicznym podejściem do
nauki programowania jest bazowanie na narzędziach, które nie zapewniają wspomagania
graficznego w tworzeniu interfejsów, nie preferują programowania obsługującego zdarzenia
i programowania obiektowego. Te pojęcia nie muszą oznaczać wyższego wtajemniczenia
w sztukę programowania. Nie należy klasyfikować ich jako zbyt zaawansowane. Od nich
musimy zaczynać nie tylko programowanie, ale już analizę problemu i projektowanie
rozwiązania. Języki platformy .NET umożliwiają jak nigdy dotąd tworzenie programów
obiektowych, sterowanych zdarzeniami i silnie wspomaganych graficznie(w języku F# jest tu
jeszcze dużo do usprawnienia). Od samego początku wykorzystujemy (przynajmniej
pasywnie) właściwości i metody obiektów, nawet nie wspominając o nich. W sytuacjach, gdy
interfejs graficzny jest zbędny lub przeszkadza w zgłębieniu istoty problemu można zbu-
dować aplikację konsolową.
Platforma .NET to nie tylko języki programowania. W wielu sytuacjach języki pełnią rolę
pomocniczą, służąc do zapisywania poleceń. W Visual Studio znajdziemy Server Explorer, za
pomocą którego możemy tworzyć tabele baz danych i łączyć je relacjami. Zbiór klas ADO
.NET umożliwia z kolei zarządzanie bazami w tradycyjnym środowisku połączonym jak
i w bardziej efektywnym i nowoczesnym środowisku rozłączonym. Do wykonania szeregu
zadań, jak zapytania i modyfikacje relacyjnych baz danych wykorzystywać możemy
popularny język SQL. Dane możemy zapisywać w coraz bardziej popularnym, niezależnym od
platformy formacie XML.
Platforma .NET oferuje również (a może przede wszystkim) narzędzia do budowania aplikacji
internetowych i zarządzania zasobami rozproszonymi. Biblioteka ASP .NET umożliwia two-
rzenie formularzy WWW. Usługi Web Services umożliwiają tworzenie nowoczesnych aplikacji
rozproszonych.
Oprogramowanie Visual Studio stanowi środowisko uruchomieniowe, bibliotekę klas, kompi-
latory i narzędzia pomocnicze.
Programy napisane dla środowiska .NET Framework nie są kompilowane od razu do kodu
maszynowego danego procesora, lecz do kodu pośredniego MSIL (Microsoft Intermediate
Language). Uruchomienie programu wymaga więc środowiska CLR (Common Language
Runtime), które jest częścią .NET Framework. Podczas pierwszego uruchomienia programu
na maszynie docelowej kompilator Just In Time tworzy kod maszynowy specyficzny dla
danego procesora. W uproszczeniu przedstawia to poniższy schemat.
10
W systemach operacyjnych Windows niezbędne jest zainstalowanie bibliotek .NET Frame-
work, dostępnych bezpłatnie na stronach internetowych Microsoftu (instalowane są auto-
matycznie podczas instalacji Visual Studio).
Środowisko Visual Studio 2010 (lub wcześniejsza wersja 2008) daje znacznie większy komfort
pracy z językiem F#. Bezpłatną powłokę (Shell) można pobrać pod adresem:
http://www.microsoft.com/downloads/en/details.aspx?FamilyID=8e5aa7b6-8436-43f0-
b778-00c3bca733d3&displaylang=en
Istotna jest kolejność instalacji. Najpierw należy zainstalować Visual Studio 2010 Shell,
a później konsolę F#. W przeciwnym wypadku wymagane komponenty nie zostaną zainsta-
lowane w Visual Studio. Można oczywiście wtedy odinstalować konsolę i ponownie zainsta-
lować ją.
W komercyjnym (płatnym) wydaniu Visual Studio 2010 język F# jest wbudowany i nie trzeba
doinstalowywać go.
.NET Framework
Projekt
Kod
źródłowy
Kompilator
Common Language
Runtime Kod w języku
pośrednim
MSIL
Kompilator JIT
Kod maszynowy
procesora
11
Rysunek 2. Visual Studio 2010 Shell
W środowisku Visual Studio można wygodnie tworzyć kod programu, uruchamiać go (kompi-
lować), debuggować, testować, edytować itp.
Możliwa jest tu również praca z interpreterem, czyli interaktywnie wykonywanie poleceń.
Rysunek 3. Praca interaktywna w Visual Studio 2010
LINQPad
LINQPad jest programem stworzonym głównie do uruchamiania interaktywnych kwerend
baz danych w nowoczesnej technologii LINQ, stosowanej w coraz większej liczbie języków
programowania. Współczesne wersje programu są jednak coraz bardziej uniwersalne.
Pozwalają między innymi pisać, uruchamiać i testować programy napisane w języku F#.
12
Program można pobrać ze strony: http://www.linqpad.net
Rysunek 4. Język F# w LINQPad
13
Rozdział 1.
Praca w różnych środowiskach
1.1. Wyprowadzanie komunikatów
Podstawowym zadaniem programów jest komunikacja z użytkownikiem, czyli drukowanie
(wyprowadzanie) komunikatów, wyników i innych napisów w oknach programów (teksto-
wych lub graficznych). Niezależnie od tego, czy wyprowadzamy komunikaty w trybie teksto-
wym (inaczej do konsoli F#), czy też w oknach Windows, wygodnym sposobem tworzenia
kodu źródłowego jest użycie Visual Studio 2010 Shell.
Ćwiczenie 1. Drukujemy komunikaty na konsoli
• Uruchomimy Visual Studio 2010 Shell i klikniemy pierwszy przycisk (z lewej) na pasku
narzędzi, czyli New Project.
• W oknie dialogowym New Project wybierzemy typ projektu (Installed Templates) – F#
Application, określimy własną nazwę projektu (zostanie automatycznie utworzony
katalog o podanej nazwie) i wybierzemy lokalizację na dysku.
Rysunek 1.1. New Project
14
• Po otwarciu projektu zobaczymy okno, przeznaczone do wpisywania kodu źródło-
wego, zatytułowane Program.fs i kilka innych okienek.
• Wpiszemy następujący kod:
// ten znak rozpoczyna komentarz tzw. Wierszowy (do końca
wiersza)
// komentarze ignorowane są przez translator,
// słuŜą do dokumentowania skryptu (kodu)
(* komentarz blokowy – moŜe zajmować wiele wierszy *)
open System //uŜycie biblioteki System – tutaj do
„Console”
//wyprowadzenie wyników
printfn „Mój komunikat”
//j.w. z wykorzystaniem biblioteki .NET
Console.WriteLine(„Drugi komunikat”)
//zatrzymanie konsoli
//Console.ReadLine() |> ignore
//lub:
Console.ReadKey(true) |> ignore
• Wypróbujemy swój produkt, uruchamiając go z poziomu środowiska zintegrowanego.
W tym celu wybierzemy przycisk Start Debugging (�) z paska narzędzi. Alternatywne
sposoby to Debug>Start Debugging lub klawisz F5, Debug>Start Without Debugging
lub Ctrl +F5. Warto polecić ten ostatni, pomijający śledzenie programu, które
spowalnia kompilację i uruchomienie. Program można, oczywiście, uruchamiać spoza
środowiska zintegrowanego. W wyniku kompilacji powstaje plik wykonywalny
o podanej wcześniej nazwie projektu i rozszerzeniu exe. Odnajdziemy go w folderze
swojego projektu, w odpowiednim podkatalogu. Pliki z kodem źródłowym posiadają
rozszerzenie fs.
Rysunek 1.2. Komunikaty na konsoli
15
Przeanalizujemy wprowadzony kod:
• open System – udostępnienie przestrzeni nazw (biblioteki). Pozwala uniknąć pisa-
nia kwalifikowanych (wieloczłonowych) nazw, np.:
System.Console.WriteLine(„Komunikat”).
• printfn „Mój komunikat” – wydruk podanego łańcucha tekstowego
i przejście do następnego wiersza (printf – bez zmiany wiersza). Polecenie może
zawierać łańcuch formatujący, służący do wyprowadzania różnych typów wyników.
• Console.WriteLine(„Drugi komunikat”) – inny sposób wyprowadzania
komunikatów i wyników.
• Console.ReadLine() |> ignore – wstrzymanie zamknięcia konsoli do mo-
mentu wciśnięcia klawisza Enter. Druga część komendy „|> ignore” nakazuje
zignorowanie zwracanego wyniku.
• Console.ReadKey(true) |> ignore – inny sposób wstrzymania zamknięcia
konsoli (do momentu naciśnięcia dowolnego klawisza.
Wyniki (komunikaty) możemy wyprowadzać również do okna pracy interaktywnej programu
Visual Studio 2010. Znajdziemy je (możemy otworzyć) w menu View>Other Windows>F#
Interactive. Aby wyprowadzić wyniki do tego okna, należy zaznaczyć wybrany fragment kodu,
nacisnąć prawy przycisk myszki i wybrać z menu wyskakującego polecenie Send To
Interactive.
Okna F# Interactive można używać poza tym do interaktywnej pracy z interpreterem języka
F#.
Rysunek 1.3. Wysłanie wyników do okna F# Interactive
16
Rysunek 1.4. Okno F# Interactive
Ćwiczenie 2. Testujemy kod w programie LINQPad
• Uruchomimy program LINQPad.
• Z listy Language, na pasku narzędzi, wybierzemy opcję F# Program.
Rysunek 1.5. Lista obsługiwanych języków w LINQPad
• Napiszemy następującą treść kodu:
open System
//wyprowadzenie wyników
printfn "Mój komunikat"
//j.w. z wykorzystaniem .NET
Console.WriteLine("Drugi komunikat")
//wypr. wyników w LinqPad
"Kolejny komunikat".Dump()
• Program uruchomimy przyciskiem �.
17
Rysunek 1.6. Wyniki programu w LINQPad
Polecenie Dump() jest alternatywnym sposobem wyprowadzenia wyników, funkcjonują-
cym tylko w LINQPad.
Treść kodu źródłowego można zapisać w pliku z domyślnym rozszerzeniem „linq” lub innym
dowolnym, np. ”fs”. Pliki typu „linq” są plikami tekstowymi z kodem źródłowym, podobnie
jak pliki „fs”. Te pierwsze mogą być użyte w innych środowiskach, np. w Visual Studio, po
usunięciu z nich pierwszego wiersza (pełni funkcję informacyjną tylko dla programu
LINQPad).
Ćwiczenie 3. Tworzymy pierwsze okno F# w Visual Studio
Pisząc programy w języku F# możemy pracować nie tylko w trybie konsolowym, ale również
tworzyć aplikacje okienkowe. Atrakcyjność pracy w środowisku Visual Studio w dużej mierze
związana jest z pracą w trybie graficznym i w usprawnianiu wykonywanych czynności
poprzez wspomaganie graficzne oraz autouzupełnienia (tzw. IntelliSense). Z dobrodziejstw
tej drugiej technologii możemy w pełni korzystać, natomiast pierwsze usprawnienie
w obecnej wersji jeszcze nie funkcjonuje. Brak jest szablonu Windows Forms Application.
Wobec powyższego, do pracy z okienkami w F# (dokładniej w Visual F#) musimy „ręcznie”
przygotować projekt aplikacji Visual Studio.
Napiszemy program, który wydrukuje komunikat w oknie Windows.
• Uruchomimy Visual Studio 2010 Shell i utworzymy nowy projekt typu F# Application.
Nadamy mu nazwę, np. „Cw3-okna”.
Powstały projekt jest szkieletem aplikacji konsolowej. Przekształcimy go w aplika-cję
Windows Forms.
18
• Z menu Project wybierzemy AddReference… i dalej kartę .NET. Wskażemy bibliotekę
System.Windows.Forms i zatwierdzimy przyciskiem OK.
• Ponownie otworzymy okno Add Reference i wskażemy bibliotekę
System.Drawing.
Rysunek 1.7. Dodawanie referencji do bibliotek .NET
• Z menu Project wybierzemy Properties… i zmienimy typ naszej aplikacji na
Windows Application.
Rysunek 1.8. Zmiana typu aplikacji
• W oknie Program.fs wpiszemy kod źródłowy:
// uŜycie bibliotek "okienkowych"
open System.Windows.Forms
open System.Drawing
// utworzenie obiektu formularza
let form =new Form(Text="Mój formularz",StartPosition=
FormStartPosition.CenterScreen,
19
AutoScaleMode=AutoScaleMode.Font)
// utworzenie obiektu etykiety
let label=new Label(Text="Komunikat w
oknie!",Top=20,Left=10,
AutoSize=true)
// dodanie etykiety do kolekcji kontrolek formularza
form.Controls.Add(label)
// wyświetlenie formularza
form.Show() //lub Visible=true w new Form(...
// uruchomienie aplikacji
Application.Run(form)
• Projekt możemy już uruchomić (np. CTRL+F5).
Rysunek 1.9. Aplikacja Windows Forms
Aplikacje okienkowe (Windows Forms) wymagają utworzenia formularza, prezentującego
okno programu i kontrolek (inaczej formantów) umieszczonych na nim. Definicje klas tych
obiektów zawarte są w odpowiednich bibliotekach: System.Windows.Forms,
System.Drawing.
Aby utworzyć obiekt formularza, musimy użyć słowa kluczowego new i nazwy klasy
z odpowiednimi parametrami. Całość przypisujemy do własnej zmiennej (w F# bardziej
odpowiednim tu określeniem jest „wartość niezmienna”) używając słowa kluczowego let,
np.:
let form =new Form(Text="Mój formularz",StartPosition=
FormStartPosition.CenterScreen,AutoScaleMode=AutoScaleMode.Fon
t)
Teksty, napisy, komunikaty umieszczamy na formularzach w etykietach. Obiekt etykiety two-
rzymy używając klasy Label:
20
let label=new Label(Text="Komunikat w
oknie!",Top=20,Left=10, AutoSize=true)
Etykiety i inne kontrolki musimy dodać do kolekcji obiektów formularza:
form.Controls.Add(label)
Wyświetlaniem formularza na ekranie zajmuje się funkcja (dla obiektu to inaczej – metoda)
Show:
form.Show()
Aplikację uruchomimy wywołując metodę Run:
Application.Run(form)
PEŁNA WERSJA
http://www.escapemagazine.pl/369717-jezyk-f-w-praktyce
Top Related