F # - Classes

Les classes sont des types qui représentent des objets pouvant avoir des propriétés, des méthodes et des événements. «Ils sont utilisés pour modéliser des actions, des processus et toute entité conceptuelle dans les applications».

Syntaxe

La syntaxe pour définir un type de classe est la suivante -

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

Où,

• le type-nameest tout identifiant valide. Le modificateur d'accès par défaut pour cela estpublic.

• le type-params décrit les paramètres de type générique facultatifs.

• le parameter-listdécrit les paramètres du constructeur. Le modificateur d'accès par défaut pour le constructeur principal estpublic.

• le identifier utilisé avec l'option as mot-clé donne un nom à la variable d'instance, ou self-identifier, qui peut être utilisé dans la définition de type pour faire référence à l'instance du type.

• le inherit Le mot-clé vous permet de spécifier la classe de base d'une classe.

• le let les liaisons vous permettent de déclarer des champs ou des valeurs de fonction locales à la classe.

• le do-bindings La section comprend le code à exécuter lors de la construction de l'objet.

• le member-list se compose de constructeurs supplémentaires, de déclarations d'instances et de méthodes statiques, de déclarations d'interface, de liaisons abstraites et de déclarations de propriétés et d'événements.

• Les mots clés class et end qui marquent le début et la fin de la définition sont facultatifs.

Constructeur d'une classe

Le constructeur est un code qui crée une instance du type de classe.

En F #, les constructeurs fonctionnent peu différemment des autres langages .Net. Dans la définition de classe, les arguments du constructeur principal sont décrits comme une liste de paramètres.

Le corps du constructeur se compose du let et do fixations.

Vous pouvez ajouter des constructeurs supplémentaires en utilisant le nouveau mot clé pour ajouter un membre -

new (argument-list) = constructor-body

L'exemple suivant illustre le concept -

Exemple

Le programme suivant crée une classe de ligne avec un constructeur qui calcule la longueur de la ligne pendant qu'un objet de la classe est créé -

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)

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

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

Laisser les liaisons

Les liaisons let dans une définition de classe vous permettent de définir des champs privés et des fonctions privées pour les classes 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")

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Hello Zara

Veuillez noter l'utilisation de l'auto-identifiant gr pour la classe Greetings .