Dela via

Importdeklarationer: Nyckelordet open

  • Artikel

En importdeklaration anger en modul eller ett namnområde vars element du kan referera till utan att använda ett fullständigt kvalificerat namn.

Syntax

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

Kommentarer

Att referera till kod med hjälp av den fullständigt kvalificerade namnrymden eller modulsökvägen varje gång kan skapa kod som är svår att skriva, läsa och underhålla. I stället kan du använda nyckelordet open för moduler och namnområden som används ofta, så att du kan använda den korta formen av namnet i stället för det fullständigt kvalificerade namnet när du refererar till en medlem i modulen eller namnområdet. Det här nyckelordet liknar nyckelordet using i C#, using namespace i Visual C++och Imports i Visual Basic.

Den angivna modulen eller namnområdet måste finnas i samma projekt eller i ett refererat projekt eller en sammansättning. Om det inte är det kan du lägga till en referens till projektet eller använda kommandoradsalternativet -reference (eller dess förkortning, -r). Mer information finns i Kompilatoralternativ.

Importdeklarationen gör namnen tillgängliga i koden som följer deklarationen, fram till slutet av den omslutande namnrymden, modulen eller filen.

När du använder flera importdeklarationer bör de visas på separata rader.

Följande kod visar användningen av nyckelordet open för att förenkla koden.

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

F#-kompilatorn genererar inte ett fel eller en varning när tvetydigheter uppstår när samma namn inträffar i mer än en öppen modul eller namnrymd. När tvetydigheter uppstår föredrar F# den nyligen öppnade modulen eller namnområdet. I följande kod empty betyder Seq.emptytill exempel , även om empty den finns i både modulerna List och Seq .

open List
open Seq
printfn %"{empty}"

Var därför försiktig när du öppnar moduler eller namnområden som List eller Seq som innehåller medlemmar som har identiska namn. Överväg i stället att använda de kvalificerade namnen. Du bör undvika situationer där koden är beroende av ordningen på importdeklarationerna.

Öppna typdeklarationer

F# har stöd open för en typ så här:

open type System.Math
PI

Då exponeras alla tillgängliga statiska fält och medlemmar för typen.

Du kan också open F#-definierade post - och diskriminerade unionstyper för att exponera statiska medlemmar. När det gäller diskriminerade fackföreningar kan du också avslöja fackliga ärenden. Detta kan vara användbart för åtkomst till fackliga ärenden i en typ som deklareras i en modul som du kanske inte vill öppna, så här:

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

Öppna endast från rotsökvägen med global specificeraren

Kapslade moduler som

module A =
    module B =
        ...

kan öppnas via

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

Om du bara vill öppna fullständigt kvalificerade moduler eller namnområden prefixar du dem med global specificeraren:

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

Namnområden som är öppna som standard

Vissa namnområden används så ofta i F#-kod att de öppnas implicit utan att en explicit importdeklaration behövs. I följande tabell visas de namnområden som är öppna som standard.

Namnområde beskrivning
FSharp.Core Innehåller grundläggande F#-typdefinitioner för inbyggda typer som int och float.
FSharp.Core.Operators Innehåller grundläggande aritmetiska åtgärder som + och *.
FSharp.Collections Innehåller oföränderliga samlingsklasser som List och Array.
FSharp.Control Innehåller typer för kontrollkonstruktioner som lat utvärdering och asynkrona uttryck.
FSharp.Text Innehåller funktioner för formaterad I/O, till exempel printf funktionen.

AutoÖppna attribut

Du kan använda AutoOpen attributet för en sammansättning om du vill öppna ett namnområde eller en modul automatiskt när sammansättningen refereras. Du kan också använda AutoOpen attributet för en modul för att automatiskt öppna modulen när den överordnade modulen eller namnområdet öppnas. Mer information finns i AutoOpenAttribute.

RequireQualifiedAccess-attribut

Vissa moduler, poster eller unionstyper kan ange attributet RequireQualifiedAccess . När du refererar till elementen i dessa moduler, poster eller fackföreningar måste du använda ett kvalificerat namn oavsett om du inkluderar en importdeklaration. Om du använder det här attributet strategiskt för typer som definierar vanliga namn kan du undvika namnkollisioner och därmed göra koden mer motståndskraftig mot ändringar i bibliotek. Mer information finns i RequireQualifiedAccessAttribute.

Se även