Espacios de nombresNamespaces

Un espacio de nombres permite organizar el código en áreas de funcionalidad relacionada, ya que permite adjuntar un nombre F# a una agrupación de elementos de programa.A namespace lets you organize code into areas of related functionality by enabling you to attach a name to a grouping of F# program elements. Los espacios de nombres suelen ser elementos de nivel F# superior en los archivos.Namespaces are typically top-level elements in F# files.

SintaxisSyntax

namespace [rec] [parent-namespaces.]identifier

ComentariosRemarks

Si desea colocar el código en un espacio de nombres, la primera declaración del archivo debe declarar el espacio de nombres.If you want to put code in a namespace, the first declaration in the file must declare the namespace. El contenido de todo el archivo se convierte entonces en parte del espacio de nombres, siempre que no exista otra declaración de espacios de nombres en el archivo.The contents of the entire file then become part of the namespace, provided no other namespaces declaration exists further in the file. En ese caso, todo el código hasta la siguiente declaración de espacio de nombres se considera que está dentro del primer espacio de nombres.If that is the case, then all code up until the next namespace declaration is considered to be within the first namespace.

Los espacios de nombres no pueden contener directamente valores y funciones.Namespaces cannot directly contain values and functions. En su lugar, los valores y las funciones deben estar incluidos en los módulos y los módulos se incluyen en los espacios de nombres.Instead, values and functions must be included in modules, and modules are included in namespaces. Los espacios de nombres pueden contener tipos, módulos.Namespaces can contain types, modules.

Los comentarios de documento XML se pueden declarar sobre un espacio de nombres, pero se omiten.XML doc comments can be declared above a namespace, but they're ignored. Las directivas de compilador también se pueden declarar sobre un espacio de nombres.Compiler directives can also be declared above a namespace.

Los espacios de nombres se pueden declarar explícitamente con la palabra clave namespace o implícitamente al declarar un módulo.Namespaces can be declared explicitly with the namespace keyword, or implicitly when declaring a module. Para declarar explícitamente un espacio de nombres, use la palabra clave namespace seguida del nombre del espacio de nombres.To declare a namespace explicitly, use the namespace keyword followed by the namespace name. En el ejemplo siguiente se muestra un archivo de código que declara Widgets un espacio de nombres con un tipo y un módulo incluido en dicho espacio de nombres.The following example shows a code file that declares a namespace Widgets with a type and a module included in that namespace.

namespace Widgets

type MyWidget1 =
    member this.WidgetName = "Widget1"

module WidgetsModule =
    let widgetName = "Widget2"

Si todo el contenido del archivo está en un módulo, también puede declarar espacios de nombres implícitamente mediante la module palabra clave y proporcionando el nuevo nombre de espacio de nombres en el nombre completo del módulo.If the entire contents of the file are in one module, you can also declare namespaces implicitly by using the module keyword and providing the new namespace name in the fully qualified module name. En el ejemplo siguiente se muestra un archivo de código que declara Widgets un espacio de WidgetsModulenombres y un módulo, que contiene una función.The following example shows a code file that declares a namespace Widgets and a module WidgetsModule, which contains a function.

module Widgets.WidgetModule

let widgetFunction x y =
   printfn "%A %A" x y

El código siguiente es equivalente al código anterior, pero el módulo es una declaración de módulo local.The following code is equivalent to the preceding code, but the module is a local module declaration. En ese caso, el espacio de nombres debe aparecer en su propia línea.In that case, the namespace must appear on its own line.

namespace Widgets

module WidgetModule =

    let widgetFunction x y =
        printfn "%A %A" x y

Si se necesita más de un módulo en el mismo archivo en uno o varios espacios de nombres, debe usar las declaraciones del módulo local.If more than one module is required in the same file in one or more namespaces, you must use local module declarations. Al utilizar las declaraciones del módulo local, no se puede usar el espacio de nombres completo en las declaraciones del módulo.When you use local module declarations, you cannot use the qualified namespace in the module declarations. En el código siguiente se muestra un archivo que tiene una declaración de espacio de nombres y dos declaraciones de módulos locales.The following code shows a file that has a namespace declaration and two local module declarations. En este caso, los módulos se incluyen directamente en el espacio de nombres; no hay ningún módulo creado implícitamente que tenga el mismo nombre que el archivo.In this case, the modules are contained directly in the namespace; there is no implicitly created module that has the same name as the file. Cualquier otro código del archivo, como un do enlace, está en el espacio de nombres pero no en los módulos internos, por lo que debe calificar el miembro widgetFunction del módulo mediante el nombre del módulo.Any other code in the file, such as a do binding, is in the namespace but not in the inner modules, so you need to qualify the module member widgetFunction by using the module name.

namespace Widgets

module WidgetModule1 =
   let widgetFunction x y =
      printfn "Module1 %A %A" x y
module WidgetModule2 =
   let widgetFunction x y =
      printfn "Module2 %A %A" x y

module useWidgets =

  do
     WidgetModule1.widgetFunction 10 20
     WidgetModule2.widgetFunction 5 6

La salida de este ejemplo es la siguiente.The output of this example is as follows.

Module1 10 20
Module2 5 6

Para obtener más información, vea módulos.For more information, see Modules.

Espacios de nombres anidadosNested Namespaces

Al crear un espacio de nombres anidado, debe calificarlo por completo.When you create a nested namespace, you must fully qualify it. De lo contrario, se crea un nuevo espacio de nombres de nivel superior.Otherwise, you create a new top-level namespace. La sangría se omite en las declaraciones de espacio de nombres.Indentation is ignored in namespace declarations.

En el ejemplo siguiente se muestra cómo declarar un espacio de nombres anidado.The following example shows how to declare a nested namespace.

namespace Outer

    // Full name: Outer.MyClass
    type MyClass() =
       member this.X(x) = x + 1

// Fully qualify any nested namespaces.
namespace Outer.Inner

    // Full name: Outer.Inner.MyClass
    type MyClass() =
       member this.Prop1 = "X"

Espacios de nombres en archivos y ensambladosNamespaces in Files and Assemblies

Los espacios de nombres pueden abarcar varios archivos en un único proyecto o compilación.Namespaces can span multiple files in a single project or compilation. El término espacio de nombres de términos describe la parte de un espacio de nombres que se incluye en un archivo.The term namespace fragment describes the part of a namespace that is included in one file. Los espacios de nombres también pueden abarcar varios ensamblados.Namespaces can also span multiple assemblies. Por ejemplo, el System espacio de nombres incluye todo el .NET Framework, que abarca muchos ensamblados y contiene muchos espacios de nombres anidados.For example, the System namespace includes the whole .NET Framework, which spans many assemblies and contains many nested namespaces.

Espacio de nombres globalGlobal Namespace

El espacio de nombres global predefinido se usa para colocar nombres en el espacio de nombres de nivel superior de .net.You use the predefined namespace global to put names in the .NET top-level namespace.

namespace global

type SomeType() =
    member this.SomeMember = 0

También puede usar global para hacer referencia al espacio de nombres .NET de nivel superior, por ejemplo, para resolver conflictos de nombres con otros espacios de nombres.You can also use global to reference the top-level .NET namespace, for example, to resolve name conflicts with other namespaces.

global.System.Console.WriteLine("Hello World!")

Espacios de nombres recursivosRecursive namespaces

Los espacios de nombres también se pueden declarar como recursivos para permitir que todo el código contenido sea mutuamente recursivo.Namespaces can also be declared as recursive to allow for all contained code to be mutually recursive. Esto se hace a namespace rectravés de.This is done via namespace rec. El uso namespace rec de puede aliviar algunos problemas al no poder escribir código referencial mutuamente entre tipos y módulos.Use of namespace rec can alleviate some pains in not being able to write mutually referential code between types and modules. El siguiente es un ejemplo de esto:The following is an example of this:

namespace rec MutualReferences

type Orientation = Up | Down
type PeelState = Peeled | Unpeeled

// This exception depends on the type below.
exception DontSqueezeTheBananaException of Banana

type BananaPeel() = class end

type Banana(orientation : Orientation) =
    member val IsPeeled = false with get, set
    member val Orientation = orientation with get, set
    member val Sides: PeelState list = [ Unpeeled; Unpeeled; Unpeeled; Unpeeled] with get, set

    member self.Peel() = BananaHelpers.peel self // Note the dependency on the BananaHelpers module.
    member self.SqueezeJuiceOut() = raise (DontSqueezeTheBananaException self) // This member depends on the exception above.

module BananaHelpers =
    let peel (b: Banana) =
        let flip (banana: Banana) =
            match banana.Orientation with
            | Up -> 
                banana.Orientation <- Down
                banana
            | Down -> banana

        let peelSides (banana: Banana) =
            banana.Sides
            |> List.map (function
                         | Unpeeled -> Peeled
                         | Peeled -> Peeled)

        match b.Orientation with
        | Up ->   b |> flip |> peelSides
        | Down -> b |> peelSides

Tenga en cuenta que DontSqueezeTheBananaException la excepción y Banana la clase hacen referencia entre sí.Note that the exception DontSqueezeTheBananaException and the class Banana both refer to each other. Además, el módulo BananaHelpers y la clase Banana también hacen referencia entre sí.Additionally, the module BananaHelpers and the class Banana also refer to each other. No sería posible expresar en F# si quitó la rec palabra clave del MutualReferences espacio de nombres.This wouldn't be possible to express in F# if you removed the rec keyword from the MutualReferences namespace.

Esta característica también está disponible para los módulosde nivel superior.This feature is also available for top-level Modules.

Vea tambiénSee also