F # - Clases

Las clases son tipos que representan objetos que pueden tener propiedades, métodos y eventos. 'Se utilizan para modelar acciones, procesos y cualquier entidad conceptual en aplicaciones'.

Sintaxis

La sintaxis para definir un tipo de clase es la siguiente:

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

Dónde,

  • los type-namees cualquier identificador válido. El modificador de acceso predeterminado para esto espublic.

  • los type-params describe los parámetros de tipo genérico opcionales.

  • los parameter-listdescribe los parámetros del constructor. El modificador de acceso predeterminado para el constructor primario espublic.

  • los identifier usado con el opcional as la palabra clave da un nombre a la variable de instancia, o self-identifier, que se puede utilizar en la definición de tipo para hacer referencia a la instancia del tipo.

  • los inherit La palabra clave le permite especificar la clase base para una clase.

  • los let Los enlaces le permiten declarar campos o valores de funciones locales a la clase.

  • los do-bindings La sección incluye código que se ejecutará al construir el objeto.

  • los member-list consta de constructores adicionales, declaraciones de método estático y de instancia, declaraciones de interfaz, enlaces abstractos y declaraciones de propiedades y eventos.

  • Las palabras clave class y end que marcan el inicio y el final de la definición son opcionales.

Constructor de una clase

El constructor es código que crea una instancia del tipo de clase.

En F #, los constructores funcionan de manera un poco diferente a otros lenguajes .Net. En la definición de clase, los argumentos del constructor primario se describen como lista de parámetros.

El cuerpo del constructor consta del let y do fijaciones.

Puede agregar constructores adicionales usando la nueva palabra clave para agregar un miembro:

new (argument-list) = constructor-body

El siguiente ejemplo ilustra el concepto:

Ejemplo

El siguiente programa crea una clase de línea junto con un constructor que calcula la longitud de la línea mientras se crea un objeto de la clase:

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)

Cuando compila y ejecuta el programa, produce el siguiente resultado:

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

Let Bindings

Los enlaces let en una definición de clase le permiten definir campos privados y funciones privadas para clases de 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")

Cuando compila y ejecuta el programa, produce el siguiente resultado:

Hello Zara

Tenga en cuenta el uso de autoidentificador gr para la clase Saludos .