Zugriffssteuerung (F#)
Mit Zugriffssteuerung wird angegeben, welche Clients bestimmte Programmelemente, z. B. Typen, Methoden und Funktionen, verwenden können.
Grundlagen der Zugriffssteuerung
In F# können die Zugriffssteuerungsspezifizierer public, internal und private auf Module, Typen, Methoden, Wertdefinitionen, Funktionen, Eigenschaften, und explizite Felder angewendet werden.
public gibt an, dass alle Aufrufer auf die Entität zugreifen können.
internal gibt an, dass nur aus derselben Assembly auf die Entität zugegriffen werden kann.
private gibt an, dass nur aus dem einschließenden Typ oder Modul auf die Entität zugegriffen werden kann.
Tipp
Der Zugriffsspezifizierer protected wird in F# nicht verwendet. Seine Verwendung ist jedoch zulässig, wenn Sie Typen verwenden, die in Sprachen erstellt wurden, die protected-Zugriff unterstützen. Wenn Sie eine geschützte Methode überschreiben, kann daher nur innerhalb der Klasse und ihrer untergeordneten Klasse weiterhin auf die Methode zugegriffen werden.
Im Allgemeinen wird der Spezifizierer vor dem Namen der Entität angegeben, mit Ausnahme der Spezifizierer mutable und inline, die nach dem Zugriffssteuerungsspezifizierer angegeben werden.
Wenn kein Zugriffsspezifizierer verwendet wird, ist der Standardzugriff public, außer für let-Bindungen in einem Typ, die für den Typ immer private sind.
Signaturen bieten in F# einen weiteren Mechanismus zum Steuern des Zugriffs auf F#-Programmelemente. Signaturen sind für die Zugriffssteuerung nicht erforderlich. Weitere Informationen finden Sie unter Signaturen (F#).
Regeln für die Zugriffssteuerung
Für die Zugriffssteuerung gelten die folgenden Regeln:
Vererbungsdeklarationen, (das Angeben einer Basisklasse für eine Klasse mit dem inherit-Schlüsselwort), Schnittstellendeklarationen (Angeben, dass eine Klasse eine Schnittstelle implementiert) und abstrakte Member verfügen immer über den gleichen Zugriff wie der einschließende Typ. Daher kann in diesen Konstrukten kein Zugriffssteuerungsspezifizierer verwendet werden.
Die einzelnen Fälle in einer Unterscheidungs-Union dürfen nicht über eigene Zugriffssteuerungsmodifizierer verfügen, die vom Union-Typ abweichen.
Einzelne Felder eines Datensatztyps können nicht über eigene, vom Datensatztyp getrennte Zugriffssteuerungsmodifizierer verfügen.
Beispiel
Im folgenden Code wird die Verwendung von Zugriffssteuerungsspezifizierern veranschaulicht. Das Projekt enthält die beiden Dateien Module1.fs und Module2.fs. Jede Datei ist implizit ein Modul. Daher sind die beiden Module Module1 und Module2 vorhanden. In Module1 sind ein privater Typ und ein interner Typ definiert. Aus Module2 kann nicht auf den privaten Typ zugegriffen werden, jedoch auf den internen Typ.
// 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
Im folgenden Code wird der Zugriff der in Module1.fs erstellten Typen getestet.
// 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