F # - Classi

Le classi sono tipi che rappresentano oggetti che possono avere proprietà, metodi ed eventi. "Sono utilizzati per modellare azioni, processi e qualsiasi entità concettuale nelle applicazioni".

Sintassi

La sintassi per definire un tipo di classe è la seguente:

// Class definition:
type [access-modifier] type-name [type-params] [access-modifier] ( parameter-list ) [ as identifier ] =
   [ class ]
      [ inherit base-type-name(base-constructor-args) ]
      [ let-bindings ]
      [ do-bindings ]
      member-list
      ...
   [ end ]

// Mutually recursive class definitions:
type [access-modifier] type-name1 ...
and [access-modifier] type-name2 ...
...

Dove,

  • Il type-nameè un qualsiasi identificatore valido. Il modificatore di accesso predefinito per questo èpublic.

  • Il type-params descrive parametri di tipo generico facoltativo.

  • Il parameter-listdescrive i parametri del costruttore. Il modificatore di accesso predefinito per il costruttore principale èpublic.

  • Il identifier utilizzato con l'opzionale as parola chiave dà un nome alla variabile di istanza, o self-identifier, che può essere utilizzato nella definizione del tipo per fare riferimento all'istanza del tipo.

  • Il inherit parola chiave consente di specificare la classe di base per una classe.

  • Il let le associazioni consentono di dichiarare campi o valori di funzioni locali alla classe.

  • Il do-bindings la sezione include il codice da eseguire sulla costruzione dell'oggetto.

  • Il member-list consiste in costruttori aggiuntivi, dichiarazioni di metodi statici e di istanze, dichiarazioni di interfaccia, associazioni astratte e dichiarazioni di proprietà ed eventi.

  • Le parole chiave class e end che segnano l'inizio e la fine della definizione sono opzionali.

Costruttore di una classe

Il costruttore è il codice che crea un'istanza del tipo di classe.

In F #, i costruttori funzionano in modo leggermente diverso dagli altri linguaggi .Net. Nella definizione della classe, gli argomenti del costruttore principale sono descritti come elenco di parametri.

Il corpo del costruttore è costituito da let e do attacchi.

È possibile aggiungere ulteriori costruttori utilizzando la nuova parola chiave per aggiungere un membro:

new (argument-list) = constructor-body

L'esempio seguente illustra il concetto:

Esempio

Il seguente programma crea una classe di linea insieme a un costruttore che calcola la lunghezza della linea mentre viene creato un oggetto della classe -

type Line = class
   val X1 : float
   val Y1 : float
   val X2 : float
   val Y2 : float

   new (x1, y1, x2, y2) as this =
      { X1 = x1; Y1 = y1; X2 = x2; Y2 = y2;}
      then
         printfn " Creating Line: {(%g, %g), (%g, %g)}\nLength: %g"
            this.X1 this.Y1 this.X2 this.Y2 this.Length

   member x.Length =
      let sqr x = x * x
      sqrt(sqr(x.X1 - x.X2) + sqr(x.Y1 - x.Y2) )
end
let aLine = new Line(1.0, 1.0, 4.0, 5.0)

Quando compili ed esegui il programma, restituisce il seguente output:

Creating Line: {(1, 1), (4, 5)}
Length: 5

Lascia che Bindings

Le associazioni let in una definizione di classe consentono di definire campi privati ​​e funzioni private per le classi F #.

type Greetings(name) as gr =
   let data = name
   do
      gr.PrintMessage()
   member this.PrintMessage() =
      printf "Hello %s\n" data
let gtr = new Greetings("Zara")

Quando compili ed esegui il programma, restituisce il seguente output:

Hello Zara

Si prega di notare l'uso dell'autoidentificatore gr per la classe Greetings .