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