Procedura dettagliata: utilizzo di Visual F# per la creazione, il debug e la distribuzione di un'applicazione

  • Articolo

Questa procedura dettagliata contiene informazioni introduttive sull'utilizzo di F# in Visual Studio 2010 insieme a .NET Framework 4.

Nella procedura dettagliata verrà illustrato come iniziare a utilizzare Visual Studio 2010 per scrivere applicazioni F# mediante l'esempio di un'analisi storica dei dati sui tassi di interesse del Tesoro negli Stati Uniti. Si inizierà con una rapida analisi dei dati mediante la finestra F# Interactive, si procederà quindi con la scrittura e il test di codice per l'analisi dei dati, infine si aggiungerà un front end C# di esplorazione integrando il codice F# con altri linguaggi .NET.

Prerequisiti

Per completare la procedura dettagliata, è necessario disporre dei componenti seguenti:

  • Visual Studio 2010

Nota

Nel computer in uso è possibile che vengano visualizzati nomi o percorsi diversi per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti. La versione di Visual Studio in uso e le impostazioni configurate determinano questi elementi. Per ulteriori informazioni vedere Impostazioni di Visual Studio.

Per creare uno script F#

  1. Innanzitutto, creare uno script F#. Scegliere Nuovo dal menu File, quindi fare clic su File. Nella finestra di dialogo Nuovo file selezionare Script nell'elenco Modelli installati, quindi File di script F#. Fare clic su Apri per creare il file, quindi salvare il file con il nome RateAnalysis.fsx.

  2. Utilizzare le API di .NET e F# per accedere ai dati dal sito Internet della United States Federal Reserve (Banca centrale americana). Digitare il codice riportato di seguito.

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

    Tenere presente quanto segue:

    • Stringhe e parole chiave appaiono colorate.

    • Gli elenchi di completamento vengono visualizzati dopo avere digitato ogni punto (.).

    • In Visual Studio è possibile completare i nomi di metodo e altri identificatori premendo i tasti di scelta rapida CTRL+BARRA SPAZIATRICE o CTRL+J al centro di un identificatore. Premendo CTRL+J viene visualizzato un elenco di completamento.

    • Quando si posiziona il puntatore del mouse su un identificatore nel codice, viene visualizzata una descrizione comandi contenente informazioni su quell'identificatore.

    • Premendo F1 quando il cursore si trova in WebRequest, viene visualizzata la documentazione prevista.

    • Premendo F1 quando il cursore si trova in let, viene visualizzata la documentazione prevista.

    • I tipi e gli spazi dei nomi da mscorlib.dll, System.dll e System.Windows.Forms.dll sono oggetto di riferimento per impostazione predefinita.

    • Il valore Timeout impostato qui è una proprietà, non un argomento del costruttore. Questo è il modo in cui F# consente di impostare i valori delle proprietà.

    • Se si copia l'URL dell'esempio in un browser, si ottiene un elenco di valori delimitati da virgole contenenti i dati e i tassi di interesse, pubblicato dalla United States Federal Reserve.

  3. Si eseguirà ora il codice utilizzando F# Interactive. Selezionare tutto il codice (utilizzando un mouse o premendo CTRL+A), fare clic con il pulsante destro del mouse e scegliere Invia a Interactive. In alternativa, premere ALT+INVIO.

    • Se non era già visibile, verrà visualizzata la finestra F# Interactive.

    • Il codice viene eseguito correttamente.

    • Nella finestra F# Interactive viene visualizzato quanto segue.

      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]

>

  4. Controllare quindi i dati tramite F# Interactive. Al prompt di F# Interactive digitare csv;;, quindi premere INVIO. Digitare csv.Length;;, quindi premere INVIO. Tenere presente quanto segue:

    • I dati sono correnti.

    • Nella finestra F# Interactive viene visualizzato il valore della stringa csv e la relativa lunghezza, come illustrato qui.

      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

    • Nell'illustrazione seguente viene mostrata la finestra F# Interactive.

      Finestra F# Interactive

      Finestra F# Interactive

  5. Si scriverà ora codice F# per analizzare i dati CSV (Comma-Separated Values). La denominazione CSV indica un file contenente valori delimitati da virgole. Nell'editor di codice aggiungere il seguente codice. Quando si aggiunge una riga, selezionare il codice aggiunto in questa sezione fino alla riga in questione, quindi premere ALT+INVIO per vedere i risultati parziali. Tenere presente quanto segue:

    • IntelliSense fornisce informazioni utili dopo avere digitato un punto, anche nel mezzo di espressioni annidate complesse.

    • Quando il codice è incompleto o errato, sottolineature ondulate rosse indicano la presenza di errori sintattici e semantici.

    • Per creare pipeline si utilizza l'operatore pipe (|>). Questo operatore accetta il valore restituito da un'espressione e lo utilizza come argomento per la funzione nella riga successiva. Pipeline e F# Interactive consentono un'esecuzione parziale agevole del codice di elaborazione dati.

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

  6. Si assegnerà ora un nome a questa funzionalità. Rimuovere 10 dalla definizione di url e sostituirlo con %d per convertire il valore letterale di stringa in una stringa di formato. Aggiungere maturity dopo la stringa di formato. Selezionare tutto il codice eccetto questa nuova riga e premere TAB. Sopra il blocco di codice rientrato aggiungere let loadRates maturity =. Alla fine del blocco rientrato aggiungere interest. Tenere presente quanto segue:

    Il codice risulterà analogo al seguente.

    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

  7. Si utilizzerà ora questa funzionalità sui nuovi input. Selezionare tutto il codice e premere ALT+INVIO per eseguirlo tramite F# Interactive. Al prompt di F# Interactive chiamare la nuova funzione loadRates su altri tassi di interesse: 1, 2 e 5, in anni. Tenere presente quanto segue:

    • Le definizioni precedenti non vanno perse in F# Interactive, ma sono disponibili nuove definizioni.

    • Il rendering dei dati strutturati complessi viene eseguito tramite funzionalità di stampa speciali.

Per sviluppare un componente tramite F#

  • Creare un progetto di libreria per esporre la funzionalità creata. Scegliere Nuovo dal menu File, quindi fare clic su Progetto. Nella finestra di dialogo Nuovo progetto selezionare Visual F# nell'elenco Modelli installati, quindi Libreria F# per creare un nuovo progetto di libreria. Denominare il progetto RateAnalysis. Copiare il codice precedentemente creato da RateAnalysis.fsx e incollarlo in Module1.fs. Modificare la dichiarazione del modulo in Module1.fs da Module1 a RateLoader. In Esplora soluzioni modificare il nome Module1.fs con RateLoader.fs. Tenere presente quanto segue:

    • Il modello di libreria F# predefinito fornisce un file di codice con estensione .fs e uno script con estensione .fsx. È possibile utilizzare il file di script per testare in modo interattivo il codice della libreria.

Nell'illustrazione che segue viene mostrata la finestra di dialogo Nuovo progetto con diverse opzioni disponibili per F#. Il modello del progetto di libreria F# è selezionato.

Opzioni per il modello F#

Finestra di dialogo Nuovo progetto con la libreria F# selezionata

  1. Si creerà ora una classe F# che espone la funzionalità desiderata. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto, scegliere Aggiungi, quindi fare clic su Nuovo elemento. Nella finestra di dialogo Aggiungi nuovo elemento selezionare File di origine F#. Denominare il file Analyzer.fs. In Esplora soluzioni fare clic con il pulsante destro del mouse su Script.fsx, quindi scegliere Sposta giù. In alternativa, premere ALT+FRECCIA GIÙ. Incollare il codice seguente in 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

    Tenere presente quanto segue:

    • F# supporta i concetti di programmazione orientata a oggetti. Per ulteriori informazioni, vedere Classi (F#), Ereditarietà (C#) e altri argomenti attinenti nei Riferimenti per il linguaggio F#.

  2. Si genereranno ora commenti relativi alla documentazione XML. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto, quindi scegliere Proprietà. Nella scheda Compila selezionare la casella di controllo File di documentazione XML nella parte inferiore della pagina. Tenere presente quanto segue:

    • È possibile generare documentazione XML per qualsiasi assembly di F#.

    • Per impostazione predefinita, la documentazione XML viene generata nel percorso di output.

  3. Per compilare il progetto premere CTRL+MAIUSC+B oppure F6. Tenere presente quanto segue:

    • Il progetto viene compilato correttamente.

    • La finestra Elenco errori non contiene alcun errore.

    • La directory di output contiene file .dll, .pdb e .xml.

    • Nella finestra di output viene visualizzato quanto segue:

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

  4. Per aggiungere un'applicazione client C#, fare clic con il pulsante destro del mouse sul nodo della soluzione, scegliere Aggiungi, quindi Nuovo progetto. Nella finestra di dialogo Aggiungi nuovo progetto selezionare Visual C# nell'elenco Modelli installati, quindi Applicazione console. Potrebbe essere necessario espandere il nodo Altri linguaggi. Denominare il progetto CSharpDriver. Fare clic con il pulsante destro del mouse sul nodo Riferimenti del progetto, quindi scegliere Aggiungi riferimento. Nella scheda Progetti della finestra di dialogo Aggiungi riferimento selezionare RateAnalysis, quindi fare clic su OK. Fare clic con il pulsante destro del mouse sul nodo del progetto CSharpDriver, quindi scegliere Imposta come progetto di avvio. Digitare il codice seguente nel corpo del metodo Main dell'applicazione C#. Tenere presente quanto segue:

    • È possibile aggiungere riferimenti da progetto a progetto da e verso C# e F#.

    • I tipi e gli spazi dei nomi definiti di F# possono essere utilizzati da C# come qualsiasi altro tipo.

    • I commenti relativi alla documentazione di F# sono disponibili in C# IntelliSense.

    • C# può accedere ai valori restituiti delle tuple dall'API di F#. Le tuple sono valori Tuple di .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();

  5. Per eseguire il debug dell'applicazione, premere F11 per compilare l'applicazione, avviare l'applicazione nel debugger e passare alla prima riga di codice eseguito. Premere ripetutamente F11 fino ad avanzare al codice F# nel corpo del membro GetAnalyzers. Tenere presente quanto segue:

    • È possibile passare facilmente da codice C# a codice F#.

    • Ogni espressione in F# è un passaggio nel debugger.

    • Nella finestra Variabili locali vengono visualizzati i valori di maturities.

    • Continuando a premere F11 si prosegue nella valutazione della parte restante dell'applicazione.

    • I comandi del debugger quali Esegui fino al cursore, Imposta istruzione successiva, Inserisci punto di interruzione, Aggiungi espressione di controllo e Vai a disassembly funzionano tutti come previsto.

Per distribuire un'applicazione F#:

  1. In questo passaggio si imposterà il progetto in modo che sia destinato a una versione diversa di .NET Framework. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto F# RateAnalysis, quindi scegliere Proprietà. Nella scheda Applicazione modificare l'impostazione di Framework di destinazione in .NET Framework 3.5. Tenere presente quanto segue:

    • F# consente di scegliere come destinazione versioni diverse di .NET Framework.

    • La modifica del framework di destinazione richiede il ricaricamento del progetto.

    • Dopo avere modificato il framework di destinazione, alcuni riferimenti all'assembly non sono più abilitati nella finestra di dialogo Aggiungi riferimento e non sono disponibili.

  2. Nel progetto C# è necessario aggiungere un riferimento alla versione dell'assembly FSharp.Core destinata a .NET Framework 2.0, che deve essere inoltre utilizzato quando si scelgono come destinazioni le versioni 3.0 e 3.5 di .NET Framework. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo Riferimenti, quindi scegliere Aggiungi riferimento. Nella scheda .NET selezionare FSharp.Core versione 2.0.0.0, quindi fare clic su OK. Ricompilare la soluzione.

  3. Per impostare i prerequisiti, fare doppio clic sul nodo Proprietà in CSharpDriver. Nella scheda Pubblica fare clic sul pulsante Prerequisiti e, nella finestra di dialogo Prerequisiti, selezionare la casella di controllo relativa a Microsoft Visual F# Runtime per .NET 2.0. Tenere presente quanto segue:

    • F# dispone di un pacchetto di runtime distinto da .NET Framework.

    • Questo pacchetto di runtime deve essere aggiunto in modo esplicito come prerequisito quando si distribuiscono applicazioni che utilizzano F#.

    • Sono disponibili due pacchetti di runtime: la versione 2.0 per .NET Framework versioni 2.0, 3.0 e 3.5 e la versione 4.0 per .NET Framework 4.

  4. Distribuire l'applicazione C# utilizzando ClickOnce. Fare clic con il pulsante destro del mouse sul progetto CSharpDriver, quindi scegliere Pubblica. Nella Pubblicazione guidata scegliere Fine. Eseguire l'applicazione CSharpDriver risultante. Tenere presente quanto segue:

    • Il pacchetto di runtime di Visual F# è incluso nell'applicazione.

    • Eseguendo l'applicazione, il pacchetto di runtime di F# viene installato e l'applicazione viene eseguita correttamente.

Passaggi successivi

Per un'introduzione alla scrittura di codice F#, leggere Procedura dettagliata: primo programma F#; per informazioni sulle funzioni in F#, leggere Funzioni come valori di prima classe (F#). Per analizzare il linguaggio F#, leggere Riferimenti per il linguaggio F#.

Vedere anche

Altre risorse

Procedure dettagliate relative a Visual F#

Esempi e procedure dettagliate (F#)