Compartir a través de

Control de acceso

El control de acceso hace referencia a declarar qué clientes pueden usar determinados elementos de programa, como tipos, métodos y funciones.

Conceptos básicos del control de acceso

En F#, los especificadores publicde control de acceso , internaly private se pueden aplicar a módulos, tipos, métodos, definiciones de valor, funciones, propiedades y campos explícitos.

  • public indica que todos los autores de llamada pueden acceder a la entidad.

  • internal indica que solo se puede acceder a la entidad desde el mismo ensamblado.

  • private indica que solo se puede tener acceso a la entidad desde el tipo o módulo envolvente.

Nota:

El especificador protected de acceso no se usa en F#, aunque es aceptable si usa tipos creados en lenguajes que admiten protected el acceso. Por lo tanto, si invalida un método protegido, el método permanece accesible solo dentro de la clase y sus descendientes.

El especificador de acceso se coloca delante del nombre de la entidad.

Si no se usa ningún especificador de acceso, el valor predeterminado es public, excepto los let enlaces de un tipo , que siempre private son para el tipo .

Las firmas de F# proporcionan otro mecanismo para controlar el acceso a los elementos del programa F#. Las firmas no son necesarias para el control de acceso. Para obtener más información, consulte Firmas.

Reglas para el control de acceso

El control de acceso está sujeto a las siguientes reglas:

  • Declaraciones de herencia (es decir, el uso de inherit para especificar una clase base para una clase), declaraciones de interfaz (es decir, especificar que una clase implementa una interfaz) y los miembros abstractos siempre tienen la misma accesibilidad que el tipo envolvente. Por lo tanto, no se puede usar un especificador de control de acceso en estas construcciones.

  • La accesibilidad para casos individuales en una unión discriminada viene determinada por la accesibilidad de la propia unión discriminada. Es decir, un caso de unión determinado no es menos accesible que la propia unión.

  • La accesibilidad de los campos individuales de un tipo de registro viene determinada por la accesibilidad del propio registro. Es decir, una etiqueta de registro determinada no es menos accesible que el propio registro.

Ejemplo

En el código siguiente se muestra el uso de especificadores de control de acceso. Hay dos archivos en el proyecto y Module1.fsModule2.fs. Cada archivo es implícitamente un módulo. Por lo tanto, hay dos módulos y Module1Module2. Un tipo privado y un tipo interno se definen en Module1. No se puede tener acceso al tipo privado desde Module2, pero el tipo interno puede.

// Module1.fs

module Module1

// This type is not usable outside of this file
type private MyPrivateType() =
   // x is private since this is an internal let binding
   let x = 5
   // X is private and does not appear in the QuickInfo window
   // when viewing this type in the Visual Studio editor
   member private this.X() = 10
   member this.Z() = x * 100

type internal MyInternalType() =
   let x = 5
   member private this.X() = 10
   member this.Z() = x * 100

// Top-level let bindings are public by default,
// so "private" and "internal" are needed here since a
// value cannot be more accessible than its type.
let private myPrivateObj = new MyPrivateType()
let internal myInternalObj = new MyInternalType()

// let bindings at the top level are public by default,
// so result1 and result2 are public.
let result1 = myPrivateObj.Z
let result2 = myInternalObj.Z

El código siguiente prueba la accesibilidad de los tipos creados en Module1.fs.

// Module2.fs
module Module2

open Module1

// The following line is an error because private means
// that it cannot be accessed from another file or module
// let private myPrivateObj = new MyPrivateType()
let internal myInternalObj = new MyInternalType()

let result = myInternalObj.Z

Consulte también

  • Last updated on