Procédure pas à pas : création de votre premier programme F#

Article
08/10/2011

Visual Studio 2010 inclut un nouveau langage de programmation : F#. F# est un langage multiparadigme qui prend en charge la programmation fonctionnelle en plus de la programmation traditionnelle orientée objet et des concepts .NET. Les exemples suivants présentent certaines fonctionnalités et syntaxe. Les exemples indiquent comment déclarer des variables simples, écrire et tester des fonctions, créer des tuples et des listes et définir et utiliser une classe.

Notes

Il est possible que votre ordinateur affiche des noms ou des emplacements différents pour certains des éléments d'interface utilisateur de Visual Studio dans les instructions suivantes. L'édition de Visual Studio dont vous disposez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d'informations, consultez Paramètres Visual Studio.

Pour créer une application console

Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
Si Visual F# ne figure pas dans le volet Catégories de modèles, cliquez sur Autres langages, puis sur Visual F#. Le volet Modèles au milieu liste les modèles F#.
Vérifiez en haut du volet Modèles que .NET Framework 4 apparaît dans la zone Framework cible.
Cliquez sur Application F# dans la liste des modèles.
Tapez un nom pour votre projet dans le champ Nom.
Cliquez sur OK.

Le nouveau projet s'affiche dans l'Explorateur de solutions.

Pour utiliser le mot clé let pour déclarer et utiliser des identificateurs

Copiez et collez le code suivant dans Program.fs. Vous liez chaque identificateur, anInt, aString et anIntSquared, à une valeur.
```
let anInt = 5
let aString = "Hello"
// Perform a simple calculation and bind anIntSquared to the result.
let anIntSquared = anInt * anInt
```
Notes

Si vous ne voyez pas le code dans l'Affichage classique, assurez-vous que le Filtre de langage dans l'en-tête sous le titre de la rubrique est défini pour inclure F#.

Pour afficher les résultats dans la fenêtre F# Interactive

Sélectionnez les expressions let dans la procédure précédente.
Cliquez avec le bouton droit sur la zone sélectionnée, puis cliquez sur Envoyer vers Interactive. Vous pouvez aussi appuyer sur ALT+ENTRÉE.
La fenêtre F# Interactive s'ouvre et les résultats de l'interprétation des expressions let s'affichent, comme indiqué dans les lignes suivantes. Les types sont déduits des valeurs spécifiées.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

Pour afficher les résultats dans une fenêtre d'invite de commandes

Ajoutez les lignes suivantes à Program.fs.

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

Appuyez sur CTRL+F5 pour exécuter le code. Une fenêtre d'invite de commandes, qui contient les valeurs suivantes, s'affiche.

5

Hello

25

Vous pouvez vérifier les types déduits en plaçant le pointeur de la souris sur le nom des identificateurs (anInt, aString et anIntSquared) dans les instructions WriteLine précédentes.

Pour définir et exécuter une fonction

Utilisez une expression let pour définir une fonction de mise au carré, comme indiqué dans le code suivant. La fonction possède un paramètre (n) et retourne le carré de l'argument envoyé à n.
```
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)
```
Appuyez sur CTRL+F5 pour exécuter le code. Le résultat affiché est 25.
Une fonction récursive requiert une expression let rec. L'exemple suivant définit une fonction qui calcule la factorielle de paramètre n.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Appuyez sur CTRL+F5 pour exécuter la fonction. Le résultat affiché est 120 et la factorielle de 5.

Pour créer des collections à l'aide de listes et de tuples

Vous pouvez agréger des valeurs à l'aide d'un tuple, comme indiqué dans le code suivant.

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

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

Vous pouvez aussi agréger des valeurs à l'aide d'une liste, comme indiqué dans le code suivant.
```
// List of best friends.
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Ajoutez un nouveau meilleur ami à la liste à l'aide de l'opérateur « cons » (::). Notez que l'opération ne change pas la valeur de bffs. La valeur de bffs est immuable et ne peut pas être changée.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Utilisez printfn pour afficher les listes. La fonction printfn affiche les éléments individuels qui sont contenus dans les valeurs structurées.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Vous pouvez afficher les résultats en appuyant sur CTRL+F5 ou en sélectionnant une section du code, puis en appuyant sur ALT+ENTRÉE.

Pour créer et utiliser une classe

Le code suivant crée une classe Person qui possède deux propriétés (Name et Age). Name est une propriété en lecture seule. Sa valeur est immuable, comme la plupart des valeurs en programmation fonctionnelle. Vous pouvez créer des valeurs mutables en F# si vous en avez besoin, mais vous devez les définir explicitement comme étant mutables. Dans la définition de classe suivante, la valeur d'Age est stockée dans une variable locale mutable (internalAge). La valeur d'internalAge peut être changée.

// 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

Pour tester la classe, déclarez deux objets Person, apportez-y des modifications et affichez les résultats, comme indiqué dans le code suivant.

// 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))

Les lignes suivantes s'affichent.

Name: John

Age: 44

Name: Mary

Age: 15

False

Pour afficher d'autres exemples dans le didacticiel F#

Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
Si Visual F# ne figure pas dans le volet Catégories de modèles, cliquez sur Autres langages, puis sur Visual F#. Le volet Modèles au milieu liste les modèles F#.
Vérifiez en haut du volet Modèles que .NET Framework 4 apparaît dans la zone Framework cible.
Cliquez sur Didacticiel F# dans la liste des modèles.
Cliquez sur OK.
Le didacticiel s'affiche dans l'Explorateur de solutions.

Étapes suivantes

Pour plus d'informations sur la programmation fonctionnelle et obtenir d'autres exemples, consultez Fonctions comme valeurs de première classe (F#). Pour plus d'informations sur les tuples, les listes, les expressions let, les définitions de fonction, les classes, les membres et de nombreuses autres sujets, consultez Référence du langage F#.