F#-Entwicklerreferenz zu Azure FunctionsAzure Functions F# Developer Reference

F# für Azure Functions ist eine Lösung, mit der Sie ganz einfach kleinere Codeelemente (Funktionen) in der Cloud ausführen können.F# for Azure Functions is a solution for easily running small pieces of code, or "functions," in the cloud. Daten fließen über Funktionsargumente in Ihre F#-Funktion.Data flows into your F# function via function arguments. Argumentnamen werden in function.jsonangegeben, und es gibt vordefinierte Namen für den Zugriff auf Elemente wie die Funktionsprotokollierung und Abbruchtoken.Argument names are specified in function.json, and there are predefined names for accessing things like the function logger and cancellation tokens.

Wichtig

F#-Skripts („.fsx“) werden nur von Version 1.x der Azure Functions-Runtime unterstützt.F# script (.fsx) is only supported by version 1.x of the Azure Functions runtime. Wenn Sie F# mit der Runtimeversion 2.x verwenden möchten, müssen Sie ein vorkompiliertes F#-Klassenbibliotheksprojekt („.fs“) verwenden.If you want to use F# with the version 2.x runtime, you must use a precompiled F# class library project (.fs). Sie erstellen, verwalten und veröffentlichen ein F#-Klassenbibliotheksprojekt mithilfe von Visual Studio wie ein C#-Klassenbibliotheksprojekt.You create, manage, and publish an F# class library project using Visual Studio as you would a C# class library project. Weitere Informationen zu den Versionen von Functions finden Sie unter Übersicht über die Runtimeversionen von Azure Functions.For more information about Functions versions, see Azure Functions runtime versions overview.

In diesem Artikel wird davon ausgegangen, dass Sie bereits die Entwicklerreferenz zu Azure Functionsgelesen haben.This article assumes that you've already read the Azure Functions developer reference.

Funktionsweise von „.fsx“How .fsx works

Eine .fsx -Datei ist ein F#-Skript.An .fsx file is an F# script. Sie können sich dies wie ein F#-Projekt vorstellen, das in einer einzelnen Datei enthalten ist.It can be thought of as an F# project that's contained in a single file. Die Datei enthält sowohl den Code für Ihr Programm (in diesem Fall Ihre Azure-Funktion) als auch Direktiven zum Verwalten von Abhängigkeiten.The file contains both the code for your program (in this case, your Azure Function) and directives for managing dependencies.

Bei Verwendung der Endung .fsx für eine Azure-Funktion werden die üblicherweise erforderlichen Assemblys automatisch für Sie eingebunden, sodass Sie sich auf die Funktion konzentrieren können und sich nicht mit Codebausteinen beschäftigen müssen.When you use an .fsx for an Azure Function, commonly required assemblies are automatically included for you, allowing you to focus on the function rather than "boilerplate" code.

OrdnerstrukturFolder structure

Die Ordnerstruktur für ein F#-Skriptprojekt sieht wie folgt aus:The folder structure for an F# script project looks like the following:

FunctionsProject
 | - MyFirstFunction
 | | - run.fsx
 | | - function.json
 | | - function.proj
 | - MySecondFunction
 | | - run.fsx
 | | - function.json
 | | - function.proj
 | - host.json
 | - extensions.csproj
 | - bin

Sie können die freigegebene Datei host.json zum Konfigurieren der Funktions-App verwenden.There's a shared host.json file that can be used to configure the function app. Jede Funktion verfügt über eine eigene Codedatei (FSX-Datei) sowie über eine eigene Bindungskonfigurationsdatei (function.json).Each function has its own code file (.fsx) and binding configuration file (function.json).

Die in Version 2.x der Functions-Runtime erforderlichen Bindungserweiterungen sind in der Datei extensions.csproj definiert, die eigentlichen Bibliotheksdateien befinden sich im Ordner bin.The binding extensions required in version 2.x of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. Wenn Sie lokal entwickeln, müssen Sie Bindungserweiterungen registrieren.When developing locally, you must register binding extensions. Wenn Sie Funktionen im Azure-Portal entwickeln, wird diese Registrierung für Sie ausgeführt.When developing functions in the Azure portal, this registration is done for you.

Binden an ArgumenteBinding to arguments

Jede Bindung unterstützt eine Gruppe von Argumenten. Dies ist in der Entwicklerreferenz zu Triggern und Bindungen in Azure Functions ausführlich beschrieben.Each binding supports some set of arguments, as detailed in the Azure Functions triggers and bindings developer reference. Eine Argumentbindung, die von einem Blobtrigger beispielsweise unterstützt wird, ist ein POCO-Element. Dies kann mit einem F#-Eintrag ausgedrückt werden.For example, one of the argument bindings a blob trigger supports is a POCO, which can be expressed using an F# record. Beispiel:For example:

type Item = { Id: string }

let Run(blob: string, output: byref<Item>) =
    let item = { Id = "Some ID" }
    output <- item

Für Ihre F#-Azure-Funktion wird mindestens ein Argument verwendet.Your F# Azure Function will take one or more arguments. Wenn wir von Azure Functions-Argumenten sprechen, geht es um Argumente für die Eingabe und Argumente für die Ausgabe.When we talk about Azure Functions arguments, we refer to input arguments and output arguments. Bei einem Eingabeargument geht es genau um das, was der Name vermuten lässt: die Eingabe in Ihre F#-Azure-Funktion.An input argument is exactly what it sounds like: input to your F# Azure Function. Bei einem Ausgabeargument geht es um änderbare Daten oder ein byref<>-Argument, das als Möglichkeit zum Zurückgeben von Daten aus Ihrer Funktion dient.An output argument is mutable data or a byref<> argument that serves as a way to pass data back out of your function.

Im obigen Beispiel ist blob ein Eingabeargument und output ein Ausgabeargument.In the example above, blob is an input argument, and output is an output argument. Beachten Sie, dass wir byref<> für output verwendet haben (das Hinzufügen der Anmerkung [<Out>] ist nicht erforderlich).Notice that we used byref<> for output (there's no need to add the [<Out>] annotation). Mit dem Typ byref<> kann Ihre Funktion ändern, auf welchen Eintrag oder welches Objekt das Argument verweist.Using a byref<> type allows your function to change which record or object the argument refers to.

Wenn ein F#-Eintrag als Eingabetyp verwendet wird, muss die Eintragsdefinition mit [<CLIMutable>] gekennzeichnet werden. So kann das Azure Functions-Framework die Felder richtig festlegen, bevor der Eintrag an Ihre Funktion übergeben wird.When an F# record is used as an input type, the record definition must be marked with [<CLIMutable>] in order to allow the Azure Functions framework to set the fields appropriately before passing the record to your function. Im Hintergrund generiert [<CLIMutable>] Setter für die Eintragseigenschaften.Under the hood, [<CLIMutable>] generates setters for the record properties. Beispiel:For example:

[<CLIMutable>]
type TestObject =
    { SenderName : string
      Greeting : string }

let Run(req: TestObject, log: ILogger) =
    { req with Greeting = sprintf "Hello, %s" req.SenderName }

Eine F#-Klasse kann auch für in- und out-Argumente verwendet werden.An F# class can also be used for both in and out arguments. Für eine Klasse benötigen Eigenschaften normalerweise „Getter“ und „Setter“.For a class, properties will usually need getters and setters. Beispiel:For example:

type Item() =
    member val Id = "" with get,set
    member val Text = "" with get,set

let Run(input: string, item: byref<Item>) =
    let result = Item(Id = input, Text = "Hello from F#!")
    item <- result

ProtokollierungLogging

Zum Protokollieren der Ausgabe in Ihren Streamingprotokollen in F# sollte Ihre Funktion ein Argument vom Typ ILogger verwenden.To log output to your streaming logs in F#, your function should take an argument of type ILogger. Der Einheitlichkeit halber empfehlen wir Ihnen, diesem Argument den Namen logzu geben.For consistency, we recommend this argument is named log. Beispiel:For example:

let Run(blob: string, output: byref<string>, log: ILogger) =
    log.LogInformation(sprintf "F# Azure Function processed a blob: %s" blob)
    output <- input

AsyncAsync

Der async-Workflow kann verwendet werden, aber vom Ergebnis muss ein Task-Element zurückgegeben werden.The async workflow can be used, but the result needs to return a Task. Hierfür können Sie Async.StartAsTaskverwenden, z.B.:This can be done with Async.StartAsTask, for example:

let Run(req: HttpRequestMessage) =
    async {
        return new HttpResponseMessage(HttpStatusCode.OK)
    } |> Async.StartAsTask

AbbruchtokenCancellation Token

Wenn Ihre Funktion das ordnungsgemäße Herunterfahren durchführen soll, können Sie sie mit dem Argument CancellationToken versehen.If your function needs to handle shutdown gracefully, you can give it a CancellationToken argument. Dies können Sie mit asynckombinieren, z.B.:This can be combined with async, for example:

let Run(req: HttpRequestMessage, token: CancellationToken)
    let f = async {
        do! Async.Sleep(10)
        return new HttpResponseMessage(HttpStatusCode.OK)
    }
    Async.StartAsTask(f, token)

Importieren von NamespacesImporting namespaces

Namespaces können auf die übliche Weise geöffnet werden:Namespaces can be opened in the usual way:

open System.Net
open System.Threading.Tasks
open Microsoft.Extensions.Logging

let Run(req: HttpRequestMessage, log: ILogger) =
    ...

Die folgenden Namespaces werden automatisch geöffnet:The following namespaces are automatically opened:

  • System
  • System.Collections.Generic
  • System.IO
  • System.Linq
  • System.Net.Http
  • System.Threading.Tasks
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host.Microsoft.Azure.WebJobs.Host.

Verweise auf externe AssemblysReferencing External Assemblies

Auf ähnliche Weise werden Framework-Assemblyverweise mit der #r "AssemblyName"-Direktive hinzugefügt.Similarly, framework assembly references can be added with the #r "AssemblyName" directive.

#r "System.Web.Http"

open System.Net
open System.Net.Http
open System.Threading.Tasks
open Microsoft.Extensions.Logging

let Run(req: HttpRequestMessage, log: ILogger) =
    ...

Die folgenden Assemblys werden automatisch von der Azure Functions-Hostumgebung hinzugefügt:The following assemblies are automatically added by the Azure Functions hosting environment:

  • mscorlib,mscorlib,
  • System
  • System.Core
  • System.Xml
  • System.Net.Http
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host
  • Microsoft.Azure.WebJobs.Extensions
  • System.Web.Http
  • System.Net.Http.Formatting.System.Net.Http.Formatting.

Darüber hinaus stehen die folgenden besonderen Assemblys zur Verfügung, auf die über den einfachen Namen verwiesen werden kann (beispielsweise #r "AssemblyName"):In addition, the following assemblies are special cased and may be referenced by simplename (e.g. #r "AssemblyName"):

  • Newtonsoft.Json
  • Microsoft.WindowsAzure.Storage
  • Microsoft.ServiceBus
  • Microsoft.AspNet.WebHooks.Receivers
  • Microsoft.AspNEt.WebHooks.Common(Fixierte Verbindung) festgelegt ist(Fixierte Verbindung) festgelegt ist.Microsoft.AspNEt.WebHooks.Common.

Wenn Sie auf eine private Assembly verweisen müssen, können Sie die Assemblydatei in einen bin-Ordner relativ zu Ihrer Funktion hochladen und anhand des Dateinamens darauf verweisen (Beispiel: #r "MyAssembly.dll").If you need to reference a private assembly, you can upload the assembly file into a bin folder relative to your function and reference it by using the file name (e.g. #r "MyAssembly.dll"). Informationen zum Hochladen von Dateien in Ihren Funktionenordner finden Sie im folgenden Abschnitt zur Paketverwaltung.For information on how to upload files to your function folder, see the following section on package management.

Editor-EinleitungEditor Prelude

Ein Editor, der F#-Compilerdienste unterstützt, besitzt keine Informationen zu den Namespaces und Assemblys, die in Azure Functions automatisch enthalten sind.An editor that supports F# Compiler Services will not be aware of the namespaces and assemblies that Azure Functions automatically includes. Daher kann es nützlich sein, eine Einleitung einzufügen, die dem Editor als Unterstützung beim Suchen nach den von Ihnen verwendeten Assemblys und beim expliziten Öffnen von Namespaces dient.As such, it can be useful to include a prelude that helps the editor find the assemblies you are using, and to explicitly open namespaces. Beispiel:For example:

#if !COMPILED
#I "../../bin/Binaries/WebJobs.Script.Host"
#r "Microsoft.Azure.WebJobs.Host.dll"
#endif

open System
open Microsoft.Azure.WebJobs.Host
open Microsoft.Extensions.Logging

let Run(blob: string, output: byref<string>, log: ILogger) =
    ...

Wenn Ihr Code von Azure Functions ausgeführt wird, wird die Quelle mit der Definition COMPILED verarbeitet, und die Editor-Einleitung wird ignoriert.When Azure Functions executes your code, it processes the source with COMPILED defined, so the editor prelude will be ignored.

PaketverwaltungPackage management

Um NuGet-Pakete in einer F#-Funktion zu verwenden, fügen Sie dem Funktionsordner im Dateisystem der Funktions-App die Datei project.json hinzu.To use NuGet packages in an F# function, add a project.json file to the function's folder in the function app's file system. Hier ist eine project.json-Beispieldatei angegeben, mit der ein NuGet-Paketverweis auf Microsoft.ProjectOxford.Face Version 1.1.0 hinzugefügt wird:Here is an example project.json file that adds a NuGet package reference to Microsoft.ProjectOxford.Face version 1.1.0:

{
  "frameworks": {
    "net46":{
      "dependencies": {
        "Microsoft.ProjectOxford.Face": "1.1.0"
      }
    }
   }
}

Nur .NET Framework 4.6 wird unterstützt. Stellen Sie also sicher, dass für Ihre Datei project.json wie hier gezeigt net46 angegeben wird.Only the .NET Framework 4.6 is supported, so make sure that your project.json file specifies net46 as shown here.

Beim Hochladen der Datei project.json erhält die Laufzeit die Pakete und fügt automatisch Verweise auf die Paketassemblys hinzu.When you upload a project.json file, the runtime gets the packages and automatically adds references to the package assemblies. Sie müssen keine #r "AssemblyName" -Direktiven hinzufügen.You don't need to add #r "AssemblyName" directives. Fügen Sie die erforderlichen open-Anweisungen einfach der .fsx-Datei hinzu.Just add the required open statements to your .fsx file.

Es kann ratsam sein, automatische Verweisassemblys in die Editor-Einleitung einzufügen, um die Interaktion des Editors mit den F#-Kompilierdiensten zu verbessern.You may wish to put automatically references assemblies in your editor prelude, to improve your editor's interaction with F# Compile Services.

Hinzufügen der Datei project.json zur Azure-FunktionHow to add a project.json file to your Azure Function

  1. Stellen Sie zunächst sicher, dass Ihre Funktionen-App ausgeführt wird. Öffnen Sie zu diesem Zweck Ihre Funktion im Azure-Portal.Begin by making sure your function app is running, which you can do by opening your function in the Azure portal. Dies ermöglicht auch Zugriff auf die Streamingprotokolle, in denen die Ausgabe der Paketinstallation angezeigt wird.This also gives access to the streaming logs where package installation output will be displayed.
  2. Verwenden Sie zum Hochladen der Datei project.json eines der Verfahren, die unter Aktualisieren von Funktionen-App-Dateienbeschrieben sind.To upload a project.json file, use one of the methods described in how to update function app files. Wenn Sie Continuous Deployment für Azure Functions verwenden, können Sie Ihrer Stagingverzweigung die Datei project.json hinzufügen, um damit zu experimentieren, bevor Sie sie der Bereitstellungsverzweigung hinzufügen.If you are using Continuous Deployment for Azure Functions, you can add a project.json file to your staging branch in order to experiment with it before adding it to your deployment branch.
  3. Nach dem Hinzufügen der Datei project.json wird eine Ausgabe angezeigt, die dem folgenden Beispiel im Streamingprotokoll Ihrer Funktion ähnelt:After the project.json file is added, you will see output similar to the following example in your function's streaming log:
2016-04-04T19:02:48.745 Restoring packages.
2016-04-04T19:02:48.745 Starting NuGet restore
2016-04-04T19:02:50.183 MSBuild auto-detection: using msbuild version '14.0' from 'D:\Program Files (x86)\MSBuild\14.0\bin'.
2016-04-04T19:02:50.261 Feeds used:
2016-04-04T19:02:50.261 C:\DWASFiles\Sites\facavalfunctest\LocalAppData\NuGet\Cache
2016-04-04T19:02:50.261 https://api.nuget.org/v3/index.json
2016-04-04T19:02:50.261
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\Project.json...
2016-04-04T19:02:52.800 Installing Newtonsoft.Json 6.0.8.
2016-04-04T19:02:52.800 Installing Microsoft.ProjectOxford.Face 1.1.0.
2016-04-04T19:02:57.095 All packages are compatible with .NETFramework,Version=v4.6.
2016-04-04T19:02:57.189
2016-04-04T19:02:57.189
2016-04-04T19:02:57.455 Packages restored.

UmgebungsvariablenEnvironment variables

Verwenden Sie System.Environment.GetEnvironmentVariable, um eine Umgebungsvariable oder einen App-Einstellungswert abzurufen, z.B.:To get an environment variable or an app setting value, use System.Environment.GetEnvironmentVariable, for example:

open System.Environment
open Microsoft.Extensions.Logging

let Run(timer: TimerInfo, log: ILogger) =
    log.LogInformation("Storage = " + GetEnvironmentVariable("AzureWebJobsStorage"))
    log.LogInformation("Site = " + GetEnvironmentVariable("WEBSITE_SITE_NAME"))

Wiederverwenden von .fsx-CodeReusing .fsx code

Sie können Code aus anderen .fsx-Dateien verwenden, indem Sie eine #load-Direktive nutzen.You can use code from other .fsx files by using a #load directive. Beispiel:For example:

run.fsx

#load "logger.fsx"

let Run(timer: TimerInfo, log: ILogger) =
    mylog log (sprintf "Timer: %s" DateTime.Now.ToString())

logger.fsx

let mylog(log: ILogger, text: string) =
    log.LogInformation(text);

Die Pfade zur #load-Direktive gelten relativ zum Speicherort Ihrer .fsx-Datei.Paths provides to the #load directive are relative to the location of your .fsx file.

  • #load "logger.fsx" lädt eine Datei, die sich im Funktionsordner befindet.#load "logger.fsx" loads a file located in the function folder.
  • #load "package\logger.fsx" lädt eine Datei, die sich im Ordner package im Funktionsordner befindet.#load "package\logger.fsx" loads a file located in the package folder in the function folder.
  • #load "..\shared\mylogger.fsx" lädt eine Datei, die sich im Ordner shared auf derselben Ebene wie der Funktionsordner direkt unter wwwroot befindet.#load "..\shared\mylogger.fsx" loads a file located in the shared folder at the same level as the function folder, that is, directly under wwwroot.

Die #load-Direktive funktioniert nur mit .fsx-Dateien (F#-Skripts) und nicht mit .fs-Dateien.The #load directive only works with .fsx (F# script) files, and not with .fs files.

Nächste SchritteNext steps

Weitere Informationen finden Sie in den folgenden Ressourcen:For more information, see the following resources: