Controle de acesso (F#)
Controle de acesso refere-se a declarar que os clientes podem usar determinados elementos do programa, como, por exemplo, tipos, métodos e funções.
Noções básicas de controle de acesso
No F#, especificadores de controle, o acesso public, internal, e private pode ser aplicado a módulos, tipos, métodos, definições de valor, funções, propriedades e campos explícitos.
publicindica que a entidade pode ser acessada por todos os chamadores.
internalindica que a entidade possa ser acessada somente a partir do mesmo assembly.
privateindica que a entidade pode ser acessada somente a partir do tipo de delimitador ou módulo.
.gif "Observação") Observação |
|---|
O especificador de acesso protected não é usado no F#, embora seja aceitável se você estiver usando tipos criados em idiomas que dão suporte a protected acesso.Portanto, se você substituir um método protegido, o método permanece acessível somente dentro da classe e seus descendentes. |
Em geral, o especificador é colocado na frente do nome da entidade, exceto quando uma mutable ou inline especificador é usado, que aparecem após o especificador de controle de acesso.
Não se for usado nenhum especificador de acesso, o padrão é public, exceto para let ligações em um tipo, que são sempre private para o tipo.
Assinaturas no F# fornecem outro mecanismo para controlar o acesso aos elementos do programa F#.As assinaturas não são necessárias para controle de acesso.Para obter mais informações, consulte Assinaturas (F#).
Regras para o controle de acesso
Controle de acesso está sujeita às seguintes regras:
Declarações de herança (ou seja, o uso de inherit para especificar uma classe base para uma classe), declarações (isto é, especificando que uma classe implementa uma interface) de interface e abstrair os membros sempre têm a mesma acessibilidade como o tipo de delimitador.Portanto, um especificador de controle de acesso não é possível usar essas construções.
Ocorrências individuais em uma união discriminada não podem ter seus próprios modificadores de controle de acesso separados do tipo de união.
Campos individuais de um tipo de registro não podem ter seus próprios modificadores de controle de acesso separados do tipo de registro.
Exemplo
O código a seguir ilustra o uso dos especificadores de controle de acesso.Existem dois arquivos no projeto, Module1.fs e Module2.fs.Cada arquivo é implicitamente um módulo.Portanto, há dois módulos, Module1 e Module2.Um tipo particular e um tipo interno são definidos no Module1.O tipo particular não pode ser acessado a partir 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