Compartilhar via

Importar declarações: a open palavra-chave

Uma declaração de importação especifica um módulo ou namespace cujos elementos você pode referenciar sem usar um nome totalmente qualificado.

Sintaxe

open module-or-namespace-name
open type type-name

Observações

Fazer referência ao código usando o namespace totalmente qualificado ou o caminho do módulo sempre pode criar um código difícil de gravar, ler e manter. Em vez disso, você pode usar a open palavra-chave para módulos e namespaces usados com frequência para que, ao fazer referência a um membro desse módulo ou namespace, você possa usar a forma curta do nome em vez do nome totalmente qualificado. Essa palavra-chave é semelhante à using palavra-chave em C#, using namespace no Visual C++e Imports no Visual Basic.

O módulo ou namespace fornecido deve estar no mesmo projeto ou em um projeto ou assembly referenciado. Se não estiver, você poderá adicionar uma referência ao projeto ou usar a opção -reference de linha de comando (ou sua abreviação -r). Para obter mais informações, consulte Opções do Compilador.

A declaração de importação disponibiliza os nomes no código que segue a declaração até o final do namespace, módulo ou arquivo delimitando.

Quando você usa várias declarações de importação, elas devem aparecer em linhas separadas.

O código a seguir mostra o uso da palavra-chave para simplificar o open código.

// Without the import declaration, you must include the full
// path to .NET Framework namespaces such as System.IO.
let writeToFile1 filename (text: string) =
  let stream1 = new System.IO.FileStream(filename, System.IO.FileMode.Create)
  let writer = new System.IO.StreamWriter(stream1)
  writer.WriteLine(text)

// Open a .NET Framework namespace.
open System.IO

// Now you do not have to include the full paths.
let writeToFile2 filename (text: string) =
  let stream1 = new FileStream(filename, FileMode.Create)
  let writer = new StreamWriter(stream1)
  writer.WriteLine(text)

writeToFile2 "file1.txt" "Testing..."

O compilador F# não emite um erro ou aviso quando ocorrem ambiguidades quando o mesmo nome ocorre em mais de um módulo ou namespace aberto. Quando ocorrem ambiguidades, f# dá preferência ao módulo ou namespace aberto mais recentemente. Por exemplo, no código a seguir, empty significa Seq.empty, mesmo empty que esteja localizado nos módulos e Seq nos List módulos.

open List
open Seq
printfn %"{empty}"

Portanto, tenha cuidado ao abrir módulos ou namespaces, como List ou Seq que contenham membros com nomes idênticos; em vez disso, considere usar os nomes qualificados. Você deve evitar qualquer situação em que o código dependa da ordem das declarações de importação.

Abrir declarações de tipo

O F# dá open suporte a um tipo como esse:

open type System.Math
PI

Isso exporá todos os campos estáticos e membros estáticos acessíveis no tipo.

Você também open pode registrar ediscriminar tipos de união definidos por F#para expor membros estáticos. No caso de sindicatos discriminados, você também pode expor os casos sindicais. Isso pode ser útil para acessar casos de união em um tipo declarado dentro de um módulo que talvez você não queira abrir, da seguinte maneira:

module M =
    type DU = A | B | C

    let someOtherFunction x = x + 1

// Open only the type inside the module
open type M.DU

printfn "%A" A

Abrir do caminho raiz somente com global o especificador

Módulos aninhados como

module A =
    module B =
        ...

pode ser aberto por meio de

open A // opens A
open B // opens A.B

Para abrir apenas módulos totalmente qualificados ou namespaces, prefixe-os com o global especificador:

open global.A   // works
open global.B   // this now fails
open global.A.B // works

Namespaces abertos por padrão

Alguns namespaces são usados com tanta frequência no código F# que são abertos implicitamente sem a necessidade de uma declaração de importação explícita. A tabela a seguir mostra os namespaces abertos por padrão.

Namespace Descrição
FSharp.Core Contém definições básicas de tipo F# para tipos internos, como int e float.
FSharp.Core.Operators Contém operações aritméticas básicas, como + e *.
FSharp.Collections Contém classes de coleção imutáveis, como List e Array.
FSharp.Control Contém tipos para constructos de controle, como avaliação lenta e expressões assíncronas.
FSharp.Text Contém funções para E/S formatada, como a printf função.

Atributo AutoOpen

Você pode aplicar o AutoOpen atributo a um assembly se quiser abrir automaticamente um namespace ou módulo quando o assembly for referenciado. Você também pode aplicar o AutoOpen atributo a um módulo para abrir automaticamente esse módulo quando o módulo pai ou o namespace for aberto. Para obter mais informações, consulte AutoOpenAttribute.

Atributo RequireQualifiedAccess

Alguns módulos, registros ou tipos de união podem especificar o RequireQualifiedAccess atributo. Ao fazer referência a elementos desses módulos, registros ou uniões, você deve usar um nome qualificado, independentemente de incluir uma declaração de importação. Se você usar esse atributo estrategicamente em tipos que definem nomes comumente usados, você ajuda a evitar colisões de nome e, assim, tornar o código mais resiliente às alterações nas bibliotecas. Para obter mais informações, consulte RequireQualifiedAccessAttribute.

Consulte também

  • Last updated on