Partage via

Déclarations d’importation : mot clé open

  • Article

Une déclaration d’importation spécifie un module ou un espace de noms dont vous pouvez référencer les éléments sans utiliser le nom complet.

Syntaxe

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

Notes

Quand vous référencez du code en utilisant chaque fois l’espace de noms complet ou le chemin du module, le code peut devenir difficile à écrire, à lire et à gérer. À la place, vous pouvez utiliser le mot clé open pour les modules et espaces de noms fréquemment utilisés afin que, quand vous référencez un membre de ce module ou espace de noms, vous puissiez utiliser la forme abrégée du nom au lieu du nom complet. Ce mot clé est similaire à using en C#, using namespace en Visual C++ et Imports en Visual Basic.

Le module ou l’espace de noms fourni doit être dans le même projet, ou dans un projet ou un assembly référencé. Si ce n’est pas le cas, vous pouvez ajouter une référence au projet ou utiliser l’option de ligne de commande -reference (ou son abréviation, -r). Pour plus d’informations, consultez l’article Options du compilateur.

La déclaration d’importation rend les noms disponibles dans le code qui suit la déclaration, jusqu’à la fin de l’espace de noms, du module ou du fichier englobant.

Quand vous utilisez plusieurs déclarations d’importation, elles doivent être sur des lignes distinctes.

Le code suivant montre l’utilisation du mot clé open pour simplifier le code.

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

Le compilateur F# n’émet pas d’erreur ou d’avertissement en cas d’ambiguïtés quand le même nom se produit dans plusieurs modules ou espaces de noms ouverts. En cas d’ambiguïtés, F# donne la préférence au dernier module ou espace de noms ouvert. Par exemple, dans le code suivant, empty signifie Seq.empty, même si empty se trouve dans les modules List et Seq.

open List
open Seq
printfn %"{empty}"

Par conséquent, faites attention quand vous ouvrez des modules ou des espaces de noms comme List ou Seq qui contiennent des membres avec des noms identiques. Utilisez plutôt les noms qualifiés. Vous devez éviter que le code dépende de l’ordre des déclarations d’importation.

Déclarations de type ouvert

F# prend en charge open sur un type de la façon suivante :

open type System.Math
PI

Cela expose tous les champs et membres statiques accessibles sur le type.

Vous pouvez également utiliser open pour des types enregistrement et union discriminée définis en F# pour exposer des membres statiques. Dans le cas d’unions discriminées, vous pouvez également exposer des cas d’union. Cela peut être utile pour accéder à des cas d’union dans un type déclaré à l’intérieur d’un module que vous ne voulez peut-être pas ouvrir, par exemple :

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

Ouvrir à partir du chemin d’accès racine uniquement avec le spécificateur global

Modules imbriqués comme

module A =
    module B =
        ...

peut être ouvert via

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

Pour ouvrir uniquement des modules ou des espaces de noms complets, préfixez-les avec le spécificateur global :

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

Espaces de noms ouverts par défaut

Certains espaces de noms sont si souvent utilisés dans le code F# qu’ils sont ouverts implicitement sans déclaration d’importation explicite. Le tableau suivant montre les espaces de noms qui sont ouverts par défaut.

Espace de noms Description
FSharp.Core Contient des définitions de type F# de base pour les types intégrés comme int et float.
FSharp.Core.Operators Contient des opérations arithmétiques de base comme + et *.
FSharp.Collections Contient des classes de collections immuables comme List et Array.
FSharp.Control Contient des types pour les constructions de contrôle comme l’évaluation différée et les expressions asynchrones.
FSharp.Text Contient des fonctions pour les E/S mises en forme, comme la fonction printf.

Attribut AutoOpen

Vous pouvez appliquer l’attribut AutoOpen à un assembly si vous voulez ouvrir automatiquement un espace de noms ou un module quand l’assembly est référencé. Vous pouvez également appliquer l’attribut AutoOpen à un module pour ouvrir automatiquement ce module quand le module ou l’espace de noms parent est ouvert. Pour plus d’informations, consultez AutoOpenAttribute.

Attribut RequireQualifiedAccess

Certains modules, enregistrements ou types d’union peuvent spécifier l’attribut RequireQualifiedAccess. Quand vous référencez des éléments de ces modules, enregistrements ou unions, vous devez utiliser un nom qualifié, que vous ajoutiez ou non une déclaration d’importation. Si vous utilisez cet attribut de manière stratégique sur des types qui définissent des noms couramment utilisés, vous évitez les collisions de noms et rendez le code plus résilient aux changements dans les bibliothèques. Pour plus d’informations, consultez RequireQualifiedAccessAttribute.

Voir aussi