Procédure pas à pas : utilisation de Visual F# pour créer, déboguer et déployer une application

Article
08/10/2011

Cette procédure pas à pas vous présente l'utilisation de F# dans Visual Studio 2010 avec .NET Framework 4.

Dans cette procédure pas à pas, vous en saurez plus sur la mise en route de Visual Studio 2010 pour écrire des applications F# via l'exemple de l'analyse historique des données relatives au taux d'intérêt du Trésor américain. Vous commencerez par quelques analyses rapides des données à l'aide de la fenêtre interactive F#, puis écrirez et testerez du code pour analyser les données, et enfin ajouterez un frontal C# pour explorer l'intégration de votre code F# avec d'autres langages .NET.

Composants requis

Pour exécuter cette procédure pas à pas, vous devez disposer des composants suivants :

Visual Studio 2010

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 un script F#

Créez d'abord un script F#. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Fichier. Dans la boîte de dialogue Nouveau fichier, sélectionnez Script dans la liste Modèles installés puis Fichier de script F#. Cliquez sur Ouvrir pour créer le fichier et enregistrez-le sous le nom RateAnalysis.fsx.
Utilisez les API .NET et F# pour accéder aux données du site Internet de la Réserve fédérale américaine. Tapez le code ci-dessous.
```
open System.Net
open System.IO

let url = sprintf "http://www.federalreserve.gov/releases/h15/data/business_day/H15_TCMNOM_Y10.txt"
let req = WebRequest.Create(url, Timeout = 10000000)
let resp = req.GetResponse()
let stream = resp.GetResponseStream()
let reader = new StreamReader(stream)
let csv = reader.ReadToEnd()
```
Notez les points suivants :
- Les chaînes et les mots clés sont colorisés.
- Les listes de saisie semi-automatique apparaissent après que vous avez tapé tous les points (.).
- Vous pouvez disposer de noms complets de méthodes Visual Studio et d'autres identificateurs à l'aide du raccourci clavier CTRL+ESPACE ou CTRL+J au milieu d'un identificateur. Une liste de saisie semi-automatique apparaît lorsque vous utilisez le raccourci clavier CTRL+J.
- Lorsque vous placez le pointeur de la souris juste au-dessus d'un identificateur dans le code, vous visualisez une info-bulle qui contient des informations sur cet identificateur.
- Si vous appuyez sur F1 lorsque le curseur se trouve dans WebRequest, la documentation appropriée apparaît.
- Si vous appuyez sur F1 lorsque le curseur se trouve dans let, la documentation appropriée apparaît.
- Par défaut, les types et les espaces de noms de mscorlib.dll, System.dll et System.Windows.Forms.dll sont référencés.
- La valeur Timeout définie ici est une propriété, et non un argument de constructeur. F# vous permet de définir des valeurs de propriétés de cette manière.
- Si vous copiez l'URL de l'exemple dans un navigateur, vous récupérez une liste de valeurs séparées par des virgules qui contiennent des dates et des taux d'intérêt, publiée par la Réserve fédérale américaine.
Vous allez maintenant exécuter le code à l'aide de F# Interactive. Sélectionnez l'intégralité du code (à l'aide de la souris ou du raccourci clavier CTRL+A) et cliquez avec le bouton droit, puis cliquez sur Envoyer vers Interactive. (Vous pouvez également utiliser le raccourci clavier ALT+ENTRÉE.)
- Si elle n'est pas déjà visible, la fenêtre F# Interactive s'affiche.
- Le code s'exécute correctement.
- Les éléments suivants apparaissent dans la fenêtre F# Interactive.
```
val url : string =
  "http://www.federalreserve.gov/releases/h15/data/business_day/"+[18 chars]
val req : System.Net.WebRequest
val resp : System.Net.WebResponse
val stream : System.IO.Stream
val reader : System.IO.StreamReader
val csv : string =
  "  ,Instrument,"U.S. government securities/Treasury constant m"+[224452 chars]

>
```
Ensuite, inspectez les données à l'aide de F# Interactive. À l'invite F# Interactive, tapez csv;; et appuyez sur ENTRÉE. Tapez csv.Length;; et appuyez sur ENTRÉE. Notez les points suivants :
- Les données sont actuelles.
- F# Interactive affiche la valeur de la chaîne csv ainsi que sa longueur, comme indiqué ici.
```
07/10/2009, 3.32
07/13/2009, 3.38
07/14/2009, 3.50
07/15/2009, 3.63
"
> csv.Length;;
val it : int = 224513
```
- L'illustration suivante présente la fenêtre F# Interactive.
  
  Fenêtre F# Interactive
À présent , vous allez écrire du code F# pour analyser des données CSV (Comma-Separated Values). Un fichier CSV est ainsi nommé car il contient des valeurs séparées par des virgules. Dans l'éditeur de code, ajoutez le code suivant : Lorsque vous ajoutez une ligne, sélectionnez le code ajouté dans cette section jusqu'à cette ligne et utilisez le raccourci clavier ALT+ENTRÉE pour consulter les résultats partiels. Notez les points suivants :
- IntelliSense vous fournit des informations utiles après que vous avez tapé un point, même au milieu d'expressions imbriquées complexes.
- Lorsque le code est incomplet (ou incorrect), des soulignements ondulés rouges indiquent que des erreurs syntaxiques et sémantiques s'affichent dans le code.
- Vous créez des pipelines à l'aide de l'opérateur de canal (|>). L'opérateur de canal extrait la valeur de retour d'une expression et l'utilise comme argument pour la fonction de la ligne suivante. Les canaux et F# Interactive permettent une exécution partielle simple de code de traitement de données.
```
let interest = 
    csv.Split([|'\n'|])
    |> Seq.skip 8
    |> Seq.map (fun line -> line.Trim())
    |> Seq.filter (fun line -> not (line.EndsWith("ND")))
    |> Seq.filter (fun line -> not (line.Length = 0))
    |> Seq.map (fun line -> line.Split([|','|]))
    |> Seq.map ( fun values ->
        System.DateTime.Parse(values.[0]),
        float values.[1])
```

Vous allez maintenant attribuer un nom à cette fonctionnalité. Supprimez 10 de la définition d' url et remplacez-le par %d pour convertir le littéral de chaîne en chaîne de format. Ajoutez maturity après la chaîne de format. Sélectionnez l'intégralité du code, à l'exception de cette nouvelle ligne et appuyez sur TAB. Au-dessus du bloc de code en retrait, ajoutez let loadRates maturity =. À la fin du bloc en retrait, ajoutez interest. Notez les points suivants :

La mise en retrait est significative dans F#. La mise en retrait indique le niveau d'imbrication.
TAB s'apparente quasiment à Extraire la méthode (Refactorisation C#).

Le code se présente maintenant comme suit :

open System.Net
open System.IO

let loadRates maturity = 
    let url = sprintf "http://www.federalreserve.gov/releases/h15/data/business_day/H15_TCMNOM_Y%d.txt" maturity
    let req = WebRequest.Create(url, Timeout = 10000000)
    let resp = req.GetResponse()
    let stream = resp.GetResponseStream()
    let reader = new StreamReader(stream)
    let csv = reader.ReadToEnd()

    let interest = 
        csv.Split([|'\n'|])
        |> Seq.skip 8
        |> Seq.map (fun line -> line.Trim())
        |> Seq.filter (fun line -> not (line.EndsWith("ND")))
        |> Seq.filter (fun line -> not (line.Length = 0))
        |> Seq.map (fun line -> line.Split([|','|]))
        |> Seq.map ( fun values ->
            System.DateTime.Parse(values.[0]),
            float values.[1])
    interest

À présent, vous allez utiliser ces fonctionnalités sur de nouvelles entrées. Sélectionnez l'intégralité du code et utilisez le raccourci clavier ALT+ENTRÉE pour l'exécuter à l'aide de F# Interactive. À l'invite F# Interactive, appelez la nouvelle fonction loadRates sur d'autres taux de maturité : 1, 2 et 5, en années. Notez les points suivants :
- Les précédentes définitions ne sont pas perdues dans F# Interactive, mais de nouvelles sont maintenant disponibles.
- Les données structurées complexes sont restituées par des fonctionnalités d'impression spéciales.

Pour développer un composant à l'aide de F#

Créez un projet de bibliothèque pour exposer les fonctionnalités que vous avez créées. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. Dans la boîte de dialogue Nouveau projet, sélectionnez Visual F# dans la liste Modèles installés, puis Bibliothèque F# pour créer un projet de bibliothèque. Attribuez le nom RateAnalysis au projet. Copiez le code que vous avez précédemment créé à partir de RateAnalysis.fsx et collez-le dans Module1.fs. Faites passer la déclaration de module dans Module1.fs du module Module1 au module RateLoader. Dans l'Explorateur de solutions, renommez Module1.fs en RateLoader.fs. Notez les points suivants :
- Le modèle Bibliothèque F# par défaut fournit un fichier de code portant l'extension .fs et un script dont l'extension est .fsx. Vous pouvez utiliser le fichier de script pour tester interactivement votre code de bibliothèque.

L'illustration suivante présente la boîte de dialogue Nouveau projet avec plusieurs options disponibles pour F#. Le modèle de projet Bibliothèque F# est sélectionné.

Options de modèles F#

Boîte de dialogue Nouveau projet avec bibliothèque F# sélectionnée

À présent, vous allez créer une classe F# qui affiche les fonctionnalités souhaitées. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur votre projet, pointez sur Ajouter, puis cliquez sur Nouvel élément. Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Fichier source F#. Attribuez le nom Analyzer.fs au fichier. Cliquez avec le bouton droit sur Script.fsx dans l'Explorateur de solutions, puis cliquez sur Descendre. (Vous pouvez également utiliser le raccourci clavier ALT+BAS.) Collez le code suivant dans Analyzer.fs :
```
module RateAnalysis.Analyzer

open RateLoader

/// Provides analysis of historical interest rate data.
type Analyzer(ratesAndDates) = 
    let rates = 
        ratesAndDates
        |> Seq.map snd

    /// Construct Analyzer objects for each maturity category.
    static member GetAnalyzers(maturities) = 
        maturities
        |> Seq.map loadRates
        |> Seq.map (fun ratesAndDates -> new Analyzer(ratesAndDates))

    member sa.Min =
        let date, minRate = (Seq.minBy (fun (_, rate) -> rate) ratesAndDates)
        (minRate, date.ToString("d"))

    member sa.Max = 
        let date, maxRate = (Seq.maxBy (fun (_, rate) -> rate) ratesAndDates)
        (maxRate, date.ToString("d"))

    member sa.Current =
        rates |> List.ofSeq |> List.rev |> List.head 
```
Notez les points suivants :
- F# prend en charge des concepts de programmation orientée objet. Pour plus d'informations, consultez Classes (F#), Héritage (F#) et d'autres rubriques pertinentes dans la Référence du langage F#.
Vous allez maintenant générer des commentaires sur la documentation XML. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis cliquez sur Propriétés. Dans l'onglet Générer, activez la case à cocher Fichier de documentation XML située en bas de page. Notez les points suivants :
- Vous pouvez générer la documentation XML pour tous les assemblys F#.
- Par défaut, la documentation XML est générée dans le chemin de sortie.

Pour générer le projet, utilisez le raccourci clavier CTRL+MAJ+B ou appuyez sur F6. Notez les points suivants :

Le projet est correctement généré.
La fenêtre Liste d'erreurs n'affiche aucune erreur.
Le répertoire de sortie contient des fichiers .dll, .pdb et .xml.

La fenêtre Sortie affiche les éléments suivants :

------ Build started: Project: RateAnalysis, Configuration: Debug Any CPU ------
    C:\Program Files (x86)\Microsoft F#\v4.0\fsc.exe -o:obj\Debug\RateAnalysis.exe -g --debug:full --noframework --define:DEBUG --define:TRACE --optimize- --tailcalls- -r:"C:\Program Files (x86)\Microsoft F#\v4.0\FSharp.Core.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\mscorlib.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Core.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.dll" --target:exe --warn:3 --warnaserror:76 --vserrors --utf8output --fullpaths --flaterrors Program.fs RateLoader.fs ValueAnalyzer.fs 
    RateAnalysis -> C:\Users\ghogen\Documents\Visual Studio 10\Projects\RateAnalysis\RateAnalysis\bin\Debug\RateAnalysis.exe
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========

Pour ajouter une application client C#, cliquez avec le bouton droit de la souris sur le nœud de la solution, pointez sur Ajouter, puis cliquez sur Nouveau projet. Dans la boîte de dialogue Ajouter un nouveau projet, sélectionnez Visual C# dans la liste Modèles installés, puis sélectionnez Application console. Vous devrez peut-être développer le nœud Autres langages. Attribuez le nom CSharpDriver au projet. Cliquez avec le bouton droit sur le nœud Références de ce projet et cliquez sur Ajouter une référence. Dans l'onglet Projets de la boîte de dialogue Ajouter une référence, sélectionnez RateAnalysis et cliquez sur OK. Cliquez avec le bouton droit de la souris sur le nœud du projet CSharpDriver, puis cliquez sur Définir comme projet de démarrage. Tapez le code suivant dans le corps de la méthode Main de l'application C#. Notez les points suivants :
- Vous pouvez ajouter des références entre projets à partir de et vers C# et F#.
- Les types et les espaces de noms définis par F# peuvent être utilisés à partir de C#, comme tout autre type.
- Les commentaires de documentation F# sont disponibles dans C# IntelliSense.
- C# peut accéder à des valeurs de retour de tuple à partir de l'API F#. Les tuples sont des valeurs Tuple de .NET Framework 4.
```
var maturities = new[] { 1, 2, 5, 10 };
var analyzers = RateAnalysis.Analyzer.Analyzer.GetAnalyzers(maturities);

foreach (var item in analyzers)
{
    Console.WriteLine("Min = {0}, \t Max = {1}, \t Current = {2}", item.Min, item.Max, item.Current);
}
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
```
Pour déboguer l'application, appuyez sur F11 pour générer l'application, démarrez l'application dans le débogueur et effectuez un pas à pas détaillé dans la première ligne de code exécuté. Appuyez sur F11 à plusieurs reprises jusqu'à ce que vous effectuiez un pas à pas détaillé dans le code F# du corps du membre GetAnalyzers. Notez les points suivants :
- Vous pouvez facilement passer du code C# au code F#.
- Chaque expression en F# est une étape du débogueur.
- La fenêtre Variables locales affiche les valeurs de maturities.
- Si vous continuez à appuyer sur F11, vous progresserez dans l'évaluation du reste de l'application.
- Les commandes du débogueur comme Exécuter jusqu'au curseur, Définir l'instruction suivante, Insérer un point d'arrêt, Ajouter un espion et Atteindre le Code Machine fonctionnent toutes normalement.

Pour déployer une application F# :

Dans cette étape, vous allez configurer le projet pour cibler une autre version du .NET Framework. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet RateAnalysis F#, puis cliquez sur Propriétés. Dans l'onglet Application, remplacez le paramètre Framework cible par .NET Framework 3.5. Notez les points suivants :
- F# vous permet de cibler d'autres versions du .NET Framework.
- La modification de la version cible du .NET Framework exige le rechargement du projet.
- Une fois que vous avez modifié la version cible du .NET Framework, certaines références d'assemblys ne sont plus activées dans la boîte de dialogue Ajouter une référence et elles ne sont pas disponibles.
Dans le projet C#, vous devez ajouter une référence à la version de l'assembly FSharp.Core qui cible .NET Framework 2.0, qui doit également être utilisé lorsque vous ciblez les versions 3.0 et 3.5 du .NET Framework. Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le nœud Références, puis cliquez sur Ajouter une référence. Dans l'onglet .NET, sélectionnez FSharp.Core version 2.0.0.0, puis cliquez sur OK. Régénérez la solution.
Pour définir les conditions préalables, double-cliquez sur le nœud Propriétés dans CSharpDriver. Dans l'onglet Publier, cliquez sur le bouton Composants requis et, dans la boîte de dialogue Composants requis, activez la case à cocher pour Microsoft Visual F# Runtime pour .NET 2.0. Notez les points suivants :
- F# dispose d'un package de runtime distinct du .NET Framework.
- Ce package de runtime doit être explicitement ajouté en tant que composant requis, lorsque vous déployez des applications qui utilisent F#.
- Deux packages de runtime sont disponibles : la version 2.0 pour .NET Framework 2.0, 3.0 et 3.5, et la version 4.0 pour .NET Framework 4.
Déployez l'application C# à l'aide de ClickOnce. Cliquez avec le bouton droit sur le projet CSharpDriver, puis cliquez sur Publier. Dans l'Assistant Publication, cliquez sur Terminer. Exécutez l'élément CSharpDriver.application obtenu. Notez les points suivants :
- Le package Visual F# Runtime est inclus avec l'application.
- L'exécution de l'application installe le package Runtime F# et exécute l'application correctement.

Étapes suivantes

Découvrez l'écriture du code F# en lisant Procédure pas à pas : création de votre premier programme F# ou sachez en plus sur les fonctions dans F# en consultant Fonctions comme valeurs de première classe (F#). Vous pouvez explorer le langage F# en lisant la Référence du langage F#.

Voir aussi

Autres ressources

Procédures pas à pas Visual F#

Exemples et procédures pas à pas (F#)

Share via