Control de acceso

  • Artículo

El control de acceso hace referencia a la declaración de 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 de control de acceso public, 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 llamadas pueden acceder a la entidad.

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

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

Nota

El especificador de acceso protected no se usa en F#, aunque es aceptable si usa tipos creados en lenguajes que admiten el acceso protected. 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 enlaces let de un tipo, que siempre son private para el tipo.

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 el control de acceso

La selección de canal está sujeta 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 el propio sindicato.

  • La accesibilidad para 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 siguiente código ilustra el uso de los 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 tener acceso al tipo privado desde Module2, pero sí puede hacerlo el tipo interno.

// 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 siguiente código 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