Control de acceso

  • Artículo
  • 2 minutos para leer

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

Conceptos básicos de Access Control

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

  • public indica que todos los llamadores 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 acceder a la entidad desde el tipo o módulo que lo incluye.

Nota

El especificador de acceso no se usa en F#, aunque es aceptable si usa tipos escritos en lenguajes que protected 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.

En general, el especificador se coloca delante del nombre de la entidad, excepto cuando se usa un especificador o , que aparece después del mutable inline especificador de control de acceso.

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

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

Reglas para Access Control

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

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

  • La accesibilidad de los 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

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

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

Vea también