Extensões de tipo

As extensões de tipo (também chamadas de aumentos) são uma família de recursos que permitem adicionar novos membros a um tipo de objeto definido anteriormente. As três características são:

• Extensões de tipo intrínsecas
• Extensões de tipo opcionais
• Métodos de extensão

Cada um pode ser usado em diferentes cenários e tem compensações diferentes.

Sintaxe

// Intrinsic and optional extensions
type typename with
    member self-identifier.member-name =
        body
    ...

// Extension methods
open System.Runtime.CompilerServices

[<Extension>]
type Extensions() =
    [<Extension>]
    static member extension-name (ty: typename, [args]) =
        body
    ...

Extensões de tipo intrínsecas

Uma extensão de tipo intrínseca é uma extensão de tipo que estende um tipo definido pelo usuário.

As extensões de tipo intrínseco devem ser definidas no mesmo arquivo e no mesmo namespace ou módulo do tipo que estão estendendo. Qualquer outra definição resultará em extensões de tipo opcionais.

As extensões de tipo intrínsecas às vezes são uma maneira mais limpa de separar a funcionalidade da declaração de tipo. O exemplo a seguir mostra como definir uma extensão de tipo intrínseco:

namespace Example

type Variant =
    | Num of int
    | Str of string
  
module Variant =
    let print v =
        match v with
        | Num n -> printf "Num %d" n
        | Str s -> printf "Str %s" s

// Add a member to Variant as an extension
type Variant with
    member x.Print() = Variant.print x

O uso de uma extensão de tipo permite separar cada um dos seguintes:

• A declaração de um Variant tipo
• Funcionalidade para imprimir a classe dependendo da Variant sua "forma"
• Uma maneira de acessar a funcionalidade de impressão com notação de estilo .de objeto

Esta é uma alternativa para definir tudo como um membro em Variant. Embora não seja uma abordagem inerentemente melhor, pode ser uma representação mais limpa da funcionalidade em algumas situações.

As extensões de tipo intrínsecas são compiladas como membros do tipo que aumentam e aparecem no tipo quando o tipo é examinado por reflexão.

Extensões de tipo opcionais

Uma extensão de tipo opcional é uma extensão que aparece fora do módulo original, namespace ou assembly do tipo que está sendo estendido.

As extensões de tipo opcionais são úteis para estender um tipo que você mesmo não definiu. Por exemplo:

module Extensions

type IEnumerable<'T> with
    /// Repeat each element of the sequence n times
    member xs.RepeatElements(n: int) =
        seq {
            for x in xs do
                for _ in 1 .. n -> x
        }

Agora você pode acessar RepeatElements como se fosse um membro IEnumerable<T> , desde que o Extensions módulo esteja aberto no escopo em que você está trabalhando.

As extensões opcionais não aparecem no tipo estendido quando examinadas por reflexão. As extensões opcionais devem estar em módulos e só estão no escopo quando o módulo que contém a extensão estiver aberto ou estiver de outra forma no escopo.

Os membros de extensão opcionais são compilados para membros estáticos para os quais a instância do objeto é passada implicitamente como o primeiro parâmetro. No entanto, eles agem como se fossem membros da instância ou membros estáticos de acordo com a forma como são declarados.

Membros de extensão opcionais também não são visíveis para consumidores de C# ou Visual Basic. Eles só podem ser consumidos em outro código F#.

Limitação genérica das extensões de tipo intrínsecas e opcionais

É possível declarar uma extensão de tipo em um tipo genérico onde a variável de tipo é restrita. O requisito é que a restrição da declaração de extensão corresponda à restrição do tipo declarado.

No entanto, mesmo quando as restrições são correspondidas entre um tipo declarado e uma extensão de tipo, é possível que uma restrição seja inferida pelo corpo de um membro estendido que impõe um requisito diferente no parâmetro type do que o tipo declarado. Por exemplo:

open System.Collections.Generic

// NOT POSSIBLE AND FAILS TO COMPILE!
//
// The member 'Sum' has a different requirement on 'T than the type IEnumerable<'T>
type IEnumerable<'T> with
    member this.Sum() = Seq.sum this

Não há nenhuma maneira de fazer esse código funcionar com uma extensão de tipo opcional:

• Como está, o Sum membro tem uma restrição diferente em 'T (static member get_Zero e static member (+)) do que a extensão de tipo define.
• Modificar a extensão de tipo para ter a mesma restrição que Sum não corresponderá mais à restrição definida no IEnumerable<'T>.
• Alterar member this.Sum para member inline this.Sum dará um erro de que as restrições de tipo são incompatíveis.

O que se deseja são métodos estáticos que "flutuam no espaço" e podem ser apresentados como se estivessem estendendo um tipo. É aqui que os métodos de extensão se tornam necessários.

Métodos de extensão

Finalmente, os métodos de extensão (às vezes chamados de "membros de extensão de estilo C#") podem ser declarados em F# como um método de membro estático em uma classe.

Os métodos de extensão são úteis para quando você deseja definir extensões em um tipo genérico que restringirá a variável de tipo. Por exemplo:

namespace Extensions

open System.Collections.Generic
open System.Runtime.CompilerServices

[<Extension>]
type IEnumerableExtensions =
    [<Extension>]
    static member inline Sum(xs: IEnumerable<'T>) = Seq.sum xs

Quando usado, esse código fará com Sum que pareça que está definido em IEnumerable<T>, desde que Extensions tenha sido aberto ou esteja no escopo.

Para que a extensão esteja disponível para VB.NET código, é necessário um extra ExtensionAttribute no nível de montagem:

module AssemblyInfo
open System.Runtime.CompilerServices
[<assembly:Extension>]
do ()

Outras observações

As extensões de tipo também têm os seguintes atributos:

• Qualquer tipo que possa ser acessado pode ser estendido.
• Extensões de tipo intrínsecas e opcionais podem definir qualquer tipo de membro, não apenas métodos. Assim, propriedades de extensão também são possíveis, por exemplo.
• O self-identifier token na sintaxe representa a instância do tipo que está sendo invocado, assim como os membros comuns.
• Os membros estendidos podem ser estáticos ou membros de instância.
• As variáveis de tipo em uma extensão de tipo devem corresponder às restrições do tipo declarado.

As seguintes limitações também existem para extensões de tipo:

• As extensões de tipo não suportam métodos virtuais ou abstratos.
• As extensões de tipo não suportam métodos de substituição como aumentos.
• As extensões de tipo não suportam parâmetros de tipo resolvidos estaticamente.
• As extensões de tipo opcionais não suportam construtores como aumentos.
• As extensões de tipo não podem ser definidas em abreviaturas de tipo.
• As extensões de tipo não são válidas para byref<'T> (embora possam ser declaradas).
• As extensões de tipo não são válidas para atributos (embora possam ser declaradas).
• Você pode definir extensões que sobrecarregam outros métodos com o mesmo nome, mas o compilador F# dá preferência a métodos sem extensão se houver uma chamada ambígua.

Finalmente, se existirem várias extensões de tipo intrínsecas para um tipo, todos os membros devem ser exclusivos. Para extensões de tipo opcionais, membros em extensões de tipo diferentes para o mesmo tipo podem ter os mesmos nomes. Os erros de ambiguidade ocorrem somente se o código do cliente abrir dois escopos diferentes que definem os mesmos nomes de membros.

Consulte também

• Referência da linguagem F#
• Membros