Interfaces (F#)
Las interfaces especifican conjuntos de miembros relacionados que otras clases implementan.
Sintaxis
// Interface declaration:
[ attributes ]
type [accessibility-modifier] interface-name =
[ interface ] [ inherit base-interface-name ...]
abstract member1 : [ argument-types1 -> ] return-type1
abstract member2 : [ argument-types2 -> ] return-type2
...
[ end ]
// Implementing, inside a class type definition:
interface interface-name with
member self-identifier.member1argument-list = method-body1
member self-identifier.member2argument-list = method-body2
// Implementing, by using an object expression:
[ attributes ]
let class-name (argument-list) =
{ new interface-name with
member self-identifier.member1argument-list = method-body1
member self-identifier.member2argument-list = method-body2
[ base-interface-definitions ]
}
member-list
Comentarios
Las declaraciones de interfaz son similares a las declaraciones de clase, excepto que no se implementa ningún miembro. En su lugar, todos los miembros son abstractos, como se indica en la palabra clave abstract. No se proporciona un cuerpo del método para los métodos abstractos. F# no puede definir una implementación de método predeterminada en una interfaz, pero es compatible con las implementaciones predeterminadas definidas por C#. Las implementaciones predeterminadas que usan la palabra clave default solo se admiten al heredar de una clase base que no es de interfaz.
La accesibilidad predeterminada para las interfaces es public.
Opcionalmente, puede asignar un nombre a cada parámetro de método mediante la sintaxis normal de F#:
type ISprintable =
abstract member Print: format: string -> unit
En el ejemplo anterior ISprintable, el método Print tiene un único parámetro del tipo string con el nombre format.
Hay dos maneras de implementar interfaces: mediante expresiones de objeto y mediante tipos. En cualquier caso, el tipo o la expresión de objeto proporciona cuerpos de método para métodos abstractos de la interfaz. Las implementaciones son específicas de cada tipo que implementa la interfaz. Por lo tanto, los métodos de interfaz en diferentes tipos pueden ser diferentes entre sí.
Las palabras clave interface y end, que marcan el inicio y el final de la definición, son opcionales cuando se usa la sintaxis ligera. Si no usa estas palabras clave, el compilador intenta deducir si el tipo es una clase o una interfaz mediante el análisis de las construcciones que se usan. Si define un miembro o usa otra sintaxis de clase, el tipo se interpreta como una clase.
El estilo de codificación de .NET consiste en comenzar todas las interfaces con una mayúscula I.
Puede especificar varios parámetros de dos maneras: F#-style y . Estilo NET. Ambos compilarán de la misma manera para los consumidores de .NET, pero F#-style obligará a los llamadores de F# a usar la aplicación de parámetros de estilo F#y . El estilo de NET forzará a los autores de llamadas de F# a usar la aplicación de argumentos de tupla.
type INumericFSharp =
abstract Add: x: int -> y: int -> int
type INumericDotNet =
abstract Add: x: int * y: int -> int
Implementación de interfaces mediante tipos de clase
Puede implementar una o varias interfaces en un tipo de clase mediante la palabra clave interface, el nombre de la interfaz y la palabra clave with, seguidas de las definiciones de miembro de la interfaz, como se muestra en el siguiente código.
type IPrintable =
abstract member Print: unit -> unit
type SomeClass1(x: int, y: float) =
interface IPrintable with
member this.Print() = printfn "%d %f" x y
Las implementaciones de interfaz se heredan, por lo que las clases derivadas no necesitan volver a implementarlas.
Métodos de interfaz de llamada
Solo se puede llamar a métodos de interfaz a través de la interfaz, no a través de ningún objeto del tipo que implementa la interfaz. Por lo tanto, es posible que tenga que realizar la difusión al tipo de interfaz mediante el operador :> o el operador upcast para llamar a estos métodos.
Para llamar al método de interfaz cuando tiene un objeto de tipo SomeClass, debe convertir el objeto al tipo de interfaz, como se muestra en el siguiente código.
let x1 = new SomeClass1(1, 2.0)
(x1 :> IPrintable).Print()
Una alternativa es declarar un método en el objeto que realiza la difusión y llama al método de interfaz, como en el siguiente ejemplo.
type SomeClass2(x: int, y: float) =
member this.Print() = (this :> IPrintable).Print()
interface IPrintable with
member this.Print() = printfn "%d %f" x y
let x2 = new SomeClass2(1, 2.0)
x2.Print()
Implementación de interfaces mediante expresiones de objeto
Las expresiones de objeto proporcionan una forma corta de implementar una interfaz. Son útiles cuando no es necesario crear un tipo con nombre y solo desea un objeto que admita los métodos de interfaz, sin ningún método adicional. En el siguiente código se muestra una expresión de objeto.
let makePrintable (x: int, y: float) =
{ new IPrintable with
member this.Print() = printfn "%d %f" x y }
let x3 = makePrintable (1, 2.0)
x3.Print()
Herencia de interfaz
Una interfaz puede heredar de una o varias interfaces base.
type Interface1 =
abstract member Method1: int -> int
type Interface2 =
abstract member Method2: int -> int
type Interface3 =
inherit Interface1
inherit Interface2
abstract member Method3: int -> int
type MyClass() =
interface Interface3 with
member this.Method1(n) = 2 * n
member this.Method2(n) = n + 100
member this.Method3(n) = n / 10
Implementación de interfaces con implementaciones predeterminadas
C# admite la definición de interfaces con implementaciones predeterminadas, de la siguiente manera:
using System;
namespace CSharp
{
public interface MyDim
{
public int Z => 0;
}
}
Se pueden consumir directamente desde F#:
open CSharp
// You can implement the interface via a class
type MyType() =
member _.M() = ()
interface MyDim
let md = MyType() :> MyDim
printfn $"DIM from C#: %d{md.Z}"
// You can also implement it via an object expression
let md' = { new MyDim }
printfn $"DIM from C# but via Object Expression: %d{md'.Z}"
Puede invalidar una implementación predeterminada con override, como invalidar cualquier miembro virtual.
Los miembros de una interfaz que no tienen una implementación predeterminada deben seguir siendo implementados explícitamente.
Ahora puede implementar la misma interfaz en creaciones de instancias genéricas diferentes
F# admite la implementación de la misma interfaz en diferentes instancias genéricas como esta:
type IA<'T> =
abstract member Get : unit -> 'T
type MyClass() =
interface IA<int> with
member x.Get() = 1
interface IA<string> with
member x.Get() = "hello"
let mc = MyClass()
let iaInt = mc :> IA<int>
let iaString = mc :> IA<string>
iaInt.Get() // 1
iaString.Get() // "hello"
