Dela via

Åtkomstkontroll

  • Artikel

Åtkomstkontroll avser att deklarera vilka klienter som kan använda vissa programelement, till exempel typer, metoder och funktioner.

Grunderna i åtkomstkontroll

I F#kan åtkomstkontrollsspecificerarna public, internaloch private tillämpas på moduler, typer, metoder, värdedefinitioner, funktioner, egenskaper och explicita fält.

  • public anger att entiteten kan nås av alla anropare.

  • internal anger att entiteten endast kan nås från samma sammansättning.

  • private anger att entiteten endast kan nås från den omslutande typen eller modulen.

Kommentar

Åtkomstspecificeraren protected används inte i F#, även om det är acceptabelt om du använder typer som har skapats på språk som stöder protected åtkomst. Om du åsidosätter en skyddad metod förblir din metod därför endast tillgänglig i klassen och dess underordnade objekt.

Åtkomstspecificeraren placeras framför namnet på entiteten.

Om ingen åtkomstspecificerare används är publicstandardvärdet , förutom let bindningar i en typ, som alltid private är av typen .

Signaturer i F# ger en annan mekanism för att styra åtkomsten till F#-programelement. Signaturer krävs inte för åtkomstkontroll. Mer information finns i Signaturer.

Regler för åtkomstkontroll

Åtkomstkontroll omfattas av följande regler:

  • Arvsdeklarationer (dvs. användning av inherit för att ange en basklass för en klass), gränssnittsdeklarationer (dvs. att ange att en klass implementerar ett gränssnitt) och abstrakta medlemmar har alltid samma tillgänglighet som den omslutande typen. Därför kan inte en åtkomstkontrollsspecificerare användas på dessa konstruktioner.

  • Tillgängligheten för enskilda fall i en diskriminerad union bestäms av tillgängligheten för själva den diskriminerade unionen. Det innebär att ett visst fackligt fall inte är mindre tillgängligt än själva facket.

  • Tillgängligheten för enskilda fält av en posttyp bestäms av tillgängligheten för själva posten. En viss etikett är alltså inte mindre tillgänglig än själva posten.

Exempel

Följande kod illustrerar användningen av åtkomstkontrollsspecificerare. Det finns två filer i projektet och Module1.fsModule2.fs. Varje fil är implicit en modul. Därför finns det två moduler och Module1Module2. En privat typ och en intern typ definieras i Module1. Det går inte att komma åt den privata typen från Module2, men den interna typen kan.

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

Följande kod testar tillgängligheten för de typer som skapas i 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

Se även