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 insieme a .NET Framework 4.5.

In questa procedura verrà illustrato come iniziare a utilizzare Visual Studio 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

[!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 nella categoria Generale Nella lista dei modelli Installati e quindi selezionare 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/datadownload/Output.aspx?rel=H15&series=bcb44e57fb57efbe90002369321bfb3f&lastObs=&from=&to=&filetype=csv&label=include&layout=seriescolumn"
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 il mouse o premendo CTRL+A) e cliccare con il pulsante destro, quindi scegliere Esegui in interattivo.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/datadownload/Output.aspx?rel=H1"+[107 chars]
val req : System.Net.WebRequest
val resp : System.Net.WebResponse
val stream : System.IO.Stream
val reader : System.IO.StreamReader

val csv : string =
  ""Series Description","Market yield on U.S. Treasury securities"+[224219 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.Inoltre, aggiungere open System.Globalization all' inizio del file.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], CultureInfo.CreateSpecificCulture("en-US")),
        float values.[1])

  6. Si assegnerà ora un nome a questa funzionalità.Rimuovere l'ID di serie bcb44e57fb57efbe90002369321bfb3f dalla definizione di url e sostituirlo con %s per convertire la stringa letterale in una stringa di formato.Aggiungere seriesID dopo la stringa di formato.Selezionare tutto il codice eccetto le direttive aperte, e premere TAB.Sopra il blocco indentato del codice, aggiungere le seguenti righe di codice.

    let loadRates maturity =
    // The following tuples associate various maturity durations, in years,
    // with codes defined for treasury bills by the Federal Reserve.
    let maturitiesMap = Map.ofList [(1, "e30653a4b627e9d1f2490a0277d9f1ac")
                                    (2, "c66ea77a2e8f0919c5133c7633065908")
                                    (5, "fbb02942bfdbff31a479e98bcbe26388")
                                    (10, "bcb44e57fb57efbe90002369321bfb3f")
                                    (20, "a1ebeb6e84ca6389772dd054dc980191")]
    let seriesID = Map.find maturity maturitiesMap

    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 =
    // The following tuples associate various maturity durations, in years,
    // with codes defined for treasury bills by the Federal Reserve.
    let maturitiesMap = Map.ofList [(1, "e30653a4b627e9d1f2490a0277d9f1ac")
                                    (2, "c66ea77a2e8f0919c5133c7633065908")
                                    (5, "fbb02942bfdbff31a479e98bcbe26388")
                                    (10, "bcb44e57fb57efbe90002369321bfb3f")
                                    (20, "a1ebeb6e84ca6389772dd054dc980191")]
    let seriesID = Map.find maturity maturitiesMap
    let url = sprintf "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H15&series=%s&lastObs=&from=&to=&filetype=csv&label=include&layout=seriescolumn" seriesID
    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], CultureInfo.CreateSpecificCulture("en-US")),
            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 scegliere Progetto.Nella finestra di dialogo Nuovo progetto selezionare Visual F# nell'elenco 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 Library1.fs.Aggiungere una dichiarazione di modulo all'inizio del file: module RateLoader.In Esplora soluzioni, rinominare Library1.fs in RateLoader.fs, e salvare il file.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.

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

  3. Per aggiungere un'applicazione client C#, aprire il menu di scelta rapida del nodo della soluzione, scegliere Aggiungi e quindi scegliere Nuovo progetto.Nella finestra di dialogo Aggiungi nuovo progetto, scegliere Visual C# nell'elenco Modelli installati, quindi Applicazione console.Potrebbe essere necessario espandere il nodo Altri linguaggi.Denominare il progetto CSharpDriver, quindi scegliere il pulsante OK.Aprire il menu di scelta rapida nel nodo Riferimenti di questo progetto e quindi scegliere Aggiungi riferimento.Scegliere il nodo Soluzione, quindi selezionare il nodo Progetti.Selezionare la casella di controllo accanto al progetto RateAnalysis, quindi scegliere il pulsante OK.Aprire il menu di scelta rapida nel nodo CSharpDriver di questo progetto, quindi scegliere Imposta come progetto di avvio.Digitare il codice seguente nel corpo del metodo Main dell'applicazione C#.

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

    Tenere presente quanto segue:

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

    • E' possibile usare i spazi dei nomi definiti in F# e i tipi 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 in .NET Framework 4.5.

  4. 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 l'applicazione

  1. Se si sta eseguendo il debug, interrompere il debug scegliendo MAIUSC + F5 o aprendo il menu Debug e scegliendo Interrompi debug.

  2. Aprire il menu di scelta rapida del progetto CSharpDriver quindi scegliere Proprietà.

  3. Nella finestra di progettazione progetti, scegliere la scheda Pubblica, che mostra le opzioni per distribuire l'applicazione.

  4. Scegliere il pulsante Pubblicazione guidata.

    Viene avviata la Pubblicazione guidata e la prima schermata chiede dove inserire i file pubblicati.

  5. Nella casella di testo, specificare un percorso del disco locale in cui si desidera posizionare i file di installazione per l'applicazione quando sarà pubblicata, o scegliere il pulsante Sfoglia per passare a un percorso.

  6. Scegliere il pulsante Fine per accettare le impostazioni predefinite per compilare un'installazione standard che può essere distribuita ai client, oppure scegliere il pulsante Avanti per visualizzare altre opzioni di pubblicazione.

    Un eseguibile di installazione e i file di supporto vengono pubblicati nel percorso specificato.

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

Esempi e procedure dettagliate di Visual F#

Esempi e procedure dettagliate di Visual F#