Interaktive Programmierung mit F#Interactive programming with F#

F# Interactive (dotnet fsi) dient zum interaktiven Ausführen von F#-Code in der Konsole oder zum Ausführen von F#-Skripts.F# Interactive (dotnet fsi) is used to run F# code interactively at the console, or to execute F# scripts. Dies bedeutet, dass F# Interactive eine REPL (Read, Evaluate, Print Loop = Lesen-Auswerten-Drucken-Schleife) für F# ausführt.In other words, F# interactive executes a REPL (Read, Evaluate, Print Loop) for the F# language.

Führen Sie dotnet fsi aus, um F# Interactive in der Konsole auszuführen.To run F# Interactive from the console, run dotnet fsi. Sie finden dotnet fsi in einem beliebigen .NET SDK.You will find dotnet fsi in any .NET SDK.

Informationen zu verfügbaren Befehlszeilenoptionen finden Sie unter F# Interactive-Optionen.For information about available command-line options, see F# Interactive Options.

Direktes Ausführen von Code in F# InteractiveExecuting code directly in F# Interactive

Da F# Interactive eine REPL (read-eval-print-Loop) ist, können Sie Code interaktiv in dieser Loop ausführen.Because F# Interactive is a REPL (read-eval-print loop), you can execute code interactively in it. Nachfolgend finden Sie ein Beispiel für eine interaktive Sitzung, nachdem dotnet fsi über die Befehlszeile ausgeführt wurde:Here is an example of an interactive session after executing dotnet fsi from the command line:

Microsoft (R) F# Interactive version 11.0.0.0 for F# 5.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

> let square x = x *  x;;
val square : x:int -> int

> square 12;;
val it : int = 144

> printfn "Hello, FSI!"
- ;;
Hello, FSI!
val it : unit = ()

Beachten Sie zwei wichtige Aspekte:You'll notice two main things:

  1. Der gesamte Code muss zur Auswertung mit einem doppelten Semikolon (;;) beendet werden.All code must be terminated with a double semicolon (;;) to be evaluated
  2. Der Code wird ausgewertet und in einem it-Wert gespeichert.Code is evaluated and stored in an it value. Sie können interaktiv auf it verweisen.You can reference it interactively.

F# Interactive unterstützt zudem mehrzeilige Eingaben.F# Interactive also supports multi-line input. Sie müssen Ihre Eingaben lediglich mit einem doppelten Semikolon (;;) beenden.You just need to terminate your submission with a double semicolon (;;). Sehen Sie sich den folgenden Ausschnitt an, der in F# Interactive eingefügt und ausgewertet wurde:Consider the following snippet that has been pasted into and evaluated by F# Interactive:

> let getOddSquares xs =
-     xs
-     |> List.filter (fun x -> x % 2 <> 0)
-     |> List.map (fun x -> x * x)
-
- printfn "%A" (getOddSquares [1..10]);;
[1; 9; 25; 49; 81]
val getOddSquares : xs:int list -> int list
val it : unit = ()

>

Die Formatierung des Codes wird beibehalten, und die Eingabe wird durch ein doppeltes Semikolon (;;) beendet.The code's formatting is preserved, and there is a double semicolon (;;) terminating the input. Anschließend wurde der Code von F# Interactive ausgewertet, und die Ergebnisse wurden ausgegeben.F# Interactive then evaluated the code and printed the results!

Skripterstellung mit F#Scripting with F#

Die interaktive Auswertung von Code in F# Interactive ist eine hervorragende Lernmethode. Sie werden jedoch rasch feststellen, dass diese Vorgehensweise weniger produktiv ist als das Schreiben von Code in einem normalen Editor.Evaluating code interactively in F# Interactive can be a great learning tool, but you'll quickly find that it's not as productive as writing code in a normal editor. Um die reguläre Codebearbeitung zu unterstützen, können Sie F#-Skripts schreiben.To support normal code editing, you can write F# scripts.

Für Skripts wird die Dateierweiterung .fsx verwendet.Scripts use the file extension .fsx. Statt Quellcode zu kompilieren und später die kompilierte Assembly auszuführen, können Sie einfach dotnet fsi ausführen und den Dateinamen des Skripts mit dem F#-Quellcode angeben. F# Interactive liest dann den Code und führt ihn in Echtzeit aus.Instead of compiling source code and then later running the compiled assembly, you can just run dotnet fsi and specify the filename of the script of F# source code, and F# interactive reads the code and executes it in real time. Sehen wir uns z. B. das folgende Skript Script.fsx an:For example, consider the following script called Script.fsx:

let getOddSquares xs =
    xs
    |> List.filter (fun x -> x % 2 <> 0)
    |> List.map (fun x -> x * x)

printfn "%A" (getOddSquares [1..10])

Wenn diese Datei auf Ihrem Computer erstellt wird, können Sie sie mit dotnet fsi ausführen. Die Ausgabe wird unmittelbar in Ihrem Terminalfenster angezeigt:When this file is created in your machine, you can run it with dotnet fsi and see the output directly in your terminal window:

dotnet fsi Script.fsx
[1; 9; 25; 49; 81]

Das Erstellen von F#-Skripts wird nativ in Visual Studio, Visual Studio Code und Visual Studio für Mac unterstützt.F# scripting is natively supported in Visual Studio, Visual Studio Code, and Visual Studio for Mac.

Verweisen auf Pakete in F# InteractiveReferencing packages in F# Interactive

Hinweis

Das Paketverwaltungssystem ist erweiterbar. Lesen Sie mehr über andere Erweiterungen.Package management system is extensible, read more about other extensions.

F# Interactive unterstützt Verweise auf NuGet-Pakete mit der #r "nuget:"-Syntax und einer optionalen Version:F# Interactive supports referencing NuGet packages with the #r "nuget:" syntax and an optional version:

#r "nuget: Newtonsoft.Json"
open Newtonsoft.Json

let data = {| Name = "Don Syme"; Occupation = "F# Creator" |}
JsonConvert.SerializeObject(data)

Wenn keine Version angegeben wird, wird das höchste verfügbare Paket verwendet, bei dem es sich nicht um eine Vorschauversion handelt.If a version is not specified, the highest available non-preview package is taken. Um auf eine bestimmte Version zu verweisen, fügen Sie die Version mit Komma ein.To reference a specific version, introduce the version via a comma. Dies kann nützlich sein, um auf eine Vorschauversion eines Pakets zu verweisen.This can be handy when referencing a preview version of a package. Sehen Sie sich z. B. das folgende Skript an, bei dem eine Vorschauversion von DiffSharp verwendet wird:For example, consider this script using a preview version of DiffSharp:

#r "nuget: DiffSharp-lite, 1.0.0-preview-328097867"
open DiffSharp

// A 1D tensor
let t1 = dsharp.tensor [ 0.0 .. 0.2 .. 1.0 ]

// A 2x2 tensor
let t2 = dsharp.tensor [ [ 0; 1 ]; [ 2; 2 ] ]

// Define a scalar-to-scalar function
let f (x: Tensor) = sin (sqrt x)

printfn $"{f (dsharp.tensor 1.2)}"

Angeben einer PaketquelleSpecifying a package source

Sie können eine Paketquelle auch mit dem #i-Befehl angeben.You can also specify a package source with the #i command. Im folgenden Beispiel wird eine Remotequelle und eine lokale Quelle angegeben:The following example specifies a remote and a local source:

#i "nuget:https://my-remote-package-source/index.json
#i @"path-to-my-local-source"

Dadurch wird die Auflösungs-Engine unter der Haube ebenfalls dazu angeleitet, die Remotequellen und/oder lokalen Quellen miteinzubeziehen, die einem Skript hinzugefügt wurden.This will tell the resolution engine under the covers to also take into account the remote and/or local sources added to a script.

Sie können beliebig viele Paketverweise in einem Skript angeben.You can specify as many package references as you like in a script.

Hinweis

Es gibt zurzeit eine Einschränkung für Skripts, die Frameworkverweise verwenden (z. B. Microsoft.NET.Sdk.Web oder Microsoft.NET.Sdk.WindowsDesktop).There's currently a limitation for scripts that use framework references (e.g.Microsoft.NET.Sdk.Web or Microsoft.NET.Sdk.WindowsDesktop). Pakete wie Saturn, Giraffe und WinForms sind nicht verfügbar.Packages like Saturn, Giraffe, WinForms are not available. Dies wird in Issue #9417 nachverfolgt.This is being tracked in issue #9417.

Weitere Informationen finden Sie unter Paketverwaltungserweiterbarkeit und andere Erweiterungen.For more information, see package management extensibility and other extensions.

Verweisen auf Assemblys auf einem Datenträger mit F# InteractiveReferencing assemblies on disk with F# interactive

Wenn Sie über eine Assembly auf einem Datenträger verfügen und in einem Skript auf diese Assembly verweisen möchten, können Sie sie mit der #r-Syntax angeben.Alternatively, if you have an assembly on disk and wish to reference that in a script, you can use the #r syntax to specify an assembly. Gehen wir von folgendem Code in einem Projekt aus, der in MyAssembly.dll kompiliert wird:Consider the following code in a project compiled into MyAssembly.dll:

// MyAssembly.fs
module MyAssembly
let myFunction x y = x + 2 * y

Nach der Kompilierung können Sie in einer Datei Script.fsx wie folgt darauf verweisen:One compiled, you can reference it in a file called Script.fsx like so:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

Die Ausgabe lautet wie folgt:The output is as follows:

dotnet fsi Script.fsx
90

Sie können beliebig viele Assemblyverweise in einem Skript angeben.You can specify as many assembly references as you like in a script.

Laden anderer SkriptsLoading other scripts

Bei der Skripterstellung ist es häufig nützlich, unterschiedliche Skripts für unterschiedliche Aufgaben zu verwenden.When scripting, it can often be helpful to use different scripts for different tasks. In einigen Fällen bietet es sich an, Code aus einem Skript in einem anderen Skript wiederzuverwenden.Sometimes you may want to reuse code from on script in another. Anstatt die Skriptinhalte zu kopieren und in Ihrer Datei einzufügen, können Sie sie ganz einfach mit #load laden und auswerten.Rather than copy-pasting its contents into your file, you can simple load and evaluate it with #load.

Angenommen, Sie verfügen über die Datei Script1.fsx:Consider the following Script1.fsx:

let square x = x * x

Außerdem über die verbrauchende Datei Script2.fsx:And the consuming file, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Beachten Sie, dass die Deklaration open Script1 erforderlich ist.Note that the open Script1 declaration is required. Der Grund dafür ist, dass Konstrukte in einem F#-Skript in einem Modul der obersten Ebene kompiliert werden, das dem Namen der Skriptdatei entspricht, in dem es sich befindet.This is because constructs in an F# script are compiled into a top-level module that is the name of the script file it is in.

Sie können Script2.fsx wie folgt auswerten:You can evaluate Script2.fsx like so:

dotnet fsi Script2.fsx
144

Sie können beliebig viele #load-Anweisungen in einem Skript angeben.You can specify as many #load directives as you like in a script.

Verwenden des fsi-Objekts in F#-CodeUsing the fsi object in F# code

F#-Skripts können auf ein benutzerdefiniertes fsi-Objekt zugreifen, das die F# Interactive-Sitzung darstellt.F# scripts have access to a custom fsi object that represents the F# Interactive session. Mit diesem Objekt können Aspekte wie die Ausgabeformatierung angepasst werden.It allows you to customize things like output formatting. Darüber hinaus können Sie auf diese Weise auf Befehlszeilenargumente zugreifen.It is also how you can access command-line arguments.

Im folgenden Beispiel wird gezeigt, wie Befehlszeilenargumente abgerufen und verwendet werden:The following example shows how to get and use command-line arguments:

let args = fsi.CommandLineArgs

for arg in args do
    printfn $"{arg}"

Bei der Auswertung werden alle Argumente ausgegeben.When evaluated, it prints all arguments. Das erste Argument ist immer der Name des Skripts, das ausgewertet wird:The first argument is always the name of the script that is evaluated:

dotnet fsi Script1.fsx hello world from fsi
Script1.fsx
hello
world
from
fsi

Sie können auch mit System.Environment.GetCommandLineArgs() auf diese Argumente zugreifen.You can also use System.Environment.GetCommandLineArgs() to access the same arguments.

Referenz zu F# Interactive-AnweisungenF# Interactive directive reference

Die zuvor erwähnten Anweisungen #r und #load sind nur in F# Interactive verfügbar.The #r and #load directives seen previously are only available in F# Interactive. Eine Reihe weiterer Anweisungen sind ebenfalls nur in F# Interactive verfügbar:There are several directives only available in F# Interactive:

AnweisungDirective BeschreibungDescription
#r "nuget:..." Verweist auf ein Paket aus NuGet.References a package from NuGet
#r "assembly-name.dll" Verweist auf eine Assembly auf einem DatenträgerReferences an assembly on disk
#load "file-name.fsx" Liest eine Quelldatei, kompiliert sie und führt sie aus.Reads a source file, compiles it, and runs it.
#help Zeigt Informationen über verfügbare Anweisungen an.Displays information about available directives.
#I Gibt einen Assemblysuchpfad an (in Anführungszeichen).Specifies an assembly search path in quotation marks.
#quit Beendet eine F# Interactive-Sitzung.Terminates an F# Interactive session.
#time "on" oder #time "off"#time "on" or #time "off" Einzeln angegeben aktiviert bzw. deaktiviert #time die Anzeige von Leistungsinformationen.By itself, #time toggles whether to display performance information. Wenn "on" festgelegt ist, überwacht F# Interactive die reale Zeit, die CPU-Zeit sowie Garbage Collection-Informationen für jeden Codeabschnitt, der interpretiert und ausgeführt wird.When it is "on", F# Interactive measures real time, CPU time, and garbage collection information for each section of code that is interpreted and executed.

Wenn Sie Dateien oder Pfade in F# Interactive angeben, wird ein Zeichenfolgenliteral erwartet.When you specify files or paths in F# Interactive, a string literal is expected. Daher müssen Dateien und Pfade in Anführungszeichen stehen. Es gelten die üblichen Escapezeichen.Therefore, files and paths must be in quotation marks, and the usual escape characters apply. Sie können das Zeichen @ verwenden, damit F# Interactive eine Zeichenfolge mit einem Pfad als ausführliche Zeichenfolge interpretiert.You can use the @ character to cause F# Interactive to interpret a string that contains a path as a verbatim string. F# Interactive ignoriert in diesem Fall alle Escapezeichen.This causes F# Interactive to ignore any escape characters.

Interaktive und kompilierte PräprozessordirektivenInteractive and compiled preprocessor directives

Wenn Sie Code in F# Interactive kompilieren (unabhängig davon, ob die Ausführung interaktiv oder über ein Skript erfolgt), ist das Symbol INTERACTIVE definiert.When you compile code in F# Interactive, whether you are running interactively or running a script, the symbol INTERACTIVE is defined. Beim Kompilieren von Code im Compiler ist das Symbol COMPILED definiert.When you compile code in the compiler, the symbol COMPILED is defined. Wenn Code im Kompilierungsmodus und im interaktiven Modus unterschiedlich sein muss, können Sie mithilfe von Präprozessordirektiven für die bedingte Kompilierung bestimmen, welche Variante verwendet werden soll.Thus, if code needs to be different in compiled and interactive modes, you can use these preprocessor directives for conditional compilation to determine which to use. Beispiel:For example:

#if INTERACTIVE
// Some code that executes only in FSI
// ...
#endif

Verwenden von F# Interactive in Visual StudioUsing F# Interactive in Visual Studio

Zum Ausführen von F# Interactive über Visual Studio können Sie auf die entsprechende Symbolleistenschaltfläche F# Interactive klicken oder die Tastenkombination Strg+Alt+F verwenden.To run F# Interactive through Visual Studio, you can click the appropriate toolbar button labeled F# Interactive, or use the keys Ctrl+Alt+F. Dadurch wird das Interactive-Fenster geöffnet, ein Toolfenster, in dem eine F# Interactive-Sitzung ausgeführt wird.Doing this will open the interactive window, a tool window running an F# Interactive session. Sie können auch Code auswählen, den Sie im interaktiven Fenster ausführen möchten, und die Tastenkombination ALT+EINGABETASTE drücken.You can also select some code that you want to run in the interactive window and hit the key combination Alt+Enter. F# Interactive wird in einem Toolfenster mit der Bezeichnung F# Interactive gestartet.F# Interactive starts in a tool window labeled F# Interactive. Wenn Sie diese Tastenkombination verwenden, überprüfen Sie, ob das Editorfenster den Fokus besitzt.When you use this key combination, make sure that the editor window has the focus.

Unabhängig davon, ob Sie die Konsole oder Visual Studio verwenden, wird eine Eingabeaufforderung angezeigt, und der Interpreter erwartet Ihre Eingabe.Whether you are using the console or Visual Studio, a command prompt appears and the interpreter awaits your input. Sie können Code auf die gleiche Weise wie in einer Codedatei eingeben.You can enter code just as you would in a code file. Geben Sie zum Kompilieren und Ausführen des Codes zwei Semikolons (;;) ein, um eine oder mehrere Zeilen der Eingabe zu beenden.To compile and execute the code, enter two semicolons (;;) to terminate a line or several lines of input.

F# Interactive beginnt mit der Kompilierung des Codes, und wenn der Code erfolgreich kompiliert wurde, führt F# Interactive den Code aus und gibt die Signatur der kompilierten Typen und Werte aus.F# Interactive attempts to compile the code and, if successful, it executes the code and prints the signature of the types and values that it compiled. Wenn Fehler auftreten, gibt der Interpreter die Fehlermeldungen aus.If errors occur, the interpreter prints the error messages.

In der gleichen Sitzung eingegebener Code kann auf alle zuvor eingegebenen Konstrukte zugreifen. Daher können Sie Programme erstellen.Code entered in the same session has access to any constructs entered previously, so you can build up programs. Ein umfangreicher Puffer im Toolfenster ermöglicht es Ihnen, den Code bei Bedarf in eine Datei zu kopieren.An extensive buffer in the tool window allows you to copy the code into a file if needed.

In Visual Studio wird F# Interactive unabhängig vom Projekt ausgeführt. Daher können Sie im Projekt definierte Konstrukte nur dann in F# Interactive verwenden, wenn Sie den Code für die Funktion in das Interactive-Fenster kopieren.When run in Visual Studio, F# Interactive runs independently of your project, so, for example, you cannot use constructs defined in your project in F# Interactive unless you copy the code for the function into the interactive window.

Sie können die Befehlszeilenargumente (Optionen) von F# Interactive steuern, indem Sie die Einstellungen anpassen.You can control the F# Interactive command-line arguments (options) by adjusting the settings. Wählen Sie im Menü Extras den Eintrag Optionen aus, und erweitern Sie anschließend F#-Tools.On the Tools menu, select Options..., and then expand F# Tools. Die beiden Einstellungen, die Sie ändern können, sind die F# Interactive-Optionen und die Einstellung 64-Bit-F# Interactive, die nur relevant ist, wenn Sie F# Interactive auf einem 64-Bit-Computer ausführen.The two settings that you can change are the F# Interactive options and the 64-bit F# Interactive setting, which is relevant only if you are running F# Interactive on a 64-bit machine. Mit dieser Einstellung legen Sie fest, ob Sie die dedizierte 64-Bit-Version von fsi.exe oder aber fsianycpu.exe ausführen möchten, die anhand der Computerarchitektur ermittelt, ob sie als 32-Bit- oder 64-Bit-Prozess ausgeführt werden soll.This setting determines whether you want to run the dedicated 64-bit version of fsi.exe or fsianycpu.exe, which uses the machine architecture to determine whether to run as a 32-bit or 64-bit process.

TitelTitle BESCHREIBUNGDescription
F# Interactive-OptionenF# Interactive Options Beschreibt die Befehlszeilensyntax und Optionen für F# Interactive (fsi.exe)Describes command-line syntax and options for the F# Interactive, fsi.exe.