Partager via

Déclarations d’importation : mot open clé

Une déclaration d’importation spécifie un module ou un espace de noms dont vous pouvez faire référence sans utiliser de nom complet.

Syntaxe

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

Remarques

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

Le module ou l’espace de noms fourni doit se trouver 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 -reference de ligne de commande (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.

Lorsque vous utilisez plusieurs déclarations d’importation, elles doivent apparaître sur des lignes distinctes.

Le code suivant montre l’utilisation du mot clé pour simplifier le open 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 lorsque des ambiguïtés se produisent lorsque le même nom se produit dans plusieurs modules ou espaces de noms ouverts. Lorsque des ambiguïtés se produisent, F# donne la préférence au module ou espace de noms plus récemment ouvert. Par exemple, dans le code suivant, empty signifie Seq.empty, même si empty se trouve à la fois dans les modules et Seq les List modules.

open List
open Seq
printfn %"{empty}"

Par conséquent, faites attention lorsque vous ouvrez des modules ou des espaces de noms tels que List ou Seq qui contiennent des membres qui ont des noms identiques ; envisagez plutôt d’utiliser les noms qualifiés. Vous devez éviter toute situation dans laquelle le code dépend de l’ordre des déclarations d’importation.

Déclarations de type ouvrir

F# prend en charge open un type comme suit :

open type System.Math
PI

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

Vous pouvez également open définir des types d’enregistrements définis par F#et des types d’union discriminatoires pour exposer des membres statiques. Dans le cas de syndicats discriminatoires, vous pouvez également exposer les affaires syndicales. Cela peut être utile pour accéder aux cas d’union dans un type déclaré à l’intérieur d’un module que vous ne souhaiterez peut-être pas ouvrir, comme suit :

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 global spécificateur

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 global spécificateur :

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 fréquemment utilisés dans le code F# qu’ils sont ouverts implicitement sans avoir besoin d’une déclaration d’importation explicite. Le tableau suivant montre les espaces de noms ouverts par défaut.

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

Attribut AutoOpen

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

RequireQualifiedAccess, attribut

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

Voir aussi

  • Last updated on