Procedura dettagliata: primo programma F#

Articolo
08/11/2011

Visual Studio 2010 include un nuovo linguaggio di programmazione, F#. F# è un linguaggio multi-paradigma che supporta la programmazione funzionale oltre alla programmazione tradizionale orientata a oggetti e ai concetti .NET. Negli esempi seguenti vengono introdotte alcune delle funzionalità e parte della sintassi. Negli esempi viene illustrato come dichiarare variabili semplici, scrivere ed eseguire il test di funzioni, creare tuple ed elenchi e definire e utilizzare una classe.

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 una nuova applicazione console

Scegliere Nuovo dal menu File, quindi Progetto.
Se Visual F# non compare nel riquadro Categorie di modelli, fare clic su Altri linguaggi, quindi su Visual F#. Nel riquadro Modelli al centro verranno visualizzati i modelli di F#.
Verificare che nella parte superiore del riquadro Modelli sia visualizzato .NET Framework 4 nella casella Versione .NET Framework di destinazione.
Fare clic su Applicazione F# nell'elenco di modelli.
Digitare un nome per il progetto nel campo Nome.
Scegliere OK.

Il nuovo progetto verrà visualizzato in Esplora soluzioni.

Per utilizzare la parola chiave let per dichiarare e utilizzare gli identificatori

Copiare e incollare il codice seguente in Program.fs. In questo modo si associa ogni identificatore, anInt, aString e anIntSquared, a un valore.
```
let anInt = 5
let aString = "Hello"
// Perform a simple calculation and bind anIntSquared to the result.
let anIntSquared = anInt * anInt
```
Nota

Se non è possibile visualizzare il codice nella visualizzazione classica, assicurarsi che il filtro relativo al linguaggio nell'intestazione sotto il titolo dell'argomento sia impostato per includere F#.

Per visualizzare i risultati nella finestra F# Interactive

Selezionare le espressioni let nella procedura precedente.
Fare clic con il pulsante destro del mouse sull'area selezionata, quindi scegliere Invia a Interactive. In alternativa, premere ALT+INVIO.
Verrà visualizzata la finestra F# Interactive con i risultati dell'interpretazione delle espressioni let, come illustrato nelle righe seguenti. I tipi vengono derivati dai valori specificati.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

Per visualizzare i risultati in una finestra del prompt dei comandi

Aggiungere le righe seguenti a Program.fs.

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

Premere CTRL+F5 per eseguire il codice. Verrà visualizzata una finestra del prompt dei comandi contenente i valori seguenti.

5

Hello

25

È possibile verificare i tipi derivati posizionando il puntatore del mouse sui nomi degli identificatori anInt, aString e anIntSquared nelle istruzioni WriteLine precedenti.

Per definire ed eseguire una funzione

Utilizzare un'espressione let per definire una funzione di elevazione al quadrato, come mostrato nel codice seguente. La funzione dispone di un solo parametro, n, e restituisce il quadrato dell'argomento inviato a 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)
```
Premere CTRL+F5 per eseguire il codice. Il risultato visualizzato sarà 25.
Una funzione ricorsiva richiede un'espressione let rec. Nell'esempio seguente viene definita una funzione che calcola il fattoriale del parametro n.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Premere CTRL+F5 per eseguire la funzione. Il risultato visualizzato sarà 120, ovvero il fattoriale di 5.

Per creare insiemi: elenchi e tuple

Un metodo di aggregazione di valori è dato dall'utilizzo di una tupla, come mostrato nel codice seguente.

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

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

Un altro metodo di aggregazione di valori è dato dall'utilizzo di un elenco, come mostrato nel codice seguente.
```
// List of best friends.
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Aggiungere un nuovo migliore amico all'elenco tramite l'operatore "cons" (::). Si noti che il valore di bffs non viene modificato dall'operatore. Il valore di bffs è invariabile, pertanto non può essere modificato.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Utilizzare printfn per visualizzare gli elenchi. La funzione printfn visualizza i singoli elementi contenuti nei valori strutturati.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Per visualizzare i risultati premere CTRL+F5 oppure selezionare una sezione del codice e premere ALT+INVIO.

Per creare e utilizzare una classe

Nel codice riportato di seguito viene creata una classe Person con due proprietà, Name e Age. Name è una proprietà di sola lettura. Il suo valore non è modificabile, come la maggior parte dei valori nella programmazione funzionale. All'occorrenza è possibile creare valori modificabili in F#, ma è necessario definirli in modo esplicito come modificabili. Nella definizione di classe seguente, il valore di Age viene archiviato in una variabile locale modificabile, internalAge. Il valore di internalAge può essere modificato.

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

Per eseguire il test della classe, dichiarare due oggetti Person, apportare alcune modifiche e visualizzare i risultati, come mostrato nel codice seguente.

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

Verranno visualizzate le righe seguenti.

Name: John

Age: 44

Name: Mary

Age: 15

False

Per visualizzare altri esempi nell'esercitazione su F#

Scegliere Nuovo dal menu File, quindi Progetto.
Se Visual F# non compare nel riquadro Categorie di modelli, fare clic su Altri linguaggi, quindi su Visual F#. Nel riquadro Modelli al centro verranno visualizzati i modelli di F#.
Verificare che nella parte superiore del riquadro Modelli sia visualizzato .NET Framework 4 nella casella Versione .NET Framework di destinazione.
Fare clic su Esercitazione su F# nell'elenco di modelli.
Scegliere OK.
L'esercitazione verrà visualizzata in Esplora soluzioni.

Passaggi successivi

Per ulteriori informazioni sulla programmazione funzionale e per altri esempi, vedere Funzioni come valori di prima classe (F#). Per ulteriori informazioni su tuple, elenchi, espressioni let, definizioni di funzioni, classi, membri e molti altri argomenti, vedere Riferimenti per il linguaggio F#.