Partilhar via

Controlo de Acesso

Controle de acesso refere-se à declaração de quais clientes podem usar determinados elementos do programa, como tipos, métodos e funções.

Noções básicas de controle de acesso

Em F#, os especificadores de controle de acesso , internale private podem ser aplicados a módulos, tipos, métodos, definições de publicvalor, funções, propriedades e campos explícitos.

  • public indica que a entidade pode ser acessada por todos os chamadores.

  • internal Indica que a entidade pode ser acessada somente do mesmo assembly.

  • private indica que a entidade só pode ser acedida a partir do tipo ou módulo anexo.

Observação

O especificador protected de acesso não é usado em F#, embora seja aceitável se você estiver usando tipos criados em idiomas que oferecem suporte ao protected acesso. Portanto, se você substituir um método protegido, seu método permanecerá acessível somente dentro da classe e seus descendentes.

O especificador de acesso é colocado na frente do nome da entidade.

Se nenhum especificador de acesso for usado, o padrão será public, exceto para let associações em um tipo, que são sempre private para o tipo.

As assinaturas em F# fornecem outro mecanismo para controlar o acesso aos elementos do programa F#. As assinaturas não são necessárias para o controle de acesso. Para obter mais informações, consulte Assinaturas.

Regras para Controlo de Acessos

O controlo de acesso está sujeito às seguintes regras:

  • As declarações de herança (ou seja, o uso de para especificar uma classe base para uma classe), declarações de interface (ou seja, especificar que uma classe implementa uma interface) e membros abstratos sempre têm a mesma acessibilidade que o tipo de inherit inclusão. Portanto, um especificador de controle de acesso não pode ser usado nessas construções.

  • A acessibilidade para casos individuais num sindicato discriminado é determinada pela acessibilidade do próprio sindicato discriminado. Ou seja, um determinado caso sindical não é menos acessível do que o próprio sindicato.

  • A acessibilidade para campos individuais de um tipo de registo é determinada pela acessibilidade do próprio registo. Ou seja, uma determinada gravadora não é menos acessível do que o próprio disco.

Exemplo

O código a seguir ilustra o uso de especificadores de controle de acesso. Há dois arquivos no projeto Module1.fs e Module2.fs. Cada ficheiro é implicitamente um módulo. Portanto, existem dois módulos, Module1 e Module2. Um tipo privado e um tipo interno são definidos em Module1. O tipo privado não pode ser acessado a partir de Module2, mas o tipo interno pode.

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

O código a seguir testa a acessibilidade dos tipos criados no 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

Ver também

  • Last updated on