Exemplarische Vorgehensweise: Ihr erstes F#-Programm

Artikel
08/10/2011

In Visual Studio 2010 wurde die neue Programmiersprache F# eingeführt. F# ist eine Sprache mit mehreren Paradigmen, die zusätzlich zur herkömmlichen objektorientierten Programmierung und .NET-Konzepten die funktionale Programmierung unterstützt. Die folgenden Beispiele bieten einen Einstieg in die Funktionen und Syntax dieser neuen Sprache. Die Beispiele zeigen, wie einfache Variablen deklariert werden, wie Funktionen geschrieben und getestet werden, wie Tupel und Listen erstellt werden und wie eine Klasse definiert und verwendet wird.

Tipp

Ihr Computer zeigt möglicherweise für einige der Elemente der Visual Studio-Benutzeroberfläche in der folgenden Anleitung andere Namen oder Standorte an. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

So erstellen Sie eine neue Konsolenanwendung

Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.
Wenn Visual F# im Bereich Vorlagenkategorien nicht angezeigt wird, klicken Sie auf Andere Sprachen und dann auf Visual F#. Im Bereich Vorlagen in der Mitte sind die F#-Vorlagen aufgeführt.
Stellen Sie oben im Bereich Vorlagen sicher, dass .NET Framework 4 im Feld Zielframework angezeigt wird.
Klicken Sie in der Liste der Vorlagen auf F# Application.
Geben Sie einen Namen für das Projekt in das Feld Name ein.
Klicken Sie auf OK.

Das neue Projekt wird im Projektmappen-Explorer angezeigt.

So deklarieren und verwenden Sie Bezeichner mit dem let-Schlüsselwort

Kopieren Sie den folgenden Code, und fügen Sie ihn in Program.fs ein. Sie binden die einzelnen Bezeichner anInt, aString und anIntSquared an einen Wert.
```
let anInt = 5
let aString = "Hello"
// Perform a simple calculation and bind anIntSquared to the result.
let anIntSquared = anInt * anInt
```
Tipp

Wenn Sie den Code in der klassischen Ansicht nicht sehen können, stellen Sie sicher, dass der Sprachfilter im Header unter der Themenüberschrift auch F# berücksichtigt.

So zeigen Sie die Ergebnisse im F# Interactive-Fenster an

Wählen Sie die let-Ausdrücke aus der vorherigen Prozedur aus.
Klicken Sie mit der rechten Maustaste auf den ausgewählten Bereich, und klicken Sie dann auf Senden an Interactive. Alternativ können Sie die Tastenkombination ALT+EINGABETASTE verwenden.
Das Fenster F# Interactive wird geöffnet, und die Ergebnisse der Auswertung der let-Ausdrücke werden angezeigt. Die folgenden Zeilen veranschaulichen diesen Vorgang. Die Typen werden von den angegebenen Werten abgeleitet.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

So zeigen Sie die Ergebnisse in einem Eingabeaufforderungsfenster an

Fügen Sie Program.fs die folgenden Zeilen hinzu.

System.Console.WriteLine(anInt)
System.Console.WriteLine(aString)
System.Console.WriteLine(anIntSquared)

Drücken Sie STRG+F5, um den Code auszuführen. Ein Eingabeaufforderungsfenster mit den folgenden Werten wird angezeigt.

5

Hello

25

Zur Überprüfung der abgeleiteten Typen zeigen Sie mit der Maus auf die Bezeichnernamen anInt, aString und anIntSquared in den vorangehenden WriteLine-Anweisungen.

So definieren und führen Sie eine Funktion aus

Verwenden Sie einen let-Ausdruck, um eine Quadratfunktion zu definieren, wie im folgenden Code gezeigt. Die Funktion verfügt über einen Parameter n und gibt das Quadrat des an n gesendeten Arguments zurück.
```
let square n = n * n
// Call the function to calculate the square of anInt, which has the value 5.
let result = square anInt
// Display the result.
System.Console.WriteLine(result)
```
Drücken Sie STRG+F5, um den Code auszuführen. Das angezeigte Ergebnis ist 25.
Eine rekursive Funktion erfordert einen let rec-Ausdruck. Im folgenden Beispiel wird eine Funktion zur Berechnung der Fakultät des Parameters n definiert.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Drücken Sie STRG+F5, um die Funktion auszuführen. Das angezeigte Ergebnis ist 120, die Fakultät von 5.

So erstellen Sie Auflistungen: Listen und Tupel

Eine Methode zum Zusammenfassen von Werten ist die Verwendung eines Tupels, wie im folgenden Code gezeigt.

let turnChoices = ("right", "left")
System.Console.WriteLine(turnChoices)
// Output: (right, left)

let intAndSquare = (anInt, square anInt)
System.Console.WriteLine(intAndSquare)
// Output: (5,25)

Eine weitere Methode ist die Verwendung einer Liste wie im folgenden Code.
```
// List of best friends.
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Fügen Sie der Liste mit dem "cons"-Operator (::) einen neuen "Best Friend" hinzu. Beachten Sie, dass der Wert von bffs durch die Operation nicht geändert wird. Der Wert von bffs ist unveränderlich.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Verwenden Sie printfn zum Anzeigen der Listen. Die printfn-Funktion zeigt die einzelnen Elemente an, die in strukturierten Werten enthalten sind.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Zum Anzeigen der Ergebnisse drücken Sie entweder STRG+F5 oder wählen einen Bereich im Code aus und drücken dann ALT+EINGABETASTE.

So erstellen und verwenden Sie eine Klasse

Mit dem folgenden Code wird eine Person-Klasse mit zwei Eigenschaften (Name und Age) erstellt. Die Name-Eigenschaft ist schreibgeschützt. Ihr Wert ist wie die meisten Werte bei der funktionalen Programmierung unveränderlich. Falls erforderlich, können Sie änderbare Werte in F# erstellen, müssen diese aber explizit als änderbar definieren. In der folgenden Klassendefinition wird der Wert von Age in der änderbaren lokalen Variablen internalAge gespeichert. Der Wert von internalAge kann geändert werden.

// The declaration creates a constructor that takes two values, name and age.
type Person(name:string, age:int) =
    // A Person object's age can be changed. The mutable keyword in the
    // declaration makes that possible.
    let mutable internalAge = age

    // Declare a second constructor that takes only one argument, a name.
    // This constructor calls the constructor that requires two arguments,
    // sending 0 as the value for age.
    new(name:string) = Person(name, 0)

    // A read-only property.
    member this.Name = name
    // A read/write property.
    member this.Age
        with get() = internalAge
        and set(value) = internalAge <- value

    // Instance methods.
    // Increment the person's age.
    member this.HasABirthday () = internalAge <- internalAge + 1

    // Check current age against some threshold.
    member this.IsOfAge targetAge = internalAge >= targetAge

    // Display the person's name and age.
    override this.ToString () = 
        "Name:  " + name + "\n" + "Age:   " + (string)internalAge

Um die Klasse zu testen, deklarieren Sie zwei Person-Objekte, nehmen Sie einige Änderungen vor und zeigen Sie die Ergebnisse an, wie im folgenden Code.

// The following let expressions are not part of the Person class. Make sure
// they begin at the left margin.
let person1 = Person("John", 43)
let person2 = Person("Mary")

// Send a new value for Mary's mutable property, Age.
person2.Age <- 15
// Add a year to John's age.
person1.HasABirthday()

// Display results.
System.Console.WriteLine(person1.ToString())
System.Console.WriteLine(person2.ToString())
// Is Mary old enough to vote?
System.Console.WriteLine(person2.IsOfAge(18))

Die folgenden Zeilen werden angezeigt.

Name: John

Age: 44

Name: Mary

Age: 15

False

So zeigen Sie andere Beispiele im F#-Lernprogramm an

Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.
Wenn Visual F# im Bereich Vorlagenkategorien nicht angezeigt wird, klicken Sie auf Andere Sprachen und dann auf Visual F#. Im Bereich Vorlagen in der Mitte sind die F#-Vorlagen aufgeführt.
Stellen Sie oben im Bereich Vorlagen sicher, dass .NET Framework 4 im Feld Zielframework angezeigt wird.
Klicken Sie in der Liste der Vorlagen auf F# Tutorial.
Klicken Sie auf OK.
Das Lernprogramm wird im Projektmappen-Explorer angezeigt.

Nächste Schritte

Weitere Informationen zur funktionalen Programmierung sowie weitere Beispiele finden Sie unter Funktionen als erstrangige Werte (F#). Weitere Informationen zu Tupeln, Listen, let-Ausdrücken, Funktionsdefinitionen, Klassen, Membern und vielen anderen Themen finden Sie unter F#-Sprachreferenz.