Interfaces (F#)

Interfaces especificar conjuntos de membros relacionados que implementam a outras classes.

// Interface declaration:
[ attributes ]
type 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.member1 argument-list = method-body1
   member self-identifier.member2 argument-list = method-body2

// Implementing, by using an object expression:
[ attributes ]
let class-name (argument-list) =
   { new interface-name with
       member self-identifier.member1 argument-list = method-body1
       member self-identifier.member2 argument-list = method-body2
       [ base-interface-definitions ]
   }
   member-list

Comentários

Declarações de interface são semelhantes às declarações de classe, exceto que não há membros são implementados. Em vez disso, todos os membros são abstratos, conforme indicado pela palavra-chave abstract. Você não fornecer um corpo de método para métodos abstratos. No entanto, você pode fornecer uma implementação padrão, incluindo também uma definição de separado do membro como um método em conjunto com o default palavra-chave. Fazer isso é equivalente à criação de um método virtual na classe base em outros.NET idiomas. Um método virtual pode ser substituído nas classes que implementam a interface.

Há duas maneiras de implementar interfaces: usando expressões de objeto e usando tipos de classe. Em ambos os casos, a expressão de tipo ou objeto de classe fornece corpos de métodos abstratos da interface. Implementações são específicas para cada tipo que implementa a interface. Portanto, a métodos de interface em diferentes tipos podem ser diferentes entre si.

As palavras-chave interface e end, que marca o início e no final da definição, são opcionais, quando você usa uma sintaxe simples. Se você não usar essas palavras-chave, o compilador tenta deduzir se o tipo é uma classe ou uma interface, analisando as construções que você usar. Se você define um membro ou usa outra sintaxe de classe, o tipo é interpretado como uma classe.

A.NET, estilo de codificação é começar a todas as interfaces com uma letra maiúscula I.

Implementar Interfaces usando os tipos de classe

Você pode implementar uma ou mais interfaces em um tipo de classe usando o interface palavra-chave, o nome da interface e o with palavra-chave, seguido as definições de membro de interface, conforme mostrado no código a seguir.

type IPrintable =
   abstract member Print : unit -> unit

type SomeClass1(x: int, y: float) =
   interface IPrintable with
      member this.Print() = printfn "%d %f" x y

Implementações de interface são herdadas, portanto, quaisquer classes derivadas não precisarão reimplementá-los.

Chamar os métodos de Interface

Os métodos de interface podem ser chamados apenas por meio da interface, e não através de qualquer objeto do tipo que implementa a interface. Assim, você pode ter de elevação para o tipo de interface usando o :> operador ou a upcast o operador para chamar esses métodos.

Para chamar o método de interface quando você tem um objeto do tipo SomeClass, você deve elevação do objeto para o tipo de interface, conforme mostrado no código a seguir.

let x1 = new SomeClass1(1, 2.0)
(x1 :> IPrintable).Print()

Uma alternativa é declarar um método no objeto que upcasts e chama o método de interface, como no exemplo a seguir.

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

Implementar Interfaces usando expressões de objeto

Expressões de objeto fornecem uma forma abreviada para implementar uma interface. Eles são úteis quando você não precisa criar um tipo nomeado e quiser somente que um objeto que suporta os métodos de interface, sem quaisquer métodos adicionais. Uma expressão de objeto é ilustrada no código a seguir.

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

Herança da interface

Interfaces podem herdar de uma ou mais interfaces de 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

Consulte também

Referência

Expressões de objeto (F#)

Classes (F#)

Outros recursos

Referência de linguagem do F#

Histórico de alterações