Condividi tramite

Dichiarazioni di importazione: parola chiave open

  • Articolo

Una dichiarazione di importazione specifica un modulo o uno spazio dei nomi ai cui elementi è possibile fare riferimento senza usare un nome completo.

Sintassi

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

Osservazioni:

Fare riferimento al codice usando lo spazio dei nomi completo o il percorso del modulo ogni volta che è possibile creare codice difficile da scrivere, leggere e gestire. È invece possibile usare la parola chiave open per i moduli e gli spazi dei nomi usati di frequente in modo che quando si fa riferimento a un membro di tale modulo o spazio dei nomi, è possibile usare la forma breve del nome anziché il nome completo. Questa parola chiave è simile alla parola chiave using in C#, using namespace in Visual C++ e Imports in Visual Basic.

Il modulo o lo spazio dei nomi specificato deve trovarsi nello stesso progetto o in un progetto o un assembly a cui si fa riferimento. In caso contrario, è possibile aggiungere un riferimento al progetto oppure usare l'opzione della riga di comando -reference (o la relativa abbreviazione, -r). Per altre informazioni, vedere Opzioni del compilatore.

La dichiarazione di importazione rende disponibili i nomi nel codice che segue la dichiarazione, fino alla fine dello spazio dei nomi, del modulo o del file.

Quando si usano più dichiarazioni di importazione, devono essere visualizzate in righe separate.

Il codice seguente illustra l'uso della parola chiave open per semplificare il codice.

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

Il compilatore F# non genera un errore o un avviso quando si verificano ambiguità, quando si verifica lo stesso nome in più moduli o spazi dei nomi aperti. Quando si verificano ambiguità, F# dà la preferenza al modulo o allo spazio dei nomi aperto più di recente. Ad esempio, nel codice seguente, empty significa Seq.empty, anche se empty si trova sia nei moduli List che Seq.

open List
open Seq
printfn %"{empty}"

Prestare quindi attenzione quando si aprono moduli o spazi dei nomi, ad esempio List o Seq che contengono membri con nomi identici; prendere invece in considerazione l'uso dei nomi qualificati. È consigliabile evitare qualsiasi situazione in cui il codice dipende dall'ordine delle dichiarazioni di importazione.

Dichiarazioni di tipo aperto

F# supporta open in un tipo simile al seguente:

open type System.Math
PI

Verranno esposti tutti i campi statici e i membri accessibili nel tipo.

È anche possibile opendefinire in F# tipi di record e tipi di unione discriminati per esporre membri statici. Nel caso di unioni discriminate, è anche possibile esporre i casi di unione. Ciò può essere utile per accedere ai casi di unione in un tipo dichiarato all'interno di un modulo che potrebbe non essere necessario aprire, come illustrato di seguito:

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

Aprire dal percorso radice solo con l’identificatore global

Moduli annidati come

module A =
    module B =
        ...

può essere aperto tramite

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

Per aprire solo moduli completi o spazi dei nomi prefissi con l'identificatore global:

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

Spazi dei nomi aperti per impostazione predefinita

Alcuni spazi dei nomi vengono usati così frequentemente nel codice F# che vengono aperti in modo implicito senza la necessità di una dichiarazione di importazione esplicita. Nella tabella seguente sono illustrati gli spazi dei nomi aperti per impostazione predefinita.

Spazio dei nomi Descrizione
FSharp.Core Contiene definizioni di tipo F# di base per i tipi predefiniti, ad esempio int e float.
FSharp.Core.Operators Contiene operazioni aritmetiche di base, ad esempio + e *.
FSharp.Collections Contiene classi di raccolta non modificabili, ad esempio List e Array.
FSharp.Control Contiene tipi per costrutti di controllo, ad esempio la valutazione differita ed espressioni asincrone.
FSharp.Text Contiene funzioni per operazioni di IO formattate, ad esempio la funzione printf.

Attributo AutoOpen

È possibile applicare l'attributo AutoOpen a un assembly se si desidera aprire automaticamente uno spazio dei nomi o un modulo quando si fa riferimento all'assembly. È anche possibile applicare l'attributo AutoOpen a un modulo per aprire automaticamente tale modulo all'apertura del modulo padre o dello spazio dei nomi. Per altre informazioni, vedere AutoOpenAttribute.

Attributo RequireQualifiedAccess

Alcuni moduli, record o tipi di unione possono specificare l'attributo RequireQualifiedAccess. Quando si fa riferimento a elementi di tali moduli, record o unioni, è necessario usare un nome completo indipendentemente dal fatto che si includa una dichiarazione di importazione. Se si usa questo attributo in modo strategico sui tipi che definiscono nomi di uso comune, è possibile evitare conflitti di nomi e rendere il codice più resiliente alle modifiche nelle librerie. Per ulteriori informazioni, vedere RequireQualifiedAccessAttribute.

Vedi anche