Referenzzellen (F#)

Referenzzellen sind Speicherorte, die Ihnen ermöglichen, änderbare Werte mit Verweissemantik zu erstellen.

ref expression

Hinweise

Sie verwenden den Operator ref vor einem Wert, um eine neue Referenzzelle zu erstellen, die den Wert kapselt. Anschließend können Sie den zugrunde liegenden Wert ändern, da er änderbar ist.

Eine Referenzzelle enthält einen tatsächlichen Wert, sie ist nicht lediglich eine Adresse. Wenn Sie mit dem Operator ref eine Referenzzelle erstellen, erstellen Sie eine Kopie des zugrunde liegenden Werts als gekapselten änderbaren Wert.

Mit dem Operator ! (Bang) können Sie eine Referenzzelle dereferenzieren.

Im folgenden Codebeispiel werden die Deklaration und Verwendung von Referenzzellen veranschaulicht.

// Declare a reference.
let refVar = ref 6

// Change the value referred to by the reference.
refVar := 50

// Dereference by using the ! operator.
printfn "%d" !refVar

Die Ausgabe lautet 50.

Referenzzellen sind Instanzen des generischen Ref-Datensatztyps, der wie folgt deklariert wird.

type Ref<'a> =
    { mutable contents: 'a }

Der Typ 'a ref ist ein Synonym für Ref<'a>. Der Compiler und IntelliSense in der IDE zeigen erstere Version für diesen Typ an, jedoch ist letztere Version die zugrunde liegende Definition.

Mit dem Operator ref wird eine neue Referenzzelle erstellt. Der folgende Code ist die Deklaration des Operators ref.

let ref x = { contents = x }

Die folgende Tabelle enthält die Funktionen, die für die Referenzzelle verfügbar sind.

Es gibt mehrere Möglichkeiten, auf den zugrunde liegenden Wert zuzugreifen. Der vom Dereferenzierungsoperator (!) zurückgegebene Wert ist kein zuweisbarer Wert. Wenn Sie den zugrunde liegenden Wert ändern, müssen Sie daher stattdessen den Zuweisungsoperator (:=) verwenden.

Sowohl die Value-Eigenschaft als auch das contents-Feld sind zuweisbare Werte. Daher können Sie diese verwenden, um auf den zugrunde liegenden Wert zuzugreifen oder diesen zu ändern, wie im folgenden Code gezeigt.

let xRef : int ref = ref 10

printfn "%d" (xRef.Value)
printfn "%d" (xRef.contents)

xRef.Value <- 11
printfn "%d" (xRef.Value)
xRef.contents <- 12
printfn "%d" (xRef.contents)

Die Ausgabe lautet wie folgt.

10
10
11
12

Das Feld contents wird für die Kompatibilität mit anderen Versionen von ML bereitgestellt und gibt während der Kompilierung eine Warnung aus. Verwenden Sie die --mlcompatibility-Compileroption, um die Warnung zu deaktivieren. Weitere Informationen finden Sie unter Compileroptionen (F#).

Beispiel

Im folgenden Code wird die Verwendung von Referenzzellen beim Übergeben von Parametern veranschaulicht. Der Incrementor-Typ verfügt über die Methode Increment, die einen Parameter akzeptiert, der im Parametertyp byref enthält. byref im Parametertyp gibt an, dass Aufrufer eine Referenzzelle oder die Adresse einer typischen Variablen des angegebenen Typs übergeben müssen, in diesem Fall int. Im restlichen Code wird veranschaulicht, wie Increment mit beiden dieser Typen von Argumenten aufgerufen wird, und es wird die Verwendung des Operators ref für eine Variable zum Erstellen einer Referenzzelle (ref myDelta1) gezeigt. Anschließend wird die Verwendung des address-of-Operators (&) zum Generieren eines entsprechenden Arguments veranschaulicht. Schließlich wird erneut die Increment-Methode mithilfe einer Referenzzelle aufgerufen, die mit einer let-Bindung deklariert wird. Die letzte Codezeile veranschaulicht die Verwendung des Operators ! zum Dereferenzieren der Referenzzelle für den Druck.

type Incrementor(delta) =
    member this.Increment(i : int byref) =
        i <- i + delta

let incrementor = new Incrementor(1)
let mutable myDelta1 = 10
incrementor.Increment(ref myDelta1)
// Prints 10:
printfn "%d" myDelta1  

let mutable myDelta2 = 10
incrementor.Increment(&myDelta2)
// Prints 11:
printfn "%d" myDelta2 

let refInt = ref 10
incrementor.Increment(refInt)
// Prints 11:
printfn "%d" !refInt

Weitere Informationen zum Übergeben als Verweis finden Sie unter Parameter und Argumente (F#).

Referenzzellen oderÄnderbare Variablen

Referenzzellen und änderbare Variablen können oft in den gleichen Situationen verwendet werden. Es gibt jedoch einige Situationen, in denen änderbare Variablen nicht verwendet werden können und Sie stattdessen eine Referenzzelle verwenden müssen. Im Allgemeinen sollten Sie vorzugsweise änderbare Variablen verwenden, wenn sie vom Compiler akzeptiert werden. In Ausdrücken, die Abschlüsse generieren, meldet der Compiler jedoch, dass Sie keine änderbaren Variablen verwenden dürfen. Abschlüsse sind lokale Funktionen, die von bestimmten F#-Ausdrücken, z. B. Lambda-Ausdrücken, Sequenzausdrücken, Berechnungsausdrücken und Curry-Funktionen, die partiell angewendete Argumente verwenden, generiert werden. Die von diesen Ausdrücken generierten Abschlüsse werden für die spätere Auswertung gespeichert. Dieser Vorgang ist nicht mit änderbaren Variablen kompatibel. Daher müssen Sie Referenzzellen verwenden, wenn Sie in einem solchen Ausdruck einen änderbaren Zustand benötigen. Weitere Informationen zu Abschlüssen finden Sie unter Abschlüsse (F#).

Im folgenden Codebeispiel wird das Szenario veranschaulicht, in dem Sie eine Referenzzelle verwenden müssen.

// Print all the lines read in from the console.
let PrintLines1() =
    let mutable finished = false
    while not finished do
        match System.Console.ReadLine() with
        | null -> finished <- true
        | s -> printfn "line is: %s" s


// Attempt to wrap the printing loop into a 
// sequence expression to delay the computation.
let PrintLines2() =
    seq {
        let mutable finished = false
        // Compiler error:
        while not finished do  
            match System.Console.ReadLine() with
            | null -> finished <- true
            | s -> yield s
    }

// You must use a reference cell instead.
let PrintLines3() =
    seq {
        let finished = ref false
        while not !finished do
            match System.Console.ReadLine() with
            | null -> finished := true
            | s -> yield s
    }

Im vorherigen Code ist die Referenzzelle finished im lokalen Zustand eingeschlossen, das heißt, im Abschluss enthaltene Variablen werden vollständig innerhalb des Ausdrucks, in diesem Fall ein Sequenzausdruck, erstellt und verwendet. Betrachten Sie den Fall, wenn die Variablen nicht lokal sind. Abschlüsse können auch auf den nicht lokalen Zustand zugreifen, jedoch werden in diesem Fall die Variablen nach Wert kopiert und gespeichert. Dieser Vorgang wird als Wertsemantik bezeichnet. Dies bedeutet, dass die Werte zum Zeitpunkt der Kopie gespeichert werden, und spätere Änderungen an den Variablen werden nicht wiedergegeben. Wenn Sie die Änderungen nicht lokaler Variablen nachverfolgen möchten, d. h., wenn Sie einen Abschluss benötigen, der mithilfe von Verweissemantik mit dem nicht lokalen Zustand interagiert, müssen Sie eine Referenzzelle verwenden.

In den folgenden Codebeispielen wird die Verwendung von Referenzzellen in Abschlüssen veranschaulicht. In diesem Fall resultiert der Abschluss aus der partiellen Anwendung von Funktionsargumenten.

// The following code demonstrates the use of reference
// cells to enable partially applied arguments to be changed
// by later code.

let increment1 delta number = number + delta

let mutable myMutableIncrement = 10

// Closures created by partial application and literals.
let incrementBy1 = increment1 1
let incrementBy2 = increment1 2

// Partial application of one argument from a mutable variable.
let incrementMutable = increment1 myMutableIncrement

myMutableIncrement <- 12

// This line prints 110.
printfn "%d" (incrementMutable 100)

let myRefIncrement = ref 10

// Partial application of one argument, dereferenced
// from a reference cell.
let incrementRef = increment1 !myRefIncrement

myRefIncrement := 12

// This line also prints 110.
printfn "%d" (incrementRef 100)

// Reset the value of the reference cell.
myRefIncrement := 10

// New increment function takes a reference cell.
let increment2 delta number = number + !delta

// Partial application of one argument, passing a reference cell
// without dereferencing first.
let incrementRef2 = increment2 myRefIncrement

myRefIncrement := 12

// This line prints 112.
printfn "%d" (incrementRef2 100)

Siehe auch

Referenz

Symbol- und Operatorenreferenz (F#)

Konzepte

Parameter und Argumente (F#)

Weitere Ressourcen

F#-Sprachreferenz