Az Azure Functions F# – fejlesztői referenciaAzure Functions F# Developer Reference

F#az Azure Functions egy megoldással egyszerűen futtathatók kisebb kódrészletek, más kód vagy a "függvények" a felhőben van.F# for Azure Functions is a solution for easily running small pieces of code, or "functions," in the cloud. Az adatáramlás a F# függvény függvény argumentumának keresztül.Data flows into your F# function via function arguments. Argument neve meg van határozva a function.json, és vannak az előre definiált nevek eléréséhez, többek között a függvény naplózó és a megszakítási tokeneket.Argument names are specified in function.json, and there are predefined names for accessing things like the function logger and cancellation tokens.

Fontos

F#parancsprogram (.fsx) csak a támogatja verzió 1.x az Azure Functions Runtime.F# script (.fsx) is only supported by version 1.x of the Azure Functions runtime. Ha a használni kívánt F# az a verzió 2.x verziójú futtatókörnyezet kell használnia egy előre lefordított F# hordozhatóosztálytár-projektjének (.fs).If you want to use F# with the version 2.x runtime, you must use a precompiled F# class library project (.fs). Létrehozásához, kezeléséhez és közzétételéhez egy F# hordozhatóosztálytár-projektjének Visual Studio használatával, mint egy C# hordozhatóosztálytár-projektjének.You create, manage, and publish an F# class library project using Visual Studio as you would a C# class library project. Functions-verziókkal kapcsolatos további információkért lásd: Azure Functions runtime verziók áttekintése.For more information about Functions versions, see Azure Functions runtime versions overview.

Ez a cikk feltételezi, hogy Ön már elolvasta a Azure Functions fejlesztői segédanyagai.This article assumes that you've already read the Azure Functions developer reference.

.Fsx működéseHow .fsx works

Egy .fsx fájl egy F# parancsfájlt.An .fsx file is an F# script. Azt is értelmezhetők, egy F# projekt, amely az egyetlen fájl szerepel.It can be thought of as an F# project that's contained in a single file. A fájl tartalmazza a kódban a program (az ebben az esetben az Azure-függvény) és a függőségek kezelése irányelveknek.The file contains both the code for your program (in this case, your Azure Function) and directives for managing dependencies.

Ha egy .fsx az Azure-függvény, gyakran szükséges a szerelvények olyan automatikusan tartalmazza, így a "bolierplate" helyett a függvény kódját összpontosíthat.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.

gyökérmappa-szerkezetébenFolder structure

A mappastruktúra egy F# parancsfájl projekt a következőhöz hasonló: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

Van egy megosztott host.json fájlt, amely a függvényalkalmazás konfigurálása használható.There's a shared host.json file that can be used to configure the function app. Minden függvény saját kódfájl (.fsx) és a kötési konfigurációs fájl (function.json) rendelkezik.Each function has its own code file (.fsx) and binding configuration file (function.json).

A kötési bővítményeket szükséges verzió 2.x a Functions runtime vannak meghatározva a extensions.csproj fájlt, a tényleges függvénytárfájlok a bin mappát.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. Ha helyileg fejlesztésével, akkor meg kell regisztrálja a kötési bővítményeket.When developing locally, you must register binding extensions. Amikor fejlesztéséről az Azure Portalon, a regisztrációt, készen áll.When developing functions in the Azure portal, this registration is done for you.

Argumentumok kötéstBinding to arguments

Minden egyes kötés támogatja bizonyos argumentumok leírt módon a eseményindítók és kötések az Azure Functions fejlesztői segédanyagok.Each binding supports some set of arguments, as detailed in the Azure Functions triggers and bindings developer reference. Ha például egy blob eseményindító támogatja az argumentum kötéseit egyik egy POCO, amelyek használatával kell megadni egy F# rekord.For example, one of the argument bindings a blob trigger supports is a POCO, which can be expressed using an F# record. Példa:For example:

type Item = { Id: string }

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

A F# Azure-függvényt egy vagy több argumentumot vesz igénybe.Your F# Azure Function will take one or more arguments. Amikor az Azure Functions-argumentumok az, hogy tekintse meg bemeneti argumentumok és kimeneti argumentumokat.When we talk about Azure Functions arguments, we refer to input arguments and output arguments. A bemeneti argumentumok az pontosan mit, megosztásánál: a bemeneti a F# Azure-függvény.An input argument is exactly what it sounds like: input to your F# Azure Function. Egy kimeneti argumentum értéke módosítható adatok, vagy egy byref<> argumentum, amely olyan módon, hogy vissza adatokat ki a függvény.An output argument is mutable data or a byref<> argument that serves as a way to pass data back out of your function.

A fentiek példában blob egy bemeneti argumentum, és output egy kimeneti argumentum.In the example above, blob is an input argument, and output is an output argument. Figyelje meg, hogy használtuk byref<> a output (nem kell hozzáadni a [<Out>] jegyzet).Notice that we used byref<> for output (there's no need to add the [<Out>] annotation). Használatával egy byref<> típusa lehetővé teszi, hogy a függvény melyik rekord vagy az argumentum a hivatkozott objektum módosítása.Using a byref<> type allows your function to change which record or object the argument refers to.

Ha egy F# rekordot egy bemeneti típus használják, fel kell tüntetni az a rekord definíció [<CLIMutable>] annak érdekében, hogy az Azure Functions keretrendszer, a mezők helyes beállítása előtt a rekord a függvényt.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. Technikai részletek [<CLIMutable>] rekord tulajdonságaira beállítókat állít elő.Under the hood, [<CLIMutable>] generates setters for the record properties. Példa:For example:

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

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

Egy F# osztályt mind a bejövő és kimenő argumentumokat is használható.An F# class can also be used for both in and out arguments. Egy osztály tulajdonságait általában kell beolvasókat és beállítókat.For a class, properties will usually need getters and setters. Példa: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

NaplózásLogging

A kimeneti bejelentkezni a folyamatos átviteli naplók a F#, a függvény típusú argumentumot vesz igénybe ILogger.To log output to your streaming logs in F#, your function should take an argument of type ILogger. A konzisztencia érdekében javasoljuk, hogy ezt az argumentumot nevű log.For consistency, we recommend this argument is named log. Példa:For example:

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

Az aszinkronAsync

A async munkafolyamat is használható, de az eredményt kell visszaadnia egy Task.The async workflow can be used, but the result needs to return a Task. Ezt megteheti a Async.StartAsTask, például:This can be done with Async.StartAsTask, for example:

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

Token törléseCancellation Token

Ha a függvény leállítási szabályosan kezelésére van szüksége, adhat egy CancellationToken argumentum.If your function needs to handle shutdown gracefully, you can give it a CancellationToken argument. Ez kombinálva async, például: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)

Névterek importálásaImporting namespaces

Névterek segítségével lehet megnyitni a szokásos módon: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) =
    ...

A következő névterek nyílik meg automatikusan: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.

Hivatkozó külső szerelvényekReferencing External Assemblies

Ehhez hasonlóan keretrendszer összeállítási referenciát is hozzáadhatók a a #r "AssemblyName" irányelv.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) =
    ...

Az alábbi szerelvények a rendszer automatikusan hozzáadja az az Azure Functions üzemeltetési környezet: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.

Emellett a következő szerelvények olyan speciális kisbetűsek és simplename szerint lehet hivatkozni (pl. #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.Microsoft.AspNEt.WebHooks.Common.

Privátní sestavení hivatkoznia kell, ha fájlt tölthet fel a szerelvény be egy bin mappa viszonyítva, a függvény és a hivatkozás, a fájl használatával nevezze (például) #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"). A fájlok feltöltéséről a függvény mappáját információkért lásd: a következő szakasz a felügyeleti csomag.For information on how to upload files to your function folder, see the following section on package management.

Editor PreludeEditor Prelude

-Szerkesztő, amely támogatja a F# fordító szolgáltatás nem lesz a névterek és-szerelvényt, amely az Azure Functions automatikusan tartalmazza.An editor that supports F# Compiler Services will not be aware of the namespaces and assemblies that Azure Functions automatically includes. Emiatt a hasznos lehet egy prelude, amely segít a szerkesztőben keresse meg a szerelvények használ, és explicit módon a névterek megnyitásához.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. Példa: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) =
    ...

Az Azure Functions végrehajtja a kódot, amikor feldolgozza a forráson COMPILED meghatározva, hogy a rendszer figyelmen kívül a szerkesztő prelude.When Azure Functions executes your code, it processes the source with COMPILED defined, so the editor prelude will be ignored.

CsomagkezelésPackage management

A NuGet-csomagok használata egy F# működik, adjon hozzá egy project.json fájlt a függvényalkalmazás fájlrendszer a függvény mappájába.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. Íme egy példa project.json fájlt, amely hozzáad egy NuGet csomag hivatkozást Microsoft.ProjectOxford.Face 1.1.0-s verzió: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"
      }
    }
   }
}

Csak a .NET Framework 4.6 támogatott, ezért ügyeljen arra, hogy a project.json fájlban az net46 itt látható módon.Only the .NET Framework 4.6 is supported, so make sure that your project.json file specifies net46 as shown here.

Amikor feltölt egy project.json fájl, a modul lekérdezi a csomagokat, és automatikusan hozzáadja a csomag szerelvényre hivatkozik.When you upload a project.json file, the runtime gets the packages and automatically adds references to the package assemblies. Nem kell hozzá #r "AssemblyName" irányelveknek.You don't need to add #r "AssemblyName" directives. Adja hozzá a szükséges open utasításokat a .fsx fájlt.Just add the required open statements to your .fsx file.

Kezdésként érdemes lehet helyezni a szerkesztő prelude való interakció a szerkesztő javítása érdekében automatikusan hivatkozásokat szerelvények F# összeállítása szolgáltatások.You may wish to put automatically references assemblies in your editor prelude, to improve your editor's interaction with F# Compile Services.

Hogyan adhat hozzá egy project.json fájlt az Azure-függvényHow to add a project.json file to your Azure Function

  1. Indítása azáltal, hogy a függvényalkalmazás fut, akkor nyissa meg a függvényt az Azure Portalon teheti.Begin by making sure your function app is running, which you can do by opening your function in the Azure portal. Ez is hozzáférést biztosít a folyamatos átviteli naplók, ahol csomag telepítési kimenet jelenik meg.This also gives access to the streaming logs where package installation output will be displayed.
  2. A feltöltendő egy project.json fájlt, a leírt módszerek egyikével függvény alkalmazásfájlok frissítése.To upload a project.json file, use one of the methods described in how to update function app files. Ha használ Azure Functions – folyamatos üzembe helyezés, adhat hozzá egy project.json fájlt annak érdekében, hogy az üzembe helyezés ágba való hozzáadása előtt kísérletezhet az átmeneti ágban.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. Miután a project.json fájlt adnak hozzá, látni fogja a függvényben az alábbi példához hasonló kimenetet a streamelési napló: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.

Környezeti változókEnvironment variables

Egy környezeti változó vagy olyan alkalmazás, beállítás értékét, amelyet System.Environment.GetEnvironmentVariable, például: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"))

.Fsx kód újrafelhasználásaReusing .fsx code

A többi kódot használhatja .fsx fájlok használatával olyan #load irányelv.You can use code from other .fsx files by using a #load directive. Példa: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);

Elérési utak biztosít a #load helyéhez viszonyított irányelv vannak a .fsx fájlt.Paths provides to the #load directive are relative to the location of your .fsx file.

  • #load "logger.fsx" betölt egy fájlt, a függvény mappában található.#load "logger.fsx" loads a file located in the function folder.
  • #load "package\logger.fsx" betölt egy fájlt a package mappája a függvényt.#load "package\logger.fsx" loads a file located in the package folder in the function folder.
  • #load "..\shared\mylogger.fsx" betölt egy fájlt a shared mappa azonos szinten, a függvény mappába, azaz közvetlenül a wwwroot.#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.

A #load irányelv csak együttműködik .fsx (F# parancsfájl) fájlokat, és nem a .fs fájlokat.The #load directive only works with .fsx (F# script) files, and not with .fs files.

További lépésekNext steps

További információkért lásd a következőket:For more information, see the following resources: