Utvecklarreferens för Azure Functions C#-skript (.csx)

Artikel
10/04/2023

Den här artikeln är en introduktion till att utveckla Azure Functions med hjälp av C#-skript (.csx).

Viktigt!

C#-skript stöds främst för att ge en praktisk upplevelse i portalen som hjälper dig att snabbt komma igång med att skapa och köra C#-funktioner. För appar av produktionskvalitet bör du i stället utveckla C#-funktionerna lokalt som ett kompilerat C#-klassbiblioteksprojekt. Information om hur du migrerar ett C#-skriptprojekt till ett C#-klassbibliotek (isolerad arbetare) finns i Konvertera en C#-skriptapp till ett C#-projekt.

Med Azure Functions kan du utveckla funktioner med C# på något av följande sätt:

Typ	Körningsprocess	Kodtillägg	Utvecklingsmiljö	Referens
C#-skript	i processen	.Csx	Portal Kärnverktyg	Den här artikeln
C#-klassbibliotek (isolerad arbetare)	isolerad arbetsprocess	.cs	Visual Studio Visual Studio Code Kärnverktyg	Processfunktioner för isolerade .NET-arbetare
C#-klassbibliotek (pågår)	i processen	.cs	Visual Studio Visual Studio Code Kärnverktyg	Processbaserade C#-klassbiblioteksfunktioner

Så här fungerar .csx

Data flödar in i C#-funktionen via metodargument. Argumentnamn anges i en function.json fil och det finns fördefinierade namn för åtkomst till saker som funktionslogger och annulleringstoken.

Med .csx-formatet kan du skriva mindre "boilerplate" och fokusera på att bara skriva en C#-funktion. I stället för att omsluta allt i ett namnområde och en klass definierar du bara en Run metod. Inkludera eventuella sammansättningsreferenser och namnområden i början av filen som vanligt.

En funktionsapps .csx-filer kompileras när en instans initieras. Det här kompileringssteget innebär att saker som kallstart kan ta längre tid för C#-skriptfunktioner jämfört med C#-klassbibliotek. Det här kompileringssteget är också anledningen till att C#-skriptfunktioner kan redigeras i Azure-portalen, medan C#-klassbibliotek inte är det.

Mappstrukturen

Mappstrukturen för ett C#-skriptprojekt ser ut som i följande exempel:

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

Det finns en delad host.json-fil som kan användas för att konfigurera funktionsappen. Varje funktion har en egen kodfil (.csx) och en bindningskonfigurationsfil (function.json).

De bindningstillägg som krävs i version 2.x och senare versioner av Functions-körningen extensions.csproj definieras i filen med de faktiska biblioteksfilerna bin i mappen. När du utvecklar lokalt måste du registrera bindningstillägg. När du utvecklar funktioner i Azure-portalen görs den här registreringen åt dig.

Bindning till argument

Indata eller utdata är bundna till en C#-skriptfunktionsparameter via name egenskapen i konfigurationsfilen function.json . I följande exempel visas en function.json-fil och en run.csx-fil för en köutlöst funktion. Parametern som tar emot data från kömeddelandet namnges myQueueItem eftersom det är värdet för name egenskapen.

{
    "disabled": false,
    "bindings": [
        {
            "type": "queueTrigger",
            "direction": "in",
            "name": "myQueueItem",
            "queueName": "myqueue-items",
            "connection":"MyStorageConnectionAppSetting"
        }
    ]
}

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.Extensions.Logging;
using Microsoft.WindowsAzure.Storage.Queue;
using System;

public static void Run(CloudQueueMessage myQueueItem, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem.AsString}");
}

Instruktionen #r förklaras senare i den här artikeln.

Typer som stöds för bindningar

Varje bindning har sina egna typer som stöds. Till exempel kan en blobutlösare användas med en strängparameter, en POCO-parameter, en CloudBlockBlob parameter eller någon av flera andra typer som stöds. I artikeln om bindningsreferens för blobbindningar visas alla parametertyper som stöds för blobutlösare. Mer information finns i Utlösare och bindningar och bindningsreferensdokumenten för varje bindningstyp.

Dricks

Om du planerar att använda HTTP- eller WebHook-bindningarna planerar du att undvika portöverbelastning som kan orsakas av felaktig instansiering av HttpClient. Mer information finns i Hantera anslutningar i Azure Functions.

Referera till anpassade klasser

Om du behöver använda en anpassad POCO-klass (Plain Old CLR Object) kan du inkludera klassdefinitionen i samma fil eller placera den i en separat fil.

I följande exempel visas ett run.csx-exempel som innehåller en POCO-klassdefinition.

public static void Run(string myBlob, out MyClass myQueueItem)
{
    log.Verbose($"C# Blob trigger function processed: {myBlob}");
    myQueueItem = new MyClass() { Id = "myid" };
}

public class MyClass
{
    public string Id { get; set; }
}

En POCO-klass måste ha en getter och setter definierad för varje egenskap.

Återanvända .csx-kod

Du kan använda klasser och metoder som definierats i andra .csx-filer i filen run.csx . Det gör du genom att använda #load direktiv i filen run.csx . I följande exempel delas en loggningsrutin med namnet MyLogger i myLogger.csx och läses in i run.csx med hjälp av #load direktivet:

Exempel på run.csx:

#load "mylogger.csx"

using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, ILogger log)
{
    log.LogInformation($"Log by run.csx: {DateTime.Now}");
    MyLogger(log, $"Log by MyLogger: {DateTime.Now}");
}

Exempel mylogger.csx:

public static void MyLogger(ILogger log, string logtext)
{
    log.LogInformation(logtext);
}

Att använda en delad .csx-fil är ett vanligt mönster när du vill ange de data som skickas mellan funktioner med hjälp av ett POCO-objekt. I följande förenklade exempel delar en HTTP-utlösare och köutlösare ett POCO-objekt med namnet Order för att ange orderdata:

Exempel på run.csx för HTTP-utlösare:

#load "..\shared\order.csx"

using System.Net;
using Microsoft.Extensions.Logging;

public static async Task<HttpResponseMessage> Run(Order req, IAsyncCollector<Order> outputQueueItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function received an order.");
    log.LogInformation(req.ToString());
    log.LogInformation("Submitting to processing queue.");

    if (req.orderId == null)
    {
        return new HttpResponseMessage(HttpStatusCode.BadRequest);
    }
    else
    {
        await outputQueueItem.AddAsync(req);
        return new HttpResponseMessage(HttpStatusCode.OK);
    }
}

Exempel på run.csx för köutlösare:

#load "..\shared\order.csx"

using System;
using Microsoft.Extensions.Logging;

public static void Run(Order myQueueItem, out Order outputQueueItem, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed order...");
    log.LogInformation(myQueueItem.ToString());

    outputQueueItem = myQueueItem;
}

Exempel på order.csx:

public class Order
{
    public string orderId {get; set; }
    public string custName {get; set;}
    public string custAddress {get; set;}
    public string custEmail {get; set;}
    public string cartId {get; set; }

    public override String ToString()
    {
        return "\n{\n\torderId : " + orderId +
                  "\n\tcustName : " + custName +
                  "\n\tcustAddress : " + custAddress +
                  "\n\tcustEmail : " + custEmail +
                  "\n\tcartId : " + cartId + "\n}";
    }
}

Du kan använda en relativ sökväg med #load direktivet:

#load "mylogger.csx" läser in en fil som finns i funktionsmappen.
#load "loadedfiles\mylogger.csx" läser in en fil som finns i en mapp i funktionsmappen.
#load "..\shared\mylogger.csx" läser in en fil som finns i en mapp på samma nivå som funktionsmappen, dvs. direkt under wwwroot.

Direktivet #load fungerar endast med .csx-filer , inte med .cs-filer .

Bindning till metodens returvärde

Du kan använda ett metodreturvärde för en utdatabindning med hjälp av namnet $return i function.json.

{
    "name": "$return",
    "type": "blob",
    "direction": "out",
    "path": "output-container/{id}"
}

Här är C#-skriptkoden med returvärdet följt av ett asynkront exempel:

public static string Run(WorkItem input, ILogger log)
{
    string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
    log.LogInformation($"C# script processed queue message. Item={json}");
    return json;
}

public static Task<string> Run(WorkItem input, ILogger log)
{
    string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
    log.LogInformation($"C# script processed queue message. Item={json}");
    return Task.FromResult(json);
}

Använd endast returvärdet om en lyckad funktionskörning alltid resulterar i ett returvärde som skickas till utdatabindningen. Annars använder du ICollector eller IAsyncCollector, som du ser i följande avsnitt.

Skriva flera utdatavärden

Om du vill skriva flera värden till en utdatabindning, eller om ett lyckat funktionsanrop kanske inte resulterar i något att skicka till utdatabindningen, använder du typerna ICollector eller IAsyncCollector . Dessa typer är skrivskyddade samlingar som skrivs till utdatabindningen när metoden är klar.

Det här exemplet skriver flera kömeddelanden i samma kö med hjälp av ICollector:

public static void Run(ICollector<string> myQueue, ILogger log)
{
    myQueue.Add("Hello");
    myQueue.Add("World!");
}

Loggning

Om du vill logga utdata till dina strömmande loggar i C# inkluderar du ett argument av typen ILogger. Vi rekommenderar att du ger den lognamnet . Undvik att använda Console.Write i Azure Functions.

public static void Run(string myBlob, ILogger log)
{
    log.LogInformation($"C# Blob trigger function processed: {myBlob}");
}

Kommentar

Information om ett nyare loggningsramverk som du kan använda i stället för TraceWriterfinns i ILogger-dokumentationen i utvecklarguiden för .NET-klassbiblioteket.

Loggning av anpassade mått

Du kan använda LogMetric tilläggsmetoden på ILogger för att skapa anpassade mått i Application Insights. Här är ett exempelmetodanrop:

logger.LogMetric("TestMetric", 1234);

Den här koden är ett alternativ till att anropa TrackMetric med hjälp av Application Insights API för .NET.

Asynkrona

Om du vill göra en funktion asynkron använder du nyckelordet async och returnerar ett Task objekt.

public async static Task ProcessQueueMessageAsync(
        string blobName,
        Stream blobInput,
        Stream blobOutput)
{
    await blobInput.CopyToAsync(blobOutput, 4096);
}

Du kan inte använda out parametrar i asynkrona funktioner. För utdatabindningar använder du funktionens returvärde eller ett insamlarobjekt i stället.

Annulleringstoken

En funktion kan acceptera parametern CancellationToken , vilket gör att operativsystemet kan meddela koden när funktionen är på väg att avslutas. Du kan använda det här meddelandet för att se till att funktionen inte avslutas oväntat på ett sätt som lämnar data i ett inkonsekvent tillstånd.

I följande exempel visas hur du söker efter förestående funktionsavslut.

using System;
using System.IO;
using System.Threading;

public static void Run(
    string inputText,
    TextWriter logger,
    CancellationToken token)
{
    for (int i = 0; i < 100; i++)
    {
        if (token.IsCancellationRequested)
        {
            logger.WriteLine("Function was cancelled at iteration {0}", i);
            break;
        }
        Thread.Sleep(5000);
        logger.WriteLine("Normal processing for queue message={0}", inputText);
    }
}

Importera namnområden

Om du behöver importera namnområden kan du göra det som vanligt med using -satsen.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger log)

Följande namnområden importeras automatiskt och är därför valfria:

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

Referera till externa sammansättningar

För ramverkssammansättningar lägger du till referenser med hjälp #r "AssemblyName" av direktivet.

#r "System.Web.Http"

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger log)

Följande sammansättningar läggs automatiskt till av Azure Functions-värdmiljön:

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

Följande sammansättningar kan refereras med enkla namn, efter körningsversion:

v2.x+
v1.x

Newtonsoft.Json
Microsoft.WindowsAzure.Storage^*

^*Togs bort i version 4.x av körningen.

I kod refereras sammansättningar som i följande exempel:

#r "AssemblyName"

Referera till anpassade sammansättningar

Om du vill referera till en anpassad sammansättning kan du använda antingen en delad sammansättning eller en privat sammansättning:

Delade sammansättningar delas mellan alla funktioner i en funktionsapp. Om du vill referera till en anpassad sammansättning laddar du upp sammansättningen till en mapp med namnet bin i rotmappen (wwwroot) i funktionsappen.
Privata sammansättningar är en del av en viss funktions kontext och stöder sidoinläsning av olika versioner. Privata sammansättningar ska laddas upp i en bin mapp i funktionskatalogen. Referera till sammansättningarna med filnamnet, till exempel #r "MyAssembly.dll".

Information om hur du laddar upp filer till funktionsmappen finns i avsnittet om pakethantering.

Övervakade kataloger

Katalogen som innehåller funktionsskriptfilen övervakas automatiskt efter ändringar i sammansättningar. Om du vill hålla utkik efter sammansättningsändringar i andra kataloger lägger du till watchDirectories dem i listan i host.json.

Använda NuGet-paket

Hur både bindningstilläggspaket och andra NuGet-paket läggs till i funktionsappen beror på målversionen av Functions-körningen.

v2.x+
v1.x

Som standard görs den uppsättning NuGet-paket för Functions-tillägg som stöds tillgängliga för din C#-skriptfunktionsapp med hjälp av tilläggspaket. Mer information finns i Tilläggspaket.

Om du av någon anledning inte kan använda tilläggspaket i projektet kan du även använda Azure Functions Core Tools för att installera tillägg baserat på bindningar som definierats i function.json-filerna i din app. När du använder Core Tools för att registrera tillägg bör du använda alternativet --csx . Mer information finns i installera func-tillägg.

Som standard läser Core Tools filerna function.json och lägger till de nödvändiga paketen i en extensions.csproj C#-klassbiblioteksprojektfil i roten till funktionsappens filsystem (wwwroot). Eftersom Core Tools använder dotnet.exe kan du använda det för att lägga till alla NuGet-paketreferenser i den här filnamnstilläggen. Under installationen skapar Core Tools extensions.csproj för att installera de bibliotek som krävs. Här är ett exempel på filen extensions.csproj som lägger till en referens till Microsoft.ProjectOxford.Face version 1.1.0:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.ProjectOxford.Face" Version="1.1.0" />
    </ItemGroup>
</Project>

Kommentar

För C#-skript (.csx) måste du ange TargetFramework värdet netstandard2.0. Andra målramverk, till exempel net6.0, stöds inte.

Version 1.x av Functions-körningen använder en project.json-fil för att definiera beroenden. Här är ett exempel på en project.json-fil :

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

Tilläggspaket stöds inte av version 1.x.

Om du vill använda en anpassad NuGet-feed anger du feeden i en Nuget.Config-fil i funktionsappens rotmapp. Mer information finns i Konfigurera NuGet-beteende.

Om du bara arbetar med projektet i portalen måste du manuellt skapa filen extensions.csproj eller en Nuget.Config-fil direkt på webbplatsen. Mer information finns i Installera tillägg manuellt.

Miljövariabler

Om du vill hämta en miljövariabel eller ett appinställningsvärde använder du System.Environment.GetEnvironmentVariable, som du ser i följande kodexempel:

public static void Run(TimerInfo myTimer, ILogger log)
{
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
    log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
    log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

public static string GetEnvironmentVariable(string name)
{
    return name + ": " +
        System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);
}

Principer för nya försök

Functions stöder två inbyggda återförsöksprinciper. Mer information finns i Återförsöksprinciper.

Fast fördröjning
Exponentiell backoff

Här är återförsöksprincipen i filen function.json :

{
    "disabled": false,
    "bindings": [
        {
            ....
        }
    ],
    "retry": {
        "strategy": "fixedDelay",
        "maxRetryCount": 4,
        "delayInterval": "00:00:10"
    }
}

function.json-egenskap	beskrivning
Strategi	Använd `fixedDelay`.
maxRetryCount	Obligatoriska. Det maximala antalet återförsök som tillåts per funktionskörning. `-1` innebär att försöka igen på obestämd tid.
delayInterval	Fördröjningen som används mellan återförsök. Ange den som en sträng med formatet `HH:mm:ss`.

Här är återförsöksprincipen i filen function.json :

{
    "disabled": false,
    "bindings": [
        {
            ....
        }
    ],
    "retry": {
        "strategy": "exponentialBackoff",
        "maxRetryCount": 5,
        "minimumInterval": "00:00:10",
        "maximumInterval": "00:15:00"
    }
}

function.json-egenskap	beskrivning
Strategi	Använd `exponentialBackoff`.
maxRetryCount	Obligatoriska. Det maximala antalet återförsök som tillåts per funktionskörning. `-1` innebär att försöka igen på obestämd tid.
minimumInterval	Minsta fördröjning för återförsök. Ange den som en sträng med formatet `HH:mm:ss`.
maximumInterval	Den maximala fördröjningen för återförsök. Ange den som en sträng med formatet `HH:mm:ss`.

Bindning vid körning

I C# och andra .NET-språk kan du använda ett imperativt bindningsmönster, till skillnad från deklarativa bindningar i function.json. Imperativ bindning är användbart när bindningsparametrar måste beräknas vid körning i stället för designtid. Med det här mönstret kan du binda till indata- och utdatabindningar som stöds direkt i funktionskoden.

Definiera en imperativ bindning enligt följande:

Inkludera inte en post i function.json för önskade imperativa bindningar.
Skicka in en indataparameter Binder binder eller IBinder binder.
Använd följande C#-mönster för att utföra databindningen.

using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
{
    ...
}

BindingTypeAttribute är .NET-attributet som definierar bindningen och T är en indata- eller utdatatyp som stöds av den bindningstypen. T kan inte vara en out parametertyp (till exempel out JObject). Till exempel stöder mobile apps-tabellutdatabindningen sex utdatatyper, men du kan bara använda ICollector<T> eller IAsyncCollector<T> för T.

Exempel på enstaka attribut

I följande exempelkod skapas en storage blob-utdatabindning med blobsökvägen som definieras vid körning och skriver sedan en sträng till bloben.

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host.Bindings.Runtime;

public static async Task Run(string input, Binder binder)
{
    using (var writer = await binder.BindAsync<TextWriter>(new BlobAttribute("samples-output/path")))
    {
        writer.Write("Hello World!!");
    }
}

BlobAttribute definierar bindningen för in- eller utdata för lagringsblob och TextWriter är en utdatabindningstyp som stöds.

Exempel på flera attribut

I föregående exempel hämtas appinställningen för funktionsappens huvudlagringskonto anslutningssträng (som är AzureWebJobsStorage). Du kan ange en anpassad appinställning som ska användas för lagringskontot genom att lägga till StorageAccountAttribute och skicka attributmatrisen till BindAsync<T>(). Använd en Binder parameter, inte IBinder. Till exempel:

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host.Bindings.Runtime;

public static async Task Run(string input, Binder binder)
{
    var attributes = new Attribute[]
    {
        new BlobAttribute("samples-output/path"),
        new StorageAccountAttribute("MyStorageAccount")
    };

    using (var writer = await binder.BindAsync<TextWriter>(attributes))
    {
        writer.Write("Hello World!");
    }
}

I följande tabell visas .NET-attributen för varje bindningstyp och de paket där de definieras.

Bindning	Attribut	Lägg till referens
Azure Cosmos DB	`Microsoft.Azure.WebJobs.DocumentDBAttribute`	`#r "Microsoft.Azure.WebJobs.Extensions.CosmosDB"`
Event Hubs	`Microsoft.Azure.WebJobs.ServiceBus.EventHubAttribute`, `Microsoft.Azure.WebJobs.ServiceBusAccountAttribute`	`#r "Microsoft.Azure.Jobs.ServiceBus"`
Mobile Apps	`Microsoft.Azure.WebJobs.MobileTableAttribute`	`#r "Microsoft.Azure.WebJobs.Extensions.MobileApps"`
Notification Hubs	`Microsoft.Azure.WebJobs.NotificationHubAttribute`	`#r "Microsoft.Azure.WebJobs.Extensions.NotificationHubs"`
Service Bus	`Microsoft.Azure.WebJobs.ServiceBusAttribute`, `Microsoft.Azure.WebJobs.ServiceBusAccountAttribute`	`#r "Microsoft.Azure.WebJobs.ServiceBus"`
Lagringskö	`Microsoft.Azure.WebJobs.QueueAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Lagringsblob	`Microsoft.Azure.WebJobs.BlobAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Lagringstabell	`Microsoft.Azure.WebJobs.TableAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Twilio	`Microsoft.Azure.WebJobs.TwilioSmsAttribute`	`#r "Microsoft.Azure.WebJobs.Extensions.Twilio"`

Konvertera en C#-skriptapp till ett C#-projekt

Det enklaste sättet att konvertera en C#-skriptfunktionsapp till ett kompilerat C#-klassbiblioteksprojekt är att börja med ett nytt projekt. För varje funktion kan du sedan migrera koden och konfigurationen från varje run.csx-fil och function.json-fil i en funktionsmapp till en enda ny .cs-klassbibliotekskodfil. När du till exempel har en C#-skriptfunktion med namnet HelloWorld har du två filer: HelloWorld/run.csx och HelloWorld/function.json. För den här funktionen skapar du en kodfil med namnet HelloWorld.cs i ditt nya klassbiblioteksprojekt.

Om du använder C#-skript för portalredigering kan du ladda ned appinnehållet till din lokala dator. Välj alternativet Webbplatsinnehåll i stället för Projektet Innehåll och Visual Studio. Du behöver inte generera ett projekt och inkludera inte programinställningar i nedladdningen. Du definierar en ny utvecklingsmiljö och den här miljön bör inte ha samma behörigheter som din värdbaserade appmiljö.

De här instruktionerna visar hur du konverterar C#-skriptfunktioner (som körs i processen med Functions-värden) till C#-klassbiblioteksfunktioner som körs i en isolerad arbetsprocess.

Slutför avsnittet Skapa ett funktionsappprojekt från din önskade snabbstart:
Skapa en C#-funktion i Azure från kommandoraden

Skapa din första C#-funktion i Azure med Visual Studio

Skapa din första C#-funktion i Azure med Hjälp av Visual Studio Code

Om den ursprungliga C#-skriptkoden innehåller en extensions.csproj fil eller filer function.proj kopierar du paketreferenserna från filen och lägger till dem i det nya projektets .csproj fil på samma sätt ItemGroup med Functions-kärnberoenden.

Dricks

Konvertering ger en bra möjlighet att uppdatera till de senaste versionerna av dina beroenden. Detta kan kräva ytterligare kodändringar i ett senare steg.
Kopiera innehållet i den ursprungliga host.json filen till det nya projektets host.json fil, förutom extensionBundles avsnittet (kompilerade C#-projekt använder inte tilläggspaket och du måste uttryckligen lägga till referenser till alla tillägg som används av dina funktioner). När du sammanfogar host.json-filer ska du komma ihåg att host.json schemat är versionshanterat, där de flesta appar använder version 2.0. Innehållet i extensions avsnittet kan variera beroende på specifika versioner av bindningstilläggen som används av dina funktioner. Se referensartiklar för enskilda tillägg för att lära dig hur du konfigurerar host.json korrekt för dina specifika versioner.
För alla delade filer som refereras till av ett #load direktiv skapar du en ny .cs fil för var och en av dessa delade referenser. Det är enklast att skapa en ny .cs fil för varje delad klassdefinition. Om det finns statiska metoder utan en klass måste du definiera nya klasser för dessa metoder.
Utför följande uppgifter för varje <FUNCTION_NAME> mapp i det ursprungliga projektet:
1. Skapa en ny fil med namnet <FUNCTION_NAME>.csoch ersätt <FUNCTION_NAME> med namnet på den mapp som definierade C#-skriptfunktionen. Du kan skapa en ny funktionskodfil från en av de utlösarspecifika mallarna på följande sätt:
  func new --name <FUNCTION_NAME> Använd kommandot och välj rätt utlösarmall i kommandotolken.
  
  Följ Lägg till en funktion i projektet i Visual Studio-guiden.
  
  Följ Lägg till en funktion i projektet i Visual Studio Code-guiden.
2. Kopiera uttrycken using från run.csx filen och lägg till dem i den nya filen. Du behöver inga #r direktiv.
3. För alla #load instruktioner i run.csx filen lägger du till en ny using instruktion för namnområdet som du använde för den delade koden.
4. I den nya filen definierar du en klass för funktionen under det namnområde som du använder för projektet.
5. Skapa en ny metod med namnet RunHandler eller något liknande. Den här nya metoden fungerar som den nya startpunkten för funktionen.
6. Kopiera den statiska metod som representerar din funktion, tillsammans med alla funktioner som den anropar, från run.csx till din nya klass som en andra metod. Från den nya metoden som du skapade i föregående steg anropar du den här statiska metoden. Det här indirekta steget är användbart för att navigera i eventuella skillnader när du fortsätter uppgraderingen. Du kan behålla den ursprungliga metoden på exakt samma sätt och helt enkelt styra dess indata från den nya kontexten. Du kan behöva skapa parametrar för den nya metoden som du sedan skickar till det statiska metodanropet. När du har bekräftat att migreringen har fungerat som den ska kan du ta bort den här extra indirekta nivån.
7. För varje bindning i function.json filen lägger du till motsvarande attribut i den nya metoden. Information om hur du snabbt hittar bindningsexempel finns i Lägga till bindningar manuellt baserat på exempel.
8. Lägg till tilläggspaket som krävs av bindningarna i projektet, om du inte redan har gjort det.
Återskapa alla programinställningar som krävs av din app i Values samlingen av filen local.settings.json.
Kontrollera att projektet körs lokalt:
Använd func start för att köra appen från kommandoraden. Mer information finns i Kör funktioner lokalt.

Följ avsnittet Kör funktioner lokalt i Visual Studio-guiden.

Följ avsnittet Kör funktioner lokalt i Visual Studio Code-guiden.
Publicera projektet till en ny funktionsapp i Azure:
Skapa dina Azure-resurser och distribuera kodprojektet till Azure med hjälp func azure functionapp publish <APP_NAME> av kommandot . Mer information finns i Distribuera projektfiler.

Följ avsnittet Publicera till Azure i Visual Studio-guiden.

Följ avsnittet Skapa Azure-resurser i Visual Studio Code-guiden.

Exempel på funktionskonvertering

Det här avsnittet visar ett exempel på migreringen för en enskild funktion.

Den ursprungliga funktionen i C#-skript har två filer:

HelloWorld/function.json
HelloWorld/run.csx

Innehållet i HelloWorld/function.json är:

{
  "bindings": [
    {
      "authLevel": "FUNCTION",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    }
  ]
}

Innehållet i HelloWorld/run.csx är:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    string responseMessage = string.IsNullOrEmpty(name)
        ? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
                : $"Hello, {name}. This HTTP triggered function executed successfully.";

            return new OkObjectResult(responseMessage);
}

När du har migrerat till den isolerade arbetsmodellen med ASP.NET Core-integrering ersätts dessa med en enda HelloWorld.cs:

using System.Net;
using Microsoft.Azure.Functions.Worker;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

namespace MyFunctionApp
{
    public class HelloWorld
    {
        private readonly ILogger _logger;

        public HelloWorld(ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<HelloWorld>();
        }

        [Function("HelloWorld")]
        public async Task<IActionResult> RunHandler([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequest req)
        {
            return await Run(req, _logger);
        }

        // From run.csx
        public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            string name = req.Query["name"];

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            dynamic data = JsonConvert.DeserializeObject(requestBody);
            name = name ?? data?.name;

            string responseMessage = string.IsNullOrEmpty(name)
                ? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
                        : $"Hello, {name}. This HTTP triggered function executed successfully.";

            return new OkObjectResult(responseMessage);
        }
    }
}

Bindningskonfiguration och exempel

Det här avsnittet innehåller referenser och exempel för att definiera utlösare och bindningar i C#-skript.

Blob-utlösare

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `blobTrigger`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Måste anges till `in`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som representerar bloben i funktionskoden.
sökväg	Containern som ska övervakas. Kan vara ett mönster för blobnamn.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Azure Blobs. Se Anslut ioner.

I följande exempel visas en blobutlösardefinition i en function.json-fil och kod som använder bindningen. Funktionen skriver en logg när en blob läggs till eller uppdateras i containernsamples-workitems.

Här är bindningsdata i filen function.json :

{
    "disabled": false,
    "bindings": [
        {
            "name": "myBlob",
            "type": "blobTrigger",
            "direction": "in",
            "path": "samples-workitems/{name}",
            "connection":"MyStorageAccountAppSetting"
        }
    ]
}

Strängen {name} i blobutlösarsökvägen samples-workitems/{name} skapar ett bindningsuttryck som du kan använda i funktionskoden för att komma åt filnamnet för den utlösande bloben. Mer information finns i Mönster för blobnamn.

Här är C#-skriptkoden som binder till en Stream:

public static void Run(Stream myBlob, string name, ILogger log)
{
   log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
}

Här är C#-skriptkoden som binder till en CloudBlockBlob:

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.WindowsAzure.Storage.Blob;

public static void Run(CloudBlockBlob myBlob, string name, ILogger log)
{
    log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name}\nURI:{myBlob.StorageUri}");
}

Blobindata

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `blob`.
riktning	Måste anges till `in`.
Namn	Namnet på variabeln som representerar bloben i funktionskoden.
sökväg	Sökvägen till bloben.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Azure Blobs. Se Anslut ioner.

I följande exempel visas blobindata- och utdatabindningar i en function.json-fil och C#-skriptkod som använder bindningarna. Funktionen gör en kopia av en textblob. Funktionen utlöses av ett kömeddelande som innehåller namnet på bloben som ska kopieras. Den nya bloben heter {originalblobname}-Copy.

I filen function.json används metadataegenskapen queueTrigger för att ange blobnamnet i path egenskaperna:

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "myInputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    },
    {
      "name": "myOutputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}-Copy",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "out"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

public static void Run(string myQueueItem, string myInputBlob, out string myOutputBlob, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    myOutputBlob = myInputBlob;
}

Blobutdata

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `blob`.
riktning	Måste anges till `out`.
Namn	Namnet på variabeln som representerar bloben i funktionskoden.
sökväg	Sökvägen till bloben.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Azure Blobs. Se Anslut ioner.

I filen function.json används metadataegenskapen queueTrigger för att ange blobnamnet i path egenskaperna:

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "myInputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    },
    {
      "name": "myOutputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}-Copy",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "out"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

public static void Run(string myQueueItem, string myInputBlob, out string myOutputBlob, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    myOutputBlob = myInputBlob;
}

RabbitMQ-utlösare

I följande exempel visas en RabbitMQ-utlösarbindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen läser och loggar RabbitMQ-meddelandet.

Här är bindningsdata i filen function.json :

{
    "bindings": [
        {
            "name": "myQueueItem",
            "type": "rabbitMQTrigger",
            "direction": "in",
            "queueName": "queue",
            "connectionStringSetting": "rabbitMQConnectionAppSetting"
        }
    ]
}

Här är C#-skriptkoden:

using System;

public static void Run(string myQueueItem, ILogger log)
{
    log.LogInformation($"C# Script RabbitMQ trigger function processed: {myQueueItem}");
}

Köutlösare

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `queueTrigger`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Endast i filen function.json . Måste anges till `in`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som innehåller nyttolasten för köobjektet i funktionskoden.
queueName	Namnet på kön som ska avsökas.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Azure Queues. Se Anslut ioner.

I följande exempel visas en köutlösarbindning i en function.json-fil och C#-skriptkod som använder bindningen. Funktionen avsöker myqueue-items kön och skriver en logg varje gång ett köobjekt bearbetas.

Här är filen function.json :

{
    "disabled": false,
    "bindings": [
        {
            "type": "queueTrigger",
            "direction": "in",
            "name": "myQueueItem",
            "queueName": "myqueue-items",
            "connection":"MyStorageConnectionAppSetting"
        }
    ]
}

Här är C#-skriptkoden:

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.Extensions.Logging;
using Microsoft.WindowsAzure.Storage.Queue;
using System;

public static void Run(CloudQueueMessage myQueueItem, 
    DateTimeOffset expirationTime, 
    DateTimeOffset insertionTime, 
    DateTimeOffset nextVisibleTime,
    string queueTrigger,
    string id,
    string popReceipt,
    int dequeueCount,
    ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem.AsString}\n" +
        $"queueTrigger={queueTrigger}\n" +
        $"expirationTime={expirationTime}\n" +
        $"insertionTime={insertionTime}\n" +
        $"nextVisibleTime={nextVisibleTime}\n" +
        $"id={id}\n" +
        $"popReceipt={popReceipt}\n" + 
        $"dequeueCount={dequeueCount}");
}

Köutdata

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `queue`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Måste anges till `out`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som representerar kön i funktionskoden. Ange till för att referera till `$return` funktionens returvärde.
queueName	Namnet på kön.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Azure Queues. Se Anslut ioner.

I följande exempel visas en HTTP-utlösarbindning i en function.json-fil och C#-skriptkod som använder bindningen. Funktionen skapar ett köobjekt med en CustomQueueMessage-objektnyttolast för varje HTTP-begäran som tas emot.

Här är filen function.json :

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "authLevel": "function",
      "name": "input"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "$return",
      "queueName": "outqueue",
      "connection": "MyStorageConnectionAppSetting"
    }
  ]
}

Här är C#-skriptkoden som skapar ett enda kömeddelande:

public class CustomQueueMessage
{
    public string PersonName { get; set; }
    public string Title { get; set; }
}

public static CustomQueueMessage Run(CustomQueueMessage input, ILogger log)
{
    return input;
}

Du kan skicka flera meddelanden samtidigt med hjälp av en eller IAsyncCollector -ICollectorparameter. Här är C#-skriptkoden som skickar flera meddelanden, en med HTTP-begärandedata och en med hårdkodade värden:

public static void Run(
    CustomQueueMessage input, 
    ICollector<CustomQueueMessage> myQueueItems, 
    ILogger log)
{
    myQueueItems.Add(input);
    myQueueItems.Add(new CustomQueueMessage { PersonName = "You", Title = "None" });
}

Tabellindata

Det här avsnittet beskriver stöd för tabell-API-versionen av tillägget .

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `table`. Den här egenskapen anges automatiskt när du skapar bindningen i Azure-portalen.
riktning	Måste anges till `in`. Den här egenskapen anges automatiskt när du skapar bindningen i Azure-portalen.
Namn	Namnet på variabeln som representerar tabellen eller entiteten i funktionskoden.
Tablename	Tabellens namn.
partitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas.
rowKey	Valfritt. Radnyckeln för tabellentiteten som ska läsas. Det går inte att använda med `take` eller `filter`.
Ta	Valfritt. Det maximala antalet entiteter som ska returneras. Det går inte att använda med `rowKey`.
filter	Valfritt. Ett OData-filteruttryck som entiteterna ska returnera från tabellen. Det går inte att använda med `rowKey`.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslut ioner.

I följande exempel visas en tabellindatabindning i en function.json-fil och C#-skriptkod som använder bindningen. Funktionen använder en köutlösare för att läsa en enskild tabellrad.

Filen function.json anger en partitionKey och en rowKey. Värdet rowKey{queueTrigger} anger att radnyckeln kommer från kömeddelandesträngen.

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "personEntity",
      "type": "table",
      "tableName": "Person",
      "partitionKey": "Test",
      "rowKey": "{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

#r "Azure.Data.Tables"
using Microsoft.Extensions.Logging;
using Azure.Data.Tables;

public static void Run(string myQueueItem, Person personEntity, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    log.LogInformation($"Name in Person entity: {personEntity.Name}");
}

public class Person : ITableEntity
{
    public string Name { get; set; }

    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }
}

Tabellutdata

Det här avsnittet beskriver stöd för tabell-API-versionen av tillägget .

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `table`. Den här egenskapen anges automatiskt när du skapar bindningen i Azure-portalen.
riktning	Måste anges till `out`. Den här egenskapen anges automatiskt när du skapar bindningen i Azure-portalen.
Namn	Variabelnamnet som används i funktionskoden som representerar tabellen eller entiteten. Ange till för att referera till `$return` funktionens returvärde.
Tablename	Namnet på den tabell som ska skrivas till.
partitionKey	Partitionsnyckeln för tabellentiteten som ska skrivas.
rowKey	Radnyckeln för tabellentiteten som ska skrivas.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslut ioner.

I följande exempel visas en tabellutdatabindning i en function.json-fil och C#-skriptkod som använder bindningen. Funktionen skriver flera tabellentiteter.

Här är filen function.json :

{
  "bindings": [
    {
      "name": "input",
      "type": "manualTrigger",
      "direction": "in"
    },
    {
      "tableName": "Person",
      "connection": "MyStorageConnectionAppSetting",
      "name": "tableBinding",
      "type": "table",
      "direction": "out"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

public static void Run(string input, ICollector<Person> tableBinding, ILogger log)
{
    for (int i = 1; i < 10; i++)
        {
            log.LogInformation($"Adding Person entity {i}");
            tableBinding.Add(
                new Person() { 
                    PartitionKey = "Test", 
                    RowKey = i.ToString(), 
                    Name = "Name" + i.ToString() }
                );
        }

}

public class Person
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
}

Timerutlösare

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `timerTrigger`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Måste anges till `in`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som representerar det tidsinställda objektet i funktionskoden.
schedule	Ett CRON-uttryck eller ett TimeSpan-värde . En `TimeSpan` kan endast användas för en funktionsapp som körs på en App Service-plan. Du kan placera schemauttrycket i en appinställning och ange den här egenskapen till namnet på appinställningen som omsluts i % tecken, som i det här exemplet: %ScheduleAppSetting%.
runOnStartup	Om `true`anropas funktionen när körningen startar. Körningen startar till exempel när funktionsappen aktiveras efter inaktivitet, när funktionsappen startas om på grund av funktionsändringar och när funktionsappen skalar ut. Använd med försiktighet.runOnStartup bör sällan eller aldrig anges till `true`, särskilt i produktion.
useMonitor	Ange till `true` eller `false` för att indikera om schemat ska övervakas. Schemaövervakning bevarar schemaförekomster för att säkerställa att schemat underhålls korrekt även när funktionsappinstanser startas om. Om den inte anges explicit är `true` standardvärdet för scheman som har ett upprepningsintervall som är större än eller lika med 1 minut. För scheman som utlöses mer än en gång per minut är `false`standardvärdet .

I följande exempel visas en timerutlösarbindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen skriver en logg som anger om funktionens anrop beror på en utebliven schemahändelse. Objektet TimerInfo skickas till funktionen.

Här är bindningsdata i filen function.json :

{
    "schedule": "0 */5 * * * *",
    "name": "myTimer",
    "type": "timerTrigger",
    "direction": "in"
}

Här är C#-skriptkoden:

public static void Run(TimerInfo myTimer, ILogger log)
{
    if (myTimer.IsPastDue)
    {
        log.LogInformation("Timer is running late!");
    }
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}" );  
}

HTTP-utlösare

I följande tabell förklaras de egenskaper för utlösarkonfiguration som du anger i filen function.json :

function.json-egenskap	beskrivning
typ	Obligatoriskt – måste anges till `httpTrigger`.
riktning	Obligatoriskt – måste anges till `in`.
Namn	Obligatoriskt – variabelnamnet som används i funktionskoden för begäran eller begärandetexten.
authLevel	Avgör vilka nycklar, om några, som måste finnas på begäran för att anropa funktionen. För värden som stöds, se auktoriseringsnivå.
Metoder	En matris med DE HTTP-metoder som funktionen svarar på. Om den inte anges svarar funktionen på alla HTTP-metoder. Se anpassa HTTP-slutpunkten.
Rutt	Definierar routningsmallen och styr till vilka url:er för begäran som din funktion svarar på. Standardvärdet om inget anges är `<functionname>`. Mer information finns i anpassa HTTP-slutpunkten.
webHookType	Stöds endast för version 1.x-körningen. Konfigurerar HTTP-utlösaren så att den fungerar som en webhook-mottagare för den angivna providern. Mer information om värden som stöds finns i WebHook-typ.

I följande exempel visas en utlösarbindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

Här är filen function.json :

{
    "disabled": false,
    "bindings": [
        {
            "authLevel": "function",
            "name": "req",
            "type": "httpTrigger",
            "direction": "in",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "name": "$return",
            "type": "http",
            "direction": "out"
        }
    ]
}

Här är C#-skriptkoden som binder till HttpRequest:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];
    
    string requestBody = String.Empty;
    using (StreamReader streamReader =  new  StreamReader(req.Body))
    {
        requestBody = await streamReader.ReadToEndAsync();
    }
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;
    
    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

Du kan binda till ett anpassat objekt i stället för HttpRequest. Det här objektet skapas från brödtexten i begäran och tolkas som JSON. På samma sätt kan en typ skickas till HTTP-svarsutdatabindningen och returneras som svarstext, tillsammans med en 200 statuskod.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static string Run(Person person, ILogger log)
{   
    return person.Name != null
        ? (ActionResult)new OkObjectResult($"Hello, {person.Name}")
        : new BadRequestObjectResult("Please pass an instance of Person.");
}

public class Person {
     public string Name {get; set;}
}

HTTP-utdata

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

Property	Beskrivning
typ	Måste anges till `http`.
riktning	Måste anges till `out`.
Namn	Variabelnamnet som används i funktionskoden för svaret eller `$return` för att använda returvärdet.

Event Hubs-utlösare

I följande tabell förklaras de egenskaper för utlösarkonfiguration som du anger i filen function.json :

function.json-egenskap	beskrivning
typ	Måste anges till `eventHubTrigger`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Måste anges till `in`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som representerar händelseobjektet i funktionskoden.
eventHubName	Funktioner 2.x och senare. Namnet på händelsehubben. När händelsehubbens namn också finns i anslutningssträng åsidosätter det värdet den här egenskapen vid körning. Kan refereras via appinställningar`%eventHubName%`. I version 1.x heter `path`den här egenskapen .
consumerGroup	En valfri egenskap som anger den konsumentgrupp som används för att prenumerera på händelser i hubben. Om den `$Default` utelämnas används konsumentgruppen.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Event Hubs. Se Anslut ioner.

I följande exempel visas en Event Hubs-utlösarbindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen loggar meddelandetexten för Event Hubs-utlösaren.

I följande exempel visas Event Hubs-bindningsdata i filen function.json för Functions runtime version 2.x och senare versioner.

{
  "type": "eventHubTrigger",
  "name": "myEventHubMessage",
  "direction": "in",
  "eventHubName": "MyEventHub",
  "connection": "myEventHubReadConnectionAppSetting"
}

Här är C#-skriptkoden:

using System;

public static void Run(string myEventHubMessage, TraceWriter log)
{
    log.Info($"C# function triggered to process a message: {myEventHubMessage}");
}

Om du vill få åtkomst till händelsemetadata i funktionskoden binder du till ett EventData-objekt . Du kan också komma åt samma egenskaper med hjälp av bindningsuttryck i metodsignaturen. I följande exempel visas båda sätten att hämta samma data:

#r "Microsoft.Azure.EventHubs"

using System.Text;
using System;
using Microsoft.ServiceBus.Messaging;
using Microsoft.Azure.EventHubs;

public void Run(EventData myEventHubMessage,
    DateTime enqueuedTimeUtc,
    Int64 sequenceNumber,
    string offset,
    TraceWriter log)
{
    log.Info($"Event: {Encoding.UTF8.GetString(myEventHubMessage.Body)}");
    log.Info($"EnqueuedTimeUtc={myEventHubMessage.SystemProperties.EnqueuedTimeUtc}");
    log.Info($"SequenceNumber={myEventHubMessage.SystemProperties.SequenceNumber}");
    log.Info($"Offset={myEventHubMessage.SystemProperties.Offset}");

    // Metadata accessed by using binding expressions
    log.Info($"EnqueuedTimeUtc={enqueuedTimeUtc}");
    log.Info($"SequenceNumber={sequenceNumber}");
    log.Info($"Offset={offset}");
}

Om du vill ta emot händelser i en batch skapar string du eller EventData en matris:

public static void Run(string[] eventHubMessages, TraceWriter log)
{
    foreach (var message in eventHubMessages)
    {
        log.Info($"C# function triggered to process a message: {message}");
    }
}

Event Hubs-utdata

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `eventHub`.
riktning	Måste anges till `out`. Den här parametern anges automatiskt när du skapar bindningen i Azure-portalen.
Namn	Variabelnamnet som används i funktionskoden som representerar händelsen.
eventHubName	Funktioner 2.x och senare. Namnet på händelsehubben. När händelsehubbens namn också finns i anslutningssträng åsidosätter det värdet den här egenskapen vid körning. I Functions 1.x heter `path`den här egenskapen .
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Event Hubs. Mer information finns i Anslut ions.

I följande exempel visas en utlösarbindning för händelsehubben i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen skriver ett meddelande till en händelsehubb.

I följande exempel visas Event Hubs-bindningsdata i filen function.json för Functions runtime version 2.x och senare versioner.

{
    "type": "eventHub",
    "name": "outputEventHubMessage",
    "eventHubName": "myeventhub",
    "connection": "MyEventHubSendAppSetting",
    "direction": "out"
}

Här är C#-skriptkoden som skapar ett meddelande:

using System;
using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, out string outputEventHubMessage, ILogger log)
{
    String msg = $"TimerTriggerCSharp1 executed at: {DateTime.Now}";
    log.LogInformation(msg);   
    outputEventHubMessage = msg;
}

Här är C#-skriptkoden som skapar flera meddelanden:

public static void Run(TimerInfo myTimer, ICollector<string> outputEventHubMessage, ILogger log)
{
    string message = $"Message created at: {DateTime.Now}";
    log.LogInformation(message);
    outputEventHubMessage.Add("1 " + message);
    outputEventHubMessage.Add("2 " + message);
}

Välj Event Grid-utlösare

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json . Det finns inga konstruktorparametrar eller egenskaper att ange i attributet EventGridTrigger .

function.json-egenskap	beskrivning
typ	Obligatoriskt – måste anges till `eventGridTrigger`.
riktning	Obligatoriskt – måste anges till `in`.
Namn	Obligatoriskt – variabelnamnet som används i funktionskoden för parametern som tar emot händelsedata.

I följande exempel visas en Event Grid-utlösare som definierats i filen function.json .

Här är bindningsdata i filen function.json :

{
  "bindings": [
    {
      "type": "eventGridTrigger",
      "name": "eventGridEvent",
      "direction": "in"
    }
  ],
  "disabled": false
}

Här är ett exempel på en C#-skriptfunktion som använder en bindningsparameter EventGridEvent :

#r "Azure.Messaging.EventGrid"
using Azure.Messaging.EventGrid;
using Microsoft.Extensions.Logging;

public static void Run(EventGridEvent eventGridEvent, ILogger log)
{
    log.LogInformation(eventGridEvent.Data.ToString());
}

Här är ett exempel på en C#-skriptfunktion som använder en JObject bindningsparameter:

#r "Newtonsoft.Json"

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public static void Run(JObject eventGridEvent, TraceWriter log)
{
    log.Info(eventGridEvent.ToString(Formatting.Indented));
}

Event Grid-utdata

I följande tabell beskrivs bindningskonfigurationsegenskaperna för C#-skriptet som du angav i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `eventGrid`.
riktning	Måste anges till `out`. Den här parametern anges automatiskt när du skapar bindningen i Azure-portalen.
Namn	Variabelnamnet som används i funktionskoden som representerar händelsen.
topicEndpointUri	Namnet på en appinställning som innehåller URI:n för det anpassade ämnet, till exempel `MyTopicEndpointUri`.
topicKeySetting	Namnet på en appinställning som innehåller en åtkomstnyckel för det anpassade ämnet.

I följande exempel visas Event Grid-utdatabindningsdata i filen function.json .

{
    "type": "eventGrid",
    "name": "outputEvent",
    "topicEndpointUri": "MyEventGridTopicUriSetting",
    "topicKeySetting": "MyEventGridTopicKeySetting",
    "direction": "out"
}

Här är C#-skriptkoden som skapar en händelse:

#r "Microsoft.Azure.EventGrid"
using System;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, out EventGridEvent outputEvent, ILogger log)
{
    outputEvent = new EventGridEvent("message-id", "subject-name", "event-data", "event-type", DateTime.UtcNow, "1.0");
}

Här är C#-skriptkoden som skapar flera händelser:

#r "Microsoft.Azure.EventGrid"
using System;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, ICollector<EventGridEvent> outputEvent, ILogger log)
{
    outputEvent.Add(new EventGridEvent("message-id-1", "subject-name", "event-data", "event-type", DateTime.UtcNow, "1.0"));
    outputEvent.Add(new EventGridEvent("message-id-2", "subject-name", "event-data", "event-type", DateTime.UtcNow, "1.0"));
}

Service Bus-utlösare

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `serviceBusTrigger`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Måste anges till `in`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som representerar kön eller ämnesmeddelandet i funktionskoden.
queueName	Namnet på kön som ska övervakas. Ange endast om du övervakar en kö, inte för ett ämne.
topicName	Namnet på det ämne som ska övervakas. Ange endast om du övervakar ett ämne, inte för en kö.
subscriptionName	Namnet på prenumerationen som ska övervakas. Ange endast om du övervakar ett ämne, inte för en kö.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Service Bus. Se Anslut ioner.
accessRights	Åtkomsträttigheter för anslutningssträng. Tillgängliga värden är `manage` och `listen`. Standardvärdet är `manage`, vilket anger att `connection` har behörigheten Hantera . Om du använder en anslutningssträng som inte har behörigheten Hantera anger du `accessRights` till "lyssna". Annars kan Functions-körningen misslyckas med att utföra åtgärder som kräver hanteringsrättigheter. I Azure Functions version 2.x och senare är den här egenskapen inte tillgänglig eftersom den senaste versionen av Service Bus SDK inte stöder hanteringsåtgärder.
isSessionsEnabled	`true` om du ansluter till en sessionsmedveten kö eller prenumeration. `false` annars, vilket är standardvärdet.
Komplettera automatiskt	`true` när utlösaren ska anropas automatiskt efter bearbetningen, eller om funktionskoden anropas manuellt. Inställningen till `false` stöds endast i C#. Om värdet är `true`inställt på slutför utlösaren meddelandet automatiskt om funktionskörningen har slutförts och avger meddelandet på annat sätt. <br/When set to `false`, you are responsible for calling ServiceBusReceiver methods to complete, abandon, or deadletter the message, session, or batch. När ett undantag utlöses (och ingen av `ServiceBusReceiver` metoderna anropas) förblir låset kvar. När låset upphör att gälla placeras meddelandet i kö igen med det `DeliveryCount` inkrementerade och låset förnyas automatiskt. Den här egenskapen är endast tillgänglig i Azure Functions 2.x och senare.

I följande exempel visas en Service Bus-utlösarbindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen läser meddelandemetadata och loggar ett Service Bus-kömeddelande.

Här är bindningsdata i filen function.json :

{
"bindings": [
    {
    "queueName": "testqueue",
    "connection": "MyServiceBusConnection",
    "name": "myQueueItem",
    "type": "serviceBusTrigger",
    "direction": "in"
    }
],
"disabled": false
}

Här är C#-skriptkoden:

using System;

public static void Run(string myQueueItem,
    Int32 deliveryCount,
    DateTime enqueuedTimeUtc,
    string messageId,
    TraceWriter log)
{
    log.Info($"C# ServiceBus queue trigger function processed message: {myQueueItem}");

    log.Info($"EnqueuedTimeUtc={enqueuedTimeUtc}");
    log.Info($"DeliveryCount={deliveryCount}");
    log.Info($"MessageId={messageId}");
}

Service Bus-utdata

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `serviceBus`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
riktning	Måste anges till `out`. Den här egenskapen anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Namnet på variabeln som representerar kön eller ämnesmeddelandet i funktionskoden. Ange till "$return" för att referera till funktionens returvärde.
queueName	Namn på kön. Ange endast om du skickar kömeddelanden, inte för ett ämne.
topicName	Namnet på ämnet. Ange endast om du skickar ämnesmeddelanden, inte för en kö.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till Service Bus. Se Anslut ioner.
accessRights (endast v1)	Åtkomsträttigheter för anslutningssträng. Tillgängliga värden är `manage` och `listen`. Standardvärdet är `manage`, vilket anger att `connection` har behörigheten Hantera . Om du använder en anslutningssträng som inte har behörigheten Hantera anger du `accessRights` till "lyssna". Annars kan Functions-körningen misslyckas med att utföra åtgärder som kräver hanteringsrättigheter. I Azure Functions version 2.x och senare är den här egenskapen inte tillgänglig eftersom den senaste versionen av Service Bus SDK inte stöder hanteringsåtgärder.

I följande exempel visas en Service Bus-utdatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen använder en timerutlösare för att skicka ett kömeddelande var 15:e sekund.

Här är bindningsdata i filen function.json :

{
    "bindings": [
        {
            "schedule": "0/15 * * * * *",
            "name": "myTimer",
            "runsOnStartup": true,
            "type": "timerTrigger",
            "direction": "in"
        },
        {
            "name": "outputSbQueue",
            "type": "serviceBus",
            "queueName": "testqueue",
            "connection": "MyServiceBusConnection",
            "direction": "out"
        }
    ],
    "disabled": false
}

Här är C#-skriptkoden som skapar ett enda meddelande:

public static void Run(TimerInfo myTimer, ILogger log, out string outputSbQueue)
{
    string message = $"Service Bus queue message created at: {DateTime.Now}";
    log.LogInformation(message); 
    outputSbQueue = message;
}

Här är C#-skriptkoden som skapar flera meddelanden:

public static async Task Run(TimerInfo myTimer, ILogger log, IAsyncCollector<string> outputSbQueue)
{
    string message = $"Service Bus queue messages created at: {DateTime.Now}";
    log.LogInformation(message); 
    await outputSbQueue.AddAsync("1 " + message);
    await outputSbQueue.AddAsync("2 " + message);
}

Azure Cosmos DB v2-utlösare

I det här avsnittet beskrivs stöd för version 4.x+ av tillägget .

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `cosmosDBTrigger`.
riktning	Måste anges till `in`. Den här parametern anges automatiskt när du skapar utlösaren i Azure-portalen.
Namn	Variabelnamnet som används i funktionskoden som representerar listan över dokument med ändringar.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till det Azure Cosmos DB-konto som övervakas. Mer information finns i Anslut ions.
Databasename	Namnet på Azure Cosmos DB-databasen med containern som övervakas.
containerName	Namnet på containern som övervakas.
lån Anslut ion	(Valfritt) Namnet på en appinställning eller inställningscontainer som anger hur du ansluter till det Azure Cosmos DB-konto som innehåller lånecontainern. När värdet inte har angetts används det `connection` . Den här parametern anges automatiskt när bindningen skapas i portalen. Anslutningssträng för lånecontainern måste ha skrivbehörighet.
leaseDatabaseName	(Valfritt) Namnet på databasen som innehåller containern som används för att lagra lån. När inställningen inte har angetts används värdet för inställningen `databaseName` .
leaseContainerName	(Valfritt) Namnet på containern som används för att lagra lån. När värdet inte har angetts används det `leases` .
createLeaseContainerIfNotExists	(Valfritt) När den är inställd `true`på skapas lånecontainern automatiskt när den inte redan finns. Standardvärdet är `false`. När du använder Microsoft Entra-identiteter om du anger värdet till är det inte tillåtet att `true`skapa containrar och funktionen kan inte starta.
leasesContainerThroughput	(Valfritt) Definierar antalet enheter för begäranden som ska tilldelas när lånecontainern skapas. Den här inställningen används endast när `createLeaseContainerIfNotExists` är inställd på `true`. Den här parametern anges automatiskt när bindningen skapas med hjälp av portalen.
leaseContainerPrefix	(Valfritt) När värdet anges läggs det till som ett prefix till lånen som skapats i lånecontainern för den här funktionen. Med hjälp av ett prefix kan två separata Azure Functions dela samma lånecontainer med hjälp av olika prefix.
feedPollDelay	(Valfritt) Tiden (i millisekunder) för fördröjningen mellan avsökningen av en partition för nya ändringar i flödet, när alla aktuella ändringar har tömts. Standardvärdet är 5 000 millisekunder eller 5 sekunder.
leaseAcquireInterval	(Valfritt) När den anges definierar den i millisekunder intervallet för att starta en uppgift för att beräkna om partitioner fördelas jämnt mellan kända värdinstanser. Standardvärdet är 13 000 (13 sekunder).
leaseExpirationInterval	(Valfritt) När den anges definierar den i millisekunder det intervall för vilket lånet tas på ett lån som representerar en partition. Om lånet inte förnyas inom det här intervallet upphör det att gälla och ägarskapet för partitionen flyttas till en annan instans. Standardvärdet är 60000 (60 sekunder).
leaseRenewInterval	(Valfritt) När den anges definierar den, i millisekunder, förnyelseintervallet för alla lån för partitioner som för närvarande innehas av en instans. Standardvärdet är 17 000 (17 sekunder).
maxItemsPerInvocation	(Valfritt) När den här egenskapen anges anger den maximala antalet objekt som tas emot per funktionsanrop. Om åtgärder i den övervakade containern utförs via lagrade procedurer bevaras transaktionsomfånget vid läsning av objekt från ändringsflödet. Därför kan antalet mottagna objekt vara högre än det angivna värdet så att objekten som ändras av samma transaktion returneras som en del av en atomisk batch.
startFromBeginning	(Valfritt) Det här alternativet instruerar utlösaren att läsa ändringar från början av containerns ändringshistorik i stället för att starta vid den aktuella tidpunkten. Läsning från början fungerar bara första gången utlösaren startar, eftersom kontrollpunkterna redan lagras i efterföljande körningar. Om du anger det här alternativet till `true` när lån som redan har skapats inte har någon effekt.
startFromTime	(Valfritt) Hämtar eller anger datum och tid från vilken ändringsflödesläsningen ska initieras. Det rekommenderade formatet är ISO 8601 med UTC-designatorn, till exempel `2021-02-16T14:19:29Z`. Detta används endast för att ange det inledande utlösartillståndet. När utlösaren har ett lånetillstånd har det ingen effekt att ändra det här värdet.
preferredLocations	(Valfritt) Definierar önskade platser (regioner) för geo-replikerade databaskonton i Azure Cosmos DB-tjänsten. Värden bör kommaavgränsas. Till exempel "USA, östra, USA, södra centrala, Europa, norra".

I följande exempel visas en Azure Cosmos DB-utlösarbindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen skriver loggmeddelanden när Azure Cosmos DB-poster läggs till eller ändras.

Här är bindningsdata i filen function.json :

{
    "type": "cosmosDBTrigger",
    "name": "documents",
    "direction": "in",
    "leaseContainerName": "leases",
    "connection": "<connection-app-setting>",
    "databaseName": "Tasks",
    "containerName": "Items",
    "createLeaseContainerIfNotExists": true
}

Här är C#-skriptkoden:

    using System;
    using System.Collections.Generic;
    using Microsoft.Extensions.Logging;

    // Customize the model with your own desired properties
    public class ToDoItem
    {
        public string id { get; set; }
        public string Description { get; set; }
    }

    public static void Run(IReadOnlyList<ToDoItem> documents, ILogger log)
    {
      log.LogInformation("Documents modified " + documents.Count);
      log.LogInformation("First document Id " + documents[0].id);
    }

Azure Cosmos DB v2-indata

I det här avsnittet beskrivs stöd för version 4.x+ av tillägget .

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	beskrivning
typ	Måste anges till `cosmosDB`.
riktning	Måste anges till `in`.
Namn	Variabelnamnet som används i funktionskoden som representerar listan över dokument med ändringar.
Anslutning	Namnet på en appinställning eller inställningscontainer som anger hur du ansluter till det Azure Cosmos DB-konto som övervakas. Mer information finns i Anslut ions.
Databasename	Namnet på Azure Cosmos DB-databasen med containern som övervakas.
containerName	Namnet på containern som övervakas.
partitionKey	Anger partitionsnyckelvärdet för sökningen. Kan innehålla bindningsparametrar. Det krävs för sökningar i partitionerade containrar.
id	ID:t för dokumentet som ska hämtas. Den här egenskapen stöder bindningsuttryck. Ange inte både `id` egenskaperna och `sqlQuery` . Om du inte anger någon av dem hämtas hela containern.
sqlQuery	En Azure Cosmos DB SQL-fråga som används för att hämta flera dokument. Egenskapen stöder runtime-bindningar, som i det här exemplet: `SELECT * FROM c where c.departmentId = {departmentId}`. Ange inte både `id` egenskaperna och `sqlQuery` . Om du inte anger någon av dem hämtas hela containern.
preferredLocations	(Valfritt) Definierar önskade platser (regioner) för geo-replikerade databaskonton i Azure Cosmos DB-tjänsten. Värden bör kommaavgränsas. Exempel: `East US,South Central US,North Europe`

Det här avsnittet innehåller följande exempel:

Köutlösare, leta upp ID från sträng
Köutlösare, hämta flera dokument med hjälp av SqlQuery
HTTP-utlösare, leta upp ID från frågesträng
HTTP-utlösare, leta upp ID från routningsdata
HTTP-utlösare, hämta flera dokument med hjälp av SqlQuery
HTTP-utlösare, hämta flera dokument med hjälp av DocumentClient

HTTP-utlösarexemplen refererar till en enkel ToDoItem typ:

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Köutlösare, leta upp ID från sträng

I följande exempel visas en Azure Cosmos DB-indatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen läser ett enda dokument och uppdaterar dokumentets textvärde.

Här är bindningsdata i filen function.json :

{
    "name": "inputDocument",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger}",
    "partitionKey": "{partition key value}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "in"
}

Här är C#-skriptkoden:

    using System;

    // Change input document contents using Azure Cosmos DB input binding
    public static void Run(string myQueueItem, dynamic inputDocument)
    {
      inputDocument.text = "This has changed.";
    }

Köutlösare, hämta flera dokument med hjälp av SqlQuery

I följande exempel visas en Azure Cosmos DB-indatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen hämtar flera dokument som anges av en SQL-fråga med hjälp av en köutlösare för att anpassa frågeparametrarna.

Köutlösaren innehåller en parameter departmentId. Ett kömeddelande för { "departmentId" : "Finance" } returnerar alla poster för ekonomiavdelningen.

Här är bindningsdata i filen function.json :

{
    "name": "documents",
    "type": "cosmosDB",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connectionStringSetting": "CosmosDBConnection"
}

Här är C#-skriptkoden:

    public static void Run(QueuePayload myQueueItem, IEnumerable<dynamic> documents)
    {
        foreach (var doc in documents)
        {
            // operate on each document
        }
    }

    public class QueuePayload
    {
        public string departmentId { get; set; }
    }

HTTP-utlösare, leta upp ID från frågesträng

I följande exempel visas en C#-skriptfunktion som hämtar ett enda dokument. Funktionen utlöses av en HTTP-begäran som använder en frågesträng för att ange det ID och partitionsnyckelvärde som ska sökas upp. Det ID- och partitionsnyckelvärdet används för att hämta ett ToDoItem dokument från den angivna databasen och samlingen.

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}",
      "PartitionKey" : "{Query.partitionKeyValue}"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System.Net;
using Microsoft.Extensions.Logging;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
         log.LogInformation($"ToDo item not found");
    }
    else
    {
        log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP-utlösare, leta upp ID från routningsdata

I följande exempel visas en C#-skriptfunktion som hämtar ett enda dokument. Funktionen utlöses av en HTTP-begäran som använder routningsdata för att ange det ID och partitionsnyckelvärde som ska sökas upp. Det ID- och partitionsnyckelvärdet används för att hämta ett ToDoItem dokument från den angivna databasen och samlingen.

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{partitionKeyValue}/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "id": "{id}",
      "partitionKey": "{partitionKeyValue}"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System.Net;
using Microsoft.Extensions.Logging;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
         log.LogInformation($"ToDo item not found");
    }
    else
    {
        log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP-utlösare, hämta flera dokument med hjälp av SqlQuery

I följande exempel visas en C#-skriptfunktion som hämtar en lista med dokument. Funktionen utlöses av en HTTP-begäran. Frågan anges i attributegenskapen SqlQuery .

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System.Net;
using Microsoft.Extensions.Logging;

public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    foreach (ToDoItem toDoItem in toDoItems)
    {
        log.LogInformation(toDoItem.Description);
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP-utlösare, hämta flera dokument med hjälp av DocumentClient

I följande exempel visas en C#-skriptfunktion som hämtar en lista med dokument. Funktionen utlöses av en HTTP-begäran. Koden använder en DocumentClient instans som tillhandahålls av Azure Cosmos DB-bindningen för att läsa en lista med dokument. Instansen DocumentClient kan också användas för skrivåtgärder.

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "client",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "inout"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.Documents.Client"

using System.Net;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Microsoft.Extensions.Logging;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");
    string searchterm = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "searchterm", true) == 0)
        .Value;

    if (searchterm == null)
    {
        return req.CreateResponse(HttpStatusCode.NotFound);
    }

    log.LogInformation($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");
    IDocumentQuery<ToDoItem> query = client.CreateDocumentQuery<ToDoItem>(collectionUri)
        .Where(p => p.Description.Contains(searchterm))
        .AsDocumentQuery();

    while (query.HasMoreResults)
    {
        foreach (ToDoItem result in await query.ExecuteNextAsync())
        {
            log.LogInformation(result.Description);
        }
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Azure Cosmos DB v2-utdata

I det här avsnittet beskrivs stöd för version 4.x+ av tillägget .

I följande tabell beskrivs de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json-egenskap	beskrivning
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till det Azure Cosmos DB-konto som övervakas. Mer information finns i Anslut ions.
Databasename	Namnet på Azure Cosmos DB-databasen med containern som övervakas.
containerName	Namnet på containern som övervakas.
createIfNotExists	Ett booleskt värde som anger om containern skapas när den inte finns. Standardvärdet är falskt eftersom nya containrar skapas med reserverat dataflöde, vilket har kostnadskonsekvenser. Mer information, se prissidan.
partitionKey	När `createIfNotExists` är sant definierar den partitionsnyckelsökvägen för den skapade containern. Kan innehålla bindningsparametrar.
containerThroughput	När `createIfNotExists` är sant definierar det dataflödet för den skapade containern.
preferredLocations	(Valfritt) Definierar önskade platser (regioner) för geo-replikerade databaskonton i Azure Cosmos DB-tjänsten. Värden bör kommaavgränsas. Exempel: `East US,South Central US,North Europe`

Det här avsnittet innehåller följande exempel:

Köutlösare, skriv ett dokument
Köutlösare, skriv dokument med IAsyncCollector

Köutlösare, skriv ett dokument

I följande exempel visas en Azure Cosmos DB-utdatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen använder en köindatabindning för en kö som tar emot JSON i följande format:

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Funktionen skapar Azure Cosmos DB-dokument i följande format för varje post:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Här är bindningsdata i filen function.json :

{
    "name": "employeeDocument",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "createIfNotExists": true,
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "out"
}

Här är C#-skriptkoden:

    #r "Newtonsoft.Json"

    using Microsoft.Azure.WebJobs.Host;
    using Newtonsoft.Json.Linq;
    using Microsoft.Extensions.Logging;

    public static void Run(string myQueueItem, out object employeeDocument, ILogger log)
    {
      log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

      dynamic employee = JObject.Parse(myQueueItem);

      employeeDocument = new {
        id = employee.name + "-" + employee.employeeId,
        name = employee.name,
        employeeId = employee.employeeId,
        address = employee.address
      };
    }

Köutlösare, skriv dokument med IAsyncCollector

Om du vill skapa flera dokument kan du binda till ICollector<T> eller IAsyncCollector<T> var T är en av de typer som stöds.

Det här exemplet refererar till en enkel ToDoItem typ:

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string id { get; set; }
        public string Description { get; set; }
    }
}

Här är filen function.json:

{
  "bindings": [
    {
      "name": "toDoItemsIn",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "todoqueueforwritemulti",
      "connectionStringSetting": "AzureWebJobsStorage"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItemsOut",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "out"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System;
using Microsoft.Extensions.Logging;

public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

    foreach (ToDoItem toDoItem in toDoItemsIn)
    {
        log.LogInformation($"Description={toDoItem.Description}");
        await toDoItemsOut.AddAsync(toDoItem);
    }
}

Azure Cosmos DB v1-utlösare

Här är bindningsdata i filen function.json :

{
    "type": "cosmosDBTrigger",
    "name": "documents",
    "direction": "in",
    "leaseCollectionName": "leases",
    "connectionStringSetting": "<connection-app-setting>",
    "databaseName": "Tasks",
    "collectionName": "Items",
    "createLeaseCollectionIfNotExists": true
}

Här är C#-skriptkoden:

    #r "Microsoft.Azure.Documents.Client"
    
    using System;
    using Microsoft.Azure.Documents;
    using System.Collections.Generic;
    

    public static void Run(IReadOnlyList<Document> documents, TraceWriter log)
    {
        log.Info("Documents modified " + documents.Count);
        log.Info("First document Id " + documents[0].Id);
    }

Azure Cosmos DB v1-indata

Det här avsnittet innehåller följande exempel:

Köutlösare, leta upp ID från sträng
Köutlösare, hämta flera dokument med hjälp av SqlQuery
HTTP-utlösare, leta upp ID från frågesträng
HTTP-utlösare, leta upp ID från routningsdata
HTTP-utlösare, hämta flera dokument med hjälp av SqlQuery
HTTP-utlösare, hämta flera dokument med hjälp av DocumentClient

HTTP-utlösarexemplen refererar till en enkel ToDoItem typ:

namespace CosmosDBSamplesV1
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Köutlösare, leta upp ID från sträng

Här är bindningsdata i filen function.json :

{
    "name": "inputDocument",
    "type": "documentDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger}",
    "partitionKey": "{partition key value}",
    "connection": "MyAccount_COSMOSDB",
    "direction": "in"
}

Här är C#-skriptkoden:

    using System;

    // Change input document contents using Azure Cosmos DB input binding
    public static void Run(string myQueueItem, dynamic inputDocument)
    {
        inputDocument.text = "This has changed.";
    }

Köutlösare, hämta flera dokument med hjälp av SqlQuery

Köutlösaren innehåller en parameter departmentId. Ett kömeddelande för { "departmentId" : "Finance" } returnerar alla poster för ekonomiavdelningen.

Här är bindningsdata i filen function.json :

{
    "name": "documents",
    "type": "documentdb",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connection": "CosmosDBConnection"
}

Här är C#-skriptkoden:

    public static void Run(QueuePayload myQueueItem, IEnumerable<dynamic> documents)
    {
        foreach (var doc in documents)
        {
            // operate on each document
        }
    }

    public class QueuePayload
    {
        public string departmentId { get; set; }
    }

HTTP-utlösare, leta upp ID från frågesträng

I följande exempel visas en C#-skriptfunktion som hämtar ett enda dokument. Funktionen utlöses av en HTTP-begäran som använder en frågesträng för att ange vilket ID som ska sökas upp. Det ID:t används för att hämta ett ToDoItem dokument från den angivna databasen och samlingen.

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}"
    }
  ],
  "disabled": true
}

Här är C#-skriptkoden:

using System.Net;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
        log.Info($"ToDo item not found");
    }
    else
    {
        log.Info($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP-utlösare, leta upp ID från routningsdata

I följande exempel visas en C#-skriptfunktion som hämtar ett enda dokument. Funktionen utlöses av en HTTP-begäran som använder routningsdata för att ange det ID som ska sökas upp. Det ID:t används för att hämta ett ToDoItem dokument från den angivna databasen och samlingen.

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "Id": "{id}"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System.Net;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
        log.Info($"ToDo item not found");
    }
    else
    {
        log.Info($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP-utlösare, hämta flera dokument med hjälp av SqlQuery

I följande exempel visas en C#-skriptfunktion som hämtar en lista med dokument. Funktionen utlöses av en HTTP-begäran. Frågan anges i attributegenskapen SqlQuery .

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "toDoItems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System.Net;

public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    foreach (ToDoItem toDoItem in toDoItems)
    {
        log.Info(toDoItem.Description);
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP-utlösare, hämta flera dokument med hjälp av DocumentClient

Här är filen function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "client",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "inout"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.Documents.Client"

using System.Net;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");
    string searchterm = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "searchterm", true) == 0)
        .Value;

    if (searchterm == null)
    {
        return req.CreateResponse(HttpStatusCode.NotFound);
    }

    log.Info($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");
    IDocumentQuery<ToDoItem> query = client.CreateDocumentQuery<ToDoItem>(collectionUri)
        .Where(p => p.Description.Contains(searchterm))
        .AsDocumentQuery();

    while (query.HasMoreResults)
    {
        foreach (ToDoItem result in await query.ExecuteNextAsync())
        {
            log.Info(result.Description);
        }
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Azure Cosmos DB v1-utdata

Det här avsnittet innehåller följande exempel:

Köutlösare, skriv ett dokument
Köutlösare, skriv dokument med hjälp av IAsyncCollector

Köutlösare, skriv ett dokument

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Funktionen skapar Azure Cosmos DB-dokument i följande format för varje post:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Här är bindningsdata i filen function.json :

{
    "name": "employeeDocument",
    "type": "documentDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "createIfNotExists": true,
    "connection": "MyAccount_COSMOSDB",
    "direction": "out"
}

Här är C#-skriptkoden:

    #r "Newtonsoft.Json"

    using Microsoft.Azure.WebJobs.Host;
    using Newtonsoft.Json.Linq;

    public static void Run(string myQueueItem, out object employeeDocument, TraceWriter log)
    {
        log.Info($"C# Queue trigger function processed: {myQueueItem}");

        dynamic employee = JObject.Parse(myQueueItem);

        employeeDocument = new {
            id = employee.name + "-" + employee.employeeId,
            name = employee.name,
            employeeId = employee.employeeId,
            address = employee.address
        };
    }

Köutlösare, skriv dokument med IAsyncCollector

Om du vill skapa flera dokument kan du binda till ICollector<T> eller IAsyncCollector<T> var T är en av de typer som stöds.

Det här exemplet refererar till en enkel ToDoItem typ:

namespace CosmosDBSamplesV1
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Här är filen function.json:

{
  "bindings": [
    {
      "name": "toDoItemsIn",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "todoqueueforwritemulti",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "documentDB",
      "name": "toDoItemsOut",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "out"
    }
  ],
  "disabled": false
}

Här är C#-skriptkoden:

using System;

public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

    foreach (ToDoItem toDoItem in toDoItemsIn)
    {
        log.Info($"Description={toDoItem.Description}");
        await toDoItemsOut.AddAsync(toDoItem);
    }
}

Azure SQL-utlösare

Fler exempel för Azure SQL-utlösaren finns på GitHub-lagringsplatsen.

Exemplet refererar till en ToDoItem klass och en motsvarande databastabell:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Ändringsspårning är aktiverat i databasen och i tabellen:

ALTER DATABASE [SampleDatabase]
SET CHANGE_TRACKING = ON
(CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON);

ALTER TABLE [dbo].[ToDo]
ENABLE CHANGE_TRACKING;

SQL-utlösaren binder till en , en lista över SqlChange objekt var och en IReadOnlyList<SqlChange<T>>med två egenskaper:

Objekt: objektet som ändrades. Typen av objekt ska följa tabellschemat enligt vad som visas i ToDoItem klassen.
Åtgärd: ett värde från SqlChangeOperation uppräkningen. De möjliga värden är Insert, Update och Delete.

I följande exempel visas en SQL-utlösare i en function.json-fil och en C#-skriptfunktion som anropas när det finns ändringar i ToDo tabellen:

Följande är bindningsdata i filen function.json:

{
    "name": "todoChanges",
    "type": "sqlTrigger",
    "direction": "in",
    "tableName": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

Följande är C#-skriptfunktionen:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static void Run(IReadOnlyList<SqlChange<ToDoItem>> todoChanges, ILogger log)
{
    log.LogInformation($"C# SQL trigger function processed a request.");

    foreach (SqlChange<ToDoItem> change in todoChanges)
    {
        ToDoItem toDoItem = change.Item;
        log.LogInformation($"Change operation: {change.Operation}");
        log.LogInformation($"Id: {toDoItem.Id}, Title: {toDoItem.title}, Url: {toDoItem.url}, Completed: {toDoItem.completed}");
    }
}

Azure SQL-indata

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

HTTP-utlösare, hämta rad efter ID från frågesträng
HTTP-utlösare, ta bort rader

Exemplen refererar till en ToDoItem klass och en motsvarande databastabell:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

HTTP-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en Azure SQL-indatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen utlöses av en HTTP-begäran som använder en frågesträng för att ange ID:t. Det ID:t används för att hämta en ToDoItem post med den angivna frågan.

Kommentar

HTTP-frågesträngsparametern är skiftlägeskänslig.

Här är bindningsdata i filen function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

Här är C#-skriptkoden:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Collections.Generic;

public static IActionResult Run(HttpRequest req, ILogger log, IEnumerable<ToDoItem> todoItem)
{
    return new OkObjectResult(todoItem);
}

HTTP-utlösare, ta bort rader

I följande exempel visas en Azure SQL-indatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen för att köra en lagrad procedur med indata från frågeparametern FÖR HTTP-begäran. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

Den lagrade proceduren dbo.DeleteToDo måste skapas i SQL-databasen.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

Här är bindningsdata i filen function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace AzureSQL.ToDo
{
    public static class DeleteToDo
    {
        // delete all items or a specific item from querystring
        // returns remaining items
        // uses input binding with a stored procedure DeleteToDo to delete items and return remaining items
        [FunctionName("DeleteToDo")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "DeleteToDo", commandType: System.Data.CommandType.StoredProcedure, 
                parameters: "@Id={Query.id}", connectionStringSetting: "SqlConnectionString")] 
                IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

Här är C#-skriptkoden:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Collections.Generic;

public static IActionResult Run(HttpRequest req, ILogger log, IEnumerable<ToDoItem> todoItems)
{
    return new OkObjectResult(todoItems);
}

Azure SQL-utdata

Fler exempel för Azure SQL-utdatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

HTTP-utlösare, skriva poster till en tabell
HTTP-utlösare, skriv till två tabeller

Exemplen refererar till en ToDoItem klass och en motsvarande databastabell:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

HTTP-utlösare, skriva poster till en tabell

I följande exempel visas en SQL-utdatabindning i en function.json-fil och en C#-skriptfunktion som lägger till poster i en tabell med data som anges i en HTTP POST-begäran som en JSON-brödtext.

Följande är bindningsdata i filen function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

Följande är exempel på C#-skriptkod:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static IActionResult Run(HttpRequest req, ILogger log, out ToDoItem todoItem)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = new StreamReader(req.Body).ReadToEnd();
    todoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

    return new OkObjectResult(todoItem);
}

HTTP-utlösare, skriv till två tabeller

I följande exempel visas en SQL-utdatabindning i en function.json-fil och en C#-skriptfunktion som lägger till poster i en databas i två olika tabeller (dbo.ToDo och dbo.RequestLog), med data som anges i en HTTP POST-begäran som en JSON-brödtext och flera utdatabindningar.

Den andra tabellen, dbo.RequestLog, motsvarar följande definition:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Följande är bindningsdata i filen function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

Följande är exempel på C#-skriptkod:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static IActionResult Run(HttpRequest req, ILogger log, out ToDoItem todoItem, out RequestLog requestLog)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = new StreamReader(req.Body).ReadToEnd();
    todoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

    requestLog = new RequestLog();
    requestLog.RequestTimeStamp = DateTime.Now;
    requestLog.ItemCount = 1;

    return new OkObjectResult(todoItem);
}

public class RequestLog {
    public DateTime RequestTimeStamp { get; set; }
    public int ItemCount { get; set; }
}

RabbitMQ-utdata

I följande exempel visas en RabbitMQ-utdatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen läser i meddelandet från en HTTP-utlösare och matar ut det till RabbitMQ-kön.

Här är bindningsdata i filen function.json :

{
    "bindings": [
        {
            "type": "httpTrigger",
            "direction": "in",
            "authLevel": "function",
            "name": "input",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "type": "rabbitMQ",
            "name": "outputMessage",
            "queueName": "outputQueue",
            "connectionStringSetting": "rabbitMQConnectionAppSetting",
            "direction": "out"
        }
    ]
}

Här är C#-skriptkoden:

using System;
using Microsoft.Extensions.Logging;

public static void Run(string input, out string outputMessage, ILogger log)
{
    log.LogInformation(input);
    outputMessage = input;
}

SendGrid-utdata

I följande exempel visas en SendGrid-utdatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen.

Här är bindningsdata i filen function.json :

{
    "bindings": [
        {
          "type": "queueTrigger",
          "name": "mymsg",
          "queueName": "myqueue",
          "connection": "AzureWebJobsStorage",
          "direction": "in"
        },
        {
          "type": "sendGrid",
          "name": "$return",
          "direction": "out",
          "apiKey": "SendGridAPIKeyAsAppSetting",
          "from": "{FromEmail}",
          "to": "{ToEmail}"
        }
    ]
}

Här är C#-skriptkoden:

#r "SendGrid"

using System;
using SendGrid.Helpers.Mail;
using Microsoft.Azure.WebJobs.Host;

public static SendGridMessage Run(Message mymsg, ILogger log)
{
    SendGridMessage message = new SendGridMessage()
    {
        Subject = $"{mymsg.Subject}"
    };
    
    message.AddContent("text/plain", $"{mymsg.Content}");

    return message;
}
public class Message
{
    public string ToEmail { get; set; }
    public string FromEmail { get; set; }
    public string Subject { get; set; }
    public string Content { get; set; }
}

SignalR-utlösare

Här är exempel på bindningsdata i filen function.json :

{
    "type": "signalRTrigger",
    "name": "invocation",
    "hubName": "SignalRTest",
    "category": "messages",
    "event": "SendMessage",
    "parameterNames": [
        "message"
    ],
    "direction": "in"
}

Och här är koden:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using System;
using Microsoft.Azure.WebJobs.Extensions.SignalRService;
using Microsoft.Extensions.Logging;

public static void Run(InvocationContext invocation, string message, ILogger logger)
{
    logger.LogInformation($"Receive {message} from {invocationContext.ConnectionId}.");
}

SignalR-indata

I följande exempel visas en SignalR-anslutningsinformationsindatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen för att returnera anslutningsinformationen.

Här är bindningsdata i filen function.json :

Exempel function.json:

{
    "type": "signalRConnectionInfo",
    "name": "connectionInfo",
    "hubName": "chat",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "direction": "in"
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static SignalRConnectionInfo Run(HttpRequest req, SignalRConnectionInfo connectionInfo)
{
    return connectionInfo;
}

Du kan ange userId egenskapen för bindningen till värdet från antingen huvudet med hjälp av ett bindningsuttryck: {headers.x-ms-client-principal-id} eller {headers.x-ms-client-principal-name}.

Exempel function.json:

{
    "type": "signalRConnectionInfo",
    "name": "connectionInfo",
    "hubName": "chat",
    "userId": "{headers.x-ms-client-principal-id}",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "direction": "in"
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static SignalRConnectionInfo Run(HttpRequest req, SignalRConnectionInfo connectionInfo)
{
    // connectionInfo contains an access key token with a name identifier
    // claim set to the authenticated user
    return connectionInfo;
}

SignalR-utdata

Här är bindningsdata i filen function.json :

Exempel function.json:

{
  "type": "signalR",
  "name": "signalRMessages",
  "hubName": "<hub_name>",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    object message,
    IAsyncCollector<SignalRMessage> signalRMessages)
{
    return signalRMessages.AddAsync(
        new SignalRMessage
        {
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Du kan bara skicka ett meddelande till anslutningar som har autentiserats till en användare genom att ange användar-ID :t i SignalR-meddelandet.

Exempel function.json:

{
  "type": "signalR",
  "name": "signalRMessages",
  "hubName": "<hub_name>",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    object message,
    IAsyncCollector<SignalRMessage> signalRMessages)
{
    return signalRMessages.AddAsync(
        new SignalRMessage
        {
            // the message will only be sent to this user ID
            UserId = "userId1",
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Du kan bara skicka ett meddelande till anslutningar som har lagts till i en grupp genom att ange gruppnamnet i SignalR-meddelandet.

Exempel function.json:

{
  "type": "signalR",
  "name": "signalRMessages",
  "hubName": "<hub_name>",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Här är C#-skriptkoden:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    object message,
    IAsyncCollector<SignalRMessage> signalRMessages)
{
    return signalRMessages.AddAsync(
        new SignalRMessage
        {
            // the message will be sent to the group with this name
            GroupName = "myGroup",
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

SignalR Service tillåter att användare eller anslutningar läggs till i grupper. Meddelanden kan sedan skickas till en grupp. Du kan använda utdatabindningen SignalR för att hantera grupper.

I följande exempel läggs en användare till i en grupp.

Exempel på function.json

{
    "type": "signalR",
    "name": "signalRGroupActions",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "hubName": "chat",
    "direction": "out"
}

Run.csx

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    HttpRequest req,
    ClaimsPrincipal claimsPrincipal,
    IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
    var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
    return signalRGroupActions.AddAsync(
        new SignalRGroupAction
        {
            UserId = userIdClaim.Value,
            GroupName = "myGroup",
            Action = GroupAction.Add
        });
}

I följande exempel tar du bort en användare från en grupp.

Exempel på function.json

{
    "type": "signalR",
    "name": "signalRGroupActions",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "hubName": "chat",
    "direction": "out"
}

Run.csx

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    HttpRequest req,
    ClaimsPrincipal claimsPrincipal,
    IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
    var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
    return signalRGroupActions.AddAsync(
        new SignalRGroupAction
        {
            UserId = userIdClaim.Value,
            GroupName = "myGroup",
            Action = GroupAction.Remove
        });
}

Twilio-utdata

I följande exempel visas en Twilio-utdatabindning i en function.json-fil och en C#-skriptfunktion som använder bindningen. Funktionen använder en out parameter för att skicka ett textmeddelande.

Här är bindningsdata i filen function.json :

Exempel function.json:

{
  "type": "twilioSms",
  "name": "message",
  "accountSidSetting": "TwilioAccountSid",
  "authTokenSetting": "TwilioAuthToken",
  "from": "+1425XXXXXXX",
  "direction": "out",
  "body": "Azure Functions Testing"
}

Här är C#-skriptkoden:

#r "Newtonsoft.Json"
#r "Twilio"
#r "Microsoft.Azure.WebJobs.Extensions.Twilio"

using System;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Microsoft.Azure.WebJobs.Extensions.Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public static void Run(string myQueueItem, out CreateMessageOptions message,  ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

    // In this example the queue item is a JSON string representing an order that contains the name of a
    // customer and a mobile number to send text updates to.
    dynamic order = JsonConvert.DeserializeObject(myQueueItem);
    string msg = "Hello " + order.name + ", thank you for your order.";

    // You must initialize the CreateMessageOptions variable with the "To" phone number.
    message = new CreateMessageOptions(new PhoneNumber("+1704XXXXXXX"));

    // A dynamic message can be set instead of the body in the output binding. In this example, we use
    // the order information to personalize a text message.
    message.Body = msg;
}

Du kan inte använda utparametrar i asynkron kod. Här är ett asynkront C#-skriptkodexempel:

#r "Newtonsoft.Json"
#r "Twilio"
#r "Microsoft.Azure.WebJobs.Extensions.Twilio"

using System;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Microsoft.Azure.WebJobs.Extensions.Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public static async Task Run(string myQueueItem, IAsyncCollector<CreateMessageOptions> message,  ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

    // In this example the queue item is a JSON string representing an order that contains the name of a
    // customer and a mobile number to send text updates to.
    dynamic order = JsonConvert.DeserializeObject(myQueueItem);
    string msg = "Hello " + order.name + ", thank you for your order.";

    // You must initialize the CreateMessageOptions variable with the "To" phone number.
    CreateMessageOptions smsText = new CreateMessageOptions(new PhoneNumber("+1704XXXXXXX"));

    // A dynamic message can be set instead of the body in the output binding. In this example, we use
    // the order information to personalize a text message.
    smsText.Body = msg;

    await message.AddAsync(smsText);
}

Uppvärmningsutlösare

I följande exempel visas en uppvärmningsutlösare i en function.json-fil och en C#-skriptfunktion som körs på varje ny instans när den läggs till i din app.

Stöds inte för version 1.x av Functions-körningen.

Här är filen function.json :

{
    "bindings": [
        {
            "type": "warmupTrigger",
            "direction": "in",
            "name": "warmupContext"
        }
    ]
}

public static void Run(WarmupContext warmupContext, ILogger log)
{
    log.LogInformation("Function App instance is warm.");  
}

Nästa steg

Läs mer om utlösare och bindningar

Läs mer om metodtips för Azure Functions