Azure Functions C#-szkript (.csx) fejlesztői referencia

Cikk
10/18/2023

Ez a cikk az Azure Functions C#-szkript (.csx) használatával történő fejlesztésének bemutatása.

Fontos

A C#-szkript elsősorban a portálon belüli kényelmes használat érdekében támogatott, így gyorsan megkezdheti a C#-függvények létrehozását és futtatását. Éles minőségű alkalmazások esetén inkább helyben, lefordított C#-osztálykódtár-projektként kell fejlesztenie a C#-függvényeket. Ha tudni szeretné, hogyan migrálhat egy C#-szkriptprojektet egy C#-osztálytár (izolált feldolgozó) projektbe, olvassa el a C#-szkriptalkalmazás konvertálása C#-projektté című témakört.

Az Azure Functions segítségével a C# használatával az alábbi módokon fejleszthet függvényeket:

Típus	Végrehajtási folyamat	Kódbővítmény	Fejlesztői környezet	Segédlet
C#-szkript	folyamatban	.Csx	Portal Alapvető eszközök	Ez a cikk
C# osztálykódtár (izolált feldolgozó)	izolált feldolgozói folyamat	.cs	Visual Studio Visual Studio Code Alapvető eszközök	.NET izolált feldolgozói folyamatfüggvények
C# osztálykódtár (folyamatban)	folyamatban	.cs	Visual Studio Visual Studio Code Alapvető eszközök	Folyamatban lévő C# osztálytárfüggvények

A .csx működése

Az adatok metódusargumentumokkal kerülnek a C#-függvénybe. Az argumentumnevek egy function.json fájlban vannak megadva, és vannak előre definiált nevek a függvénynaplózóhoz és a lemondási jogkivonatokhoz való hozzáféréshez.

A .csx formátum lehetővé teszi, hogy kevesebb "kazánlemezt" írjon, és csak egy C# függvény írására összpontosítson. Ahelyett, hogy egy névtérben és osztályban mindent körbefuttatana, egyszerűen definiáljon egy metódust Run . Adja meg a fájl elején található összes szerelvényhivatkozást és névteret a szokásos módon.

A függvényalkalmazás .csx fájljai egy példány inicializálásakor lesznek lefordítva. Ez a fordítási lépés azt jelenti, hogy a C#-szkriptfüggvények esetében a hidegindítás hosszabb időt vehet igénybe a C# osztálykódtárakhoz képest. Ez a fordítási lépés azt is lehetővé teszi, hogy a C# szkriptfüggvények szerkeszthetők legyenek az Azure Portalon, míg a C# osztálykódtárak nem.

Mappastruktúra

A C#-szkriptprojekt mappastruktúrája a következő példához hasonlóan néz ki:

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

Van egy megosztott host.json fájl, amely a függvényalkalmazás konfigurálásához használható. Minden függvény saját kódfájllal (.csx) és kötéskonfigurációs fájllal (function.json) rendelkezik.

A Functions-futtatókörnyezet 2.x és újabb verzióiban szükséges kötéskiterjesztések a extensions.csproj fájlban vannak definiálva, a mappában lévő bin tényleges kódtárfájlokkal együtt. Helyi fejlesztéskor kötésbővítményeket kell regisztrálnia. Amikor függvényeket fejleszt az Azure Portalon, ezt a regisztrációt ön végzi el.

Kötés argumentumokhoz

A bemeneti vagy kimeneti adatok egy C#-szkriptfüggvény paraméteréhez vannak kötve a namefunction.json konfigurációs fájl tulajdonságán keresztül. Az alábbi példa egy function.json fájlt és egy üzenetsor által aktivált függvény run.csx fájlját mutatja be. Az üzenetsor üzenetéből adatokat fogadó paraméter neve azért van, myQueueItem mert ez a name tulajdonság értéke.

{
    "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}");
}

Az #r állítást a cikk későbbi részében ismertetik.

A kötések támogatott típusai

Minden kötés saját támogatott típusokkal rendelkezik; A blob-eseményindítók például sztringparaméterrel, POCO-paraméterrel, CloudBlockBlob paraméterrel vagy számos más támogatott típussal használhatók. A blobkötések kötési referenciacikke felsorolja a blob-eseményindítók összes támogatott paramétertípusát. További információkért tekintse meg az eseményindítókat és kötéseket , valamint az egyes kötéstípusok kötési referencia-dokumentumait.

Tipp.

Ha HTTP- vagy WebHook-kötéseket szeretne használni, tervezze meg, hogy elkerülje a portkimerülést, amelyet a nem megfelelő példányosítás HttpClientokozhat. További információ: Kapcsolatok kezelése az Azure Functionsben.

Egyéni osztályokra való hivatkozás

Ha egyéni egyszerű régi CLR-objektumosztályt (POCO) kell használnia, az osztálydefiníciót belefoglalhatja ugyanabba a fájlba, vagy egy külön fájlba helyezheti.

Az alábbi példa egy run.csx példát mutat be, amely poCO-osztálydefiníciót tartalmaz.

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; }
}

A POCO-osztálynak minden tulajdonsághoz rendelkeznie kell egy getterrel és egy setterrel.

.csx-kód újrafelhasználása

A run.csx fájlban más .csx fájlokban definiált osztályokat és metódusokat is használhat. Ehhez használjon #load irányelveket a run.csx fájlban. A következő példában a rendszer megosztja a myLogger.csx nevű MyLogger naplózási rutint, és betölti a run.csxbe az #load irányelv használatával:

Példa 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}");
}

Példa mylogger.csx:

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

A megosztott .csx fájl használata gyakori minta, ha poCO-objektum használatával szeretné erősen begépelni a függvények között átadott adatokat. Az alábbi egyszerűsített példában egy HTTP-eseményindító és egy üzenetsor-eseményindító egy POCO-objektumot oszt meg, amely a rendelési adatok szigorú beírásához van elnevezve Order :

Példa run.csx http-eseményindítóra:

#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);
    }
}

Példa run.csx üzenetsor-eseményindítóra:

#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;
}

Példa 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}";
    }
}

A relatív elérési utat az #load irányelvvel használhatja:

#load "mylogger.csx" betölti a függvénymappában található fájlt.
#load "loadedfiles\mylogger.csx" betölt egy fájlt, amely a függvénymappában található mappában található.
#load "..\shared\mylogger.csx"betölti a függvénymappával azonos szinten lévő mappában található fájlt, vagyis közvetlenül a wwwroot alatt.

Az #load irányelv csak .csx fájlokkal működik, a .cs fájlokkal nem.

Kötés a metódus visszatérési értékéhez

A függvény.json névvel $returnegy kimeneti kötés metódus-visszaadási értékét használhatja.

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

Az alábbi C#-szkriptkód a visszatérési értéket használja, majd egy aszinkron példa:

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);
}

A visszatérési értéket csak akkor használja, ha egy sikeres függvény végrehajtása mindig visszatérési értéket eredményez a kimeneti kötésnek való továbbításhoz. Ellenkező esetben használja ICollector vagy IAsyncCollectorhasználja az alábbi szakaszban látható módon.

Több kimeneti érték írása

Ha több értéket szeretne írni egy kimeneti kötésbe, vagy ha egy sikeres függvényhívás nem eredményez semmit a kimeneti kötésnek való továbbításhoz, használja a típusokat vagy IAsyncCollector a ICollector típusokat. Ezek a típusok írásvédett gyűjtemények, amelyeket a metódus befejezésekor a kimeneti kötésbe írnak.

Ez a példa több üzenetsor-üzenetet ír ugyanabba az üzenetsorba a következő használatával ICollector:

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

Logging

Ha c#-ban szeretné naplózni a streamnaplók kimenetét, adjon meg egy ILogger típusú argumentumot. Javasoljuk, hogy nevezze el.log Kerülje az Azure Functions használatát Console.Write .

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

Megjegyzés:

A helyett TraceWriterhasználható újabb naplózási keretrendszerről a .NET-osztálytár fejlesztői útmutatójában található ILogger-dokumentációban talál további információt.

Egyéni metrikák naplózása

A bővítménymetódus ILogger használatával LogMetric egyéni metrikákat hozhat létre az Alkalmazás Elemzések. Íme egy mintametódus-hívás:

logger.LogMetric("TestMetric", 1234);

Ez a kód a .NET-hez készült Application Elemzések API használatával történő hívás TrackMetric alternatíva.

Aszinkron

Ha aszinkron függvényt szeretne létrehozni, használja a async kulcsszót, és adjon vissza egy objektumotTask.

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

Az aszinkron függvényekben nem használhatók out paraméterek. Kimeneti kötésekhez használja inkább a függvény visszatérési értékét vagy gyűjtőobjektumot.

Lemondási jogkivonatok

A függvények elfogadhatnak egy CancellationToken paramétert, amely lehetővé teszi, hogy az operációs rendszer értesítse a kódot, amikor a függvény leáll. Ezzel az értesítéssel meggyőződhet arról, hogy a függvény nem fejeződik be váratlanul oly módon, hogy az adatok inkonzisztens állapotban maradnak.

Az alábbi példa bemutatja, hogyan ellenőrizheti a közelgő függvényvégzítést.

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);
    }
}

Névterek importálása

Ha névtereket kell importálnia, ezt a szokásos módon teheti meg a using záradékkal.

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

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

A rendszer automatikusan importálja a következő névtereket, ezért nem kötelező:

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

Külső szerelvények hivatkozása

Keretszerelvények esetében az irányelv használatával #r "AssemblyName" adjon hozzá hivatkozásokat.

#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)

Az Azure Functions üzemeltetési környezete automatikusan hozzáadja a következő szerelvényeket:

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

A következő szerelvényekre egyszerű névvel hivatkozhat a futtatókörnyezet verziója:

v2.x+
v1.x

Newtonsoft.Json
Microsoft.WindowsAzure.Storage^*

^*A futtatókörnyezet 4.x verziójában el lett távolítva.

A kódban a szerelvényekre az alábbi példához hasonlóan hivatkozunk:

#r "AssemblyName"

Egyéni szerelvényekre való hivatkozás

Egyéni szerelvényre való hivatkozáshoz használhat megosztott szerelvényt vagy privát szerelvényt:

A megosztott szerelvényeket a függvényalkalmazás összes függvénye megosztja. Egyéni szerelvényre való hivatkozáshoz töltse fel a szerelvényt a függvényalkalmazás gyökérmappájában (wwwroot) elnevezett bin mappába.
A privát szerelvények egy adott függvény kontextusának részei, és támogatják a különböző verziók oldalbetöltését. A privát szerelvényeket a függvénykönyvtár egyik bin mappájába kell feltölteni. Hivatkozzon a szerelvényekre a fájlnév használatával, például #r "MyAssembly.dll".

A fájlok függvénymappába való feltöltéséről a csomagkezelésről szóló szakaszban talál további információt.

Figyelt könyvtárak

A függvényszkriptfájlt tartalmazó könyvtár automatikusan figyeli a szerelvények módosításait. Ha más könyvtárakban szeretné megtekinteni a szerelvény módosításait, vegye fel őket a watchDirectories host.json listára.

NuGet-csomagok használata

A kötésbővítmény-csomagok és más NuGet-csomagok a függvényalkalmazáshoz való hozzáadásának módja a Functions-futtatókörnyezet célzott verziójától függ.

v2.x+
v1.x

Alapértelmezés szerint a Függvénybővítmény nuGet-csomagjainak támogatott készlete a C# szkriptfüggvény-alkalmazás számára elérhetővé válik bővítménykötegek használatával. További információ: Bővítménykötegek.

Ha valamilyen okból nem tud bővítménycsomagokat használni a projektben, az Azure Functions Core Tools használatával bővítményeket is telepíthet az alkalmazás function.json fájljaiban definiált kötések alapján. Ha a Core Tools használatával regisztrálja a bővítményeket, mindenképpen használja ezt a --csx lehetőséget. További információ: func-bővítmények telepítése.

Alapértelmezés szerint a Core Tools beolvassa a function.json fájlokat, és hozzáadja a szükséges csomagokat egy extensions.csproj C# osztálytár projektfájljához a függvényalkalmazás fájlrendszerének gyökerében (wwwroot). Mivel a Core Tools a dotnet.exe fájlt használja, bármely NuGet-csomaghivatkozást hozzáadhat ehhez a bővítményfájlhoz. A telepítés során a Core Tools létrehozza a extensions.csproj fájlt a szükséges kódtárak telepítéséhez. Íme egy példa extensions.csproj fájlra, amely a Microsoft.ProjectOxford.Face 1.1.0-s verziójára mutató hivatkozást ad hozzá:

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

Megjegyzés:

C#-szkript (.csx) esetén a következő értéket kell megadnia TargetFrameworknetstandard2.0: . Más cél-keretrendszerek, például net6.0nem támogatottak.

A Functions-futtatókörnyezet 1.x-es verziója project.json fájllal definiálja a függőségeket. Íme egy példa project.json fájlra:

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

A bővítménycsomagokat az 1.x verzió nem támogatja.

Egyéni NuGet-hírcsatorna használatához adja meg a hírcsatornát egy Nuget.Config fájlban a függvényalkalmazás gyökérmappájában. További információ: A NuGet viselkedésének konfigurálása.

Ha csak a portálon dolgozik a projekten, manuálisan kell létrehoznia a extensions.csproj fájlt vagy egy Nuget.Config fájlt közvetlenül a webhelyen. További információ: Bővítmények manuális telepítése.

Környezeti változók

Környezeti változó vagy alkalmazásbeállítási érték lekéréséhez használja System.Environment.GetEnvironmentVariablea következő kód példában látható módon:

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);
}

Újrapróbálkozási szabályzatok

A Functions két beépített újrapróbálkozési szabályzatot támogat. További információ: Újrapróbálkozás szabályzatok.

Rögzített késés
Exponenciális visszalépés

A function.json fájlban az újrapróbálkozás szabályzata a következő:

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

function.json tulajdonság	Leírás
Stratégia	Use `fixedDelay`.
maxRetryCount	Szükséges. A függvényvégrehajtásonként engedélyezett újrapróbálkozések maximális száma. `-1` azt jelenti, hogy határozatlan időre újrapróbálkoznak.
delayInterval	Az újrapróbálkozások közötti késés. Adja meg sztringként a formátumot `HH:mm:ss`.

A function.json fájlban az újrapróbálkozás szabályzata a következő:

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

function.json tulajdonság	Leírás
Stratégia	Use `exponentialBackoff`.
maxRetryCount	Szükséges. A függvényvégrehajtásonként engedélyezett újrapróbálkozések maximális száma. `-1` azt jelenti, hogy határozatlan időre újrapróbálkoznak.
minimumInterval	Az újrapróbálkozások minimális késleltetése. Adja meg sztringként a formátumot `HH:mm:ss`.
maximumInterval	Az újrapróbálkozások maximális késleltetése. Adja meg sztringként a formátumot `HH:mm:ss`.

Kötés futásidőben

C# és más .NET-nyelvekben imperatív kötési mintát használhat a function.json deklaratív kötései helyett. Az imperatív kötés akkor hasznos, ha a kötési paramétereket futásidőben kell kiszámítani a tervezési idő helyett. Ezzel a mintával a függvénykódban menet közben csatlakozhat a támogatott bemeneti és kimeneti kötésekhez.

Adjon meg egy imperatív kötést az alábbiak szerint:

Ne adjon meg bejegyzést a function.json fájlban a kívánt imperatív kötésekhez.
Adjon meg egy bemeneti paramétert Binder binder vagy IBinder binder.
Az adatkötés végrehajtásához használja az alábbi C#-mintát.

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

BindingTypeAttribute a kötést meghatározó .NET-attribútum, amely T az adott kötéstípus által támogatott bemeneti vagy kimeneti típus. T nem lehet out paramétertípus (például out JObject). A Mobile Apps tábla kimeneti kötése például hat kimeneti típust támogat, de csak az ICollector<T> vagy IAsyncCollector<T> a T.

Példa egy attribútumra

Az alábbi példakód létrehoz egy Storage-blob kimeneti kötést a futtatáskor definiált blob elérési útjával, majd sztringet ír a blobhoz.

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!!");
    }
}

A BlobAttribute a Storage-blob bemeneti vagy kimeneti kötését határozza meg, a TextWriter pedig egy támogatott kimeneti kötéstípus.

Több attribútum – példa

Az előző példa lekéri a függvényalkalmazás fő Storage-fiókjának alkalmazásbeállítását kapcsolati sztring (azaz AzureWebJobsStorage). A Storage-fiókhoz használandó egyéni alkalmazásbeállítást úgy adhatja meg, hogy hozzáadja a StorageAccountAttribute értéket, és átadja az attribútumtömböt a tárfióknak BindAsync<T>(). Használjon paramétert Binder , ne IBinder. Például:

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!");
    }
}

Az alábbi táblázat felsorolja az egyes kötéstípusok .NET-attribútumait, valamint azokat a csomagokat, amelyekben definiálva vannak.

Kötés	Attribútum	Hivatkozás hozzáadása
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"`
Tárolási üzenetsor	`Microsoft.Azure.WebJobs.QueueAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Tárolóblob	`Microsoft.Azure.WebJobs.BlobAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Storage-tábla	`Microsoft.Azure.WebJobs.TableAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Twilio	`Microsoft.Azure.WebJobs.TwilioSmsAttribute`	`#r "Microsoft.Azure.WebJobs.Extensions.Twilio"`

C#-szkriptalkalmazás konvertálása C#-projektté

A C#-szkriptfüggvény-alkalmazások lefordított C# osztálykódtár-projektté alakításának legegyszerűbb módja egy új projekttel való kezdés. Ezután minden függvényhez migrálhatja a kódot és a konfigurációt a függvénymappában található minden run.csx fájlból és function.json fájlból egyetlen új .cs osztálykódtár-fájlba. Ha például egy C#-szkriptfüggvény neve HelloWorld két fájlból áll: HelloWorld/run.csx és HelloWorld/function.json. Ehhez a függvényhez létre kell hoznia egy kódfájlt HelloWorld.cs az új osztálytárprojektben.

Ha C#-szkripteket használ a portál szerkesztéséhez, letöltheti az alkalmazás tartalmát a helyi gépére. A Tartalom és a Visual Studio-projekt helyett válassza a Webhelytartalom lehetőséget. Nem kell projektet létrehoznia, és nem kell belefoglalnia az alkalmazásbeállításokat a letöltésbe. Új fejlesztési környezetet definiál, és ennek a környezetnek nem szabad ugyanazokkal az engedélyekkel rendelkeznie, mint az üzemeltetett alkalmazáskörnyezetnek.

Ezek az utasítások bemutatják, hogyan konvertálhatja a C#-szkriptfüggvényeket (amelyek a Functions-gazdagéppel folyamatban futnak) egy izolált feldolgozófolyamatban futó C# osztálytárfüggvényekké.

Töltse ki a Függvényalkalmazás-projekt létrehozása szakaszt az előnyben részesített rövid útmutatóból:
C#-függvény létrehozása az Azure-ban a parancssorból

Az első C#-függvény létrehozása az Azure-ban a Visual Studióval

Az első C#-függvény létrehozása az Azure-ban a Visual Studio Code használatával

Ha az eredeti C#-szkriptkód tartalmaz egy extensions.csproj fájlt vagy bármilyen function.proj fájlt, másolja ki a csomaghivatkozásokat ezekből a fájlból, és adja hozzá őket az új projekt fájljához .csproj a Functions alapvető függőségeivel megegyező módon ItemGroup .

Tipp.

A konvertálás jó lehetőséget kínál a függőségek legújabb verzióira való frissítésre. Ennek elvégzése további kódmódosításokat igényelhet egy későbbi lépésben.
Másolja az eredeti host.json fájl tartalmát az új projekt fájljába host.json , kivéve a szakaszt (a extensionBundles lefordított C#-projektek nem használnak bővítménycsomagokat , és kifejezetten hivatkoznia kell a függvények által használt összes bővítményre). A host.json fájlok egyesítésekor ne feledje, hogy a host.json séma verziószámozott, és a legtöbb alkalmazás a 2.0-s verziót használja. A szakasz tartalma a extensions függvények által használt kötésbővítmények adott verzióitól függően eltérhet. Az egyes bővítményekre vonatkozó hivatkozási cikkekből megtudhatja, hogyan konfigurálhatja helyesen a host.json fájlt az adott verziókhoz.
Az irányelv által #load hivatkozott megosztott fájlokhoz hozzon létre egy új .cs fájlt mindegyik megosztott hivatkozáshoz. A legegyszerűbb, ha minden megosztott osztálydefinícióhoz létrehozunk egy új .cs fájlt. Ha vannak olyan statikus metódusok, amelyek nem tartoznak osztályhoz, új osztályokat kell definiálnia ezekhez a metódusokhoz.
Hajtsa végre a következő feladatokat az eredeti projekt minden <FUNCTION_NAME> mappájához:
1. Hozzon létre egy új fájlt <FUNCTION_NAME>.cs, amely a C#-szkriptfüggvényt definiáló mappa nevére vált <FUNCTION_NAME> . Az eseményindító-specifikus sablonok egyikéből az alábbi módon hozhat létre új függvénykódfájlt:
  Használja a func new --name <FUNCTION_NAME> parancsot, és válassza ki a megfelelő triggersablont a parancssorban.
  
  Következő : Függvény hozzáadása a projekthez a Visual Studio útmutatójában.
  
  Következő : Függvény hozzáadása a projekthez a Visual Studio Code útmutatójában.
2. Másolja ki az utasításokat a usingrun.csx fájlból, és adja hozzá őket az új fájlhoz. Nincs szükség irányelvekre #r .
3. A fájl bármely #load utasításához run.csx adjon hozzá egy új using utasítást a megosztott kódhoz használt névtérhez.
4. Az új fájlban definiáljon egy osztályt a függvényhez a projekthez használt névtér alatt.
5. Hozzon létre egy új, névvel ellátott RunHandler vagy hasonló metódust. Ez az új metódus szolgál a függvény új belépési pontjaként.
6. Másolja a függvényt jelképező statikus metódust és az általa hívott függvényeket az új osztályba run.csx második metódusként. Az előző lépésben létrehozott új metódusból hívja be ezt a statikus metódust. Ez az indirekt lépés hasznos lehet a frissítés folytatása során felmerülő különbségek navigálásához. Megtarthatja az eredeti metódust pontosan ugyanazzal a módszerrel, és egyszerűen szabályozhatja a bemeneteit az új környezetből. Előfordulhat, hogy paramétereket kell létrehoznia az új metóduson, amelyet aztán átad a statikus metódushívásnak. Miután meggyőződött arról, hogy a migrálás a kívánt módon működik, eltávolíthatja ezt a további közvetett szintet.
7. A fájl minden kötéséhez function.json adja hozzá a megfelelő attribútumot az új metódushoz. A kötési példák gyors kereséséhez lásd: Kötések manuális hozzáadása példák alapján.
8. Ha még nem tette meg, adja hozzá a projekthez a kötésekhez szükséges bővítménycsomagokat.
Hozza létre újra az alkalmazás által igényelt alkalmazásbeállításokat a Valueslocal.settings.json fájl gyűjteményében.
Ellenőrizze, hogy a projekt helyileg fut-e:
Az alkalmazás parancssorból való futtatására használható func start . További információ: Függvények helyi futtatása.

Kövesse a Visual Studio útmutatójának helyi Futtatási függvények szakaszát.

Kövesse a Visual Studio Code útmutatójának Futtatási függvények helyi szakaszát.
A projekt közzététele egy új függvényalkalmazásban az Azure-ban:
Hozza létre az Azure-erőforrásokat , és helyezze üzembe a kódprojektet az Azure-ban a func azure functionapp publish <APP_NAME> parancs használatával. További információ: Projektfájlok üzembe helyezése.

Kövesse a Visual Studio útmutatójának Közzététel az Azure-ban szakaszát.

Kövesse a Visual Studio Code útmutatóJának Azure-erőforrások létrehozása szakaszát.

Példa függvénykonvertálásra

Ez a szakasz egy példa egy függvény migrálására.

A C#-szkriptelés eredeti függvénye két fájlból áll:

HelloWorld/function.json
HelloWorld/run.csx

A következők tartalma HelloWorld/function.json :

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

A következők tartalma HelloWorld/run.csx :

#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);
}

A ASP.NET Core-integrációval rendelkező izolált feldolgozói modellre való migrálás után ezeket egyetlen 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);
        }
    }
}

Kötéskonfiguráció és példák

Ez a szakasz hivatkozásokat és példákat tartalmaz az eseményindítók és kötések C#-szkriptben való definiálásához.

Blobtrigger

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `blobTrigger`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	A beállításnak a `in`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely a függvénykódban a blobot jelöli.
ösvény	A monitorozni kívánt tároló . Lehet, hogy blobnévminta.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Azure Blobshoz. Lásd: Csatlakozás ions.

Az alábbi példa egy blob triggerdefinícióját mutatja be egy function.json fájlban és a kötést használó kódban. A függvény naplót ír, amikor blobot adnak hozzá vagy frissítenek a samples-workitemstárolóban.

A function.json fájl kötési adatai a következők:

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

A blob-eseményindító elérési útjának samples-workitems/{name} sztringje {name} létrehoz egy kötési kifejezést, amelyet a függvénykódban használhat az eseményindító blob fájlnevének eléréséhez. További információ: Blobnévminták.

Az alábbi C#-szkriptkód a következőhöz Streamkötődik:

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");
}

Az alábbi C#-szkriptkód a következőhöz CloudBlockBlobkötődik:

#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}");
}

Blobbemenet

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `blob`következőnek kell lennie: .
direction	A beállításnak a `in`következőnek kell lennie: .
név	Annak a változónak a neve, amely a függvénykódban a blobot jelöli.
ösvény	A blob elérési útja.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Azure Blobshoz. Lásd: Csatlakozás ions.

Az alábbi példa a blobok bemeneti és kimeneti kötéseit mutatja be egy function.json fájlban és a kötéseket használó C# szkriptkódban. A függvény másolatot készít egy szövegblobról. A függvényt egy üzenetsor-üzenet aktiválja, amely tartalmazza a másolandó blob nevét. Az új blob neve {originalblobname}-Copy.

A function.json fájlban a queueTrigger metaadat-tulajdonság a blob nevének megadására szolgál a path tulajdonságokban:

{
  "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
}

A C# szkriptkódja a következő:

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

Blobkimenet

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `blob`következőnek kell lennie: .
direction	A beállításnak a `out`következőnek kell lennie: .
név	Annak a változónak a neve, amely a függvénykódban a blobot jelöli.
ösvény	A blob elérési útja.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Azure Blobshoz. Lásd: Csatlakozás ions.

A function.json fájlban a queueTrigger metaadat-tulajdonság a blob nevének megadására szolgál a path tulajdonságokban:

{
  "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
}

A C# szkriptkódja a következő:

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

RabbitMQ eseményindító

Az alábbi példa egy RabbitMQ-eseményindító kötését mutatja be egy function.json fájlban és egy C# szkriptfüggvényt , amely a kötést használja. A függvény beolvassa és naplózza a RabbitMQ üzenetet.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

using System;

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

Üzenetsor-eseményindító

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `queueTrigger`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	Csak a function.json fájlban. A beállításnak a `in`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely az üzenetsorelem hasznos adatait tartalmazza a függvénykódban.
queueName	A lekérdezni kívánt üzenetsor neve.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Azure Queueshoz. Lásd: Csatlakozás ions.

Az alábbi példa egy üzenetsor-eseményindító kötését mutatja be egy function.json fájlban és a kötést használó C# szkriptkódban. A függvény lekérdezi az myqueue-items üzenetsort, és naplót ír minden egyes üzenetsorelem feldolgozásakor.

A function.json fájl a következő:

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

A C# szkriptkódja a következő:

#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}");
}

Üzenetsor kimenete

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `queue`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	A beállításnak a `out`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely az üzenetsort jelöli a függvénykódban. `$return` A függvény visszatérési értékére való hivatkozásra van állítva.
queueName	Az üzenetsor neve.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Azure Queueshoz. Lásd: Csatlakozás ions.

Az alábbi példa egy HTTP-eseményindító kötését mutatja be egy function.json fájlban és a kötést használó C# szkriptkódban. A függvény létrehoz egy customQueueMessage objektum hasznos adattal rendelkező üzenetsorelemet minden fogadott HTTP-kéréshez.

A function.json fájl a következő:

{
  "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"
    }
  ]
}

Az alábbi C#-szkriptkód egyetlen üzenetsort hoz létre:

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

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

Egyszerre több üzenetet is küldhet egy vagy IAsyncCollector több ICollector paraméter használatával. Az alábbi C#-szkriptkód több üzenetet küld, egyet a HTTP-kérési adatokkal, egyet pedig a rögzített értékekkel:

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

Táblabemenet

Ez a szakasz csak a bővítmény Tables API-verziójának támogatását ismerteti.

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `table`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
direction	A beállításnak a `in`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	Annak a változónak a neve, amely a függvénykód tábláját vagy entitását jelöli.
tableName	A tábla neve.
partitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa.
rowKey	Opcionális. Az olvasni kívánt táblaentitás sorkulcsa. A (z) vagy a (z) `filter`nem használható.`take`
take	Opcionális. A visszaadandó entitások maximális száma. Nem használható a `rowKey`.
Szűrő	Opcionális. OData-szűrőkifejezés az entitásokhoz, amelyek a táblából térnek vissza. Nem használható a `rowKey`.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Csatlakozás ions.

Az alábbi példa egy táblabemeneti kötést mutat be egy function.json fájlban és a kötést használó C# szkriptkódban. A függvény egy üzenetsor-eseményindítót használ egyetlen táblasor beolvasásához.

A function.json fájl egy partitionKey és egy rowKey. Az rowKey érték {queueTrigger} azt jelzi, hogy a sorkulcs az üzenetsor-sztringből származik.

{
  "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
}

A C# szkriptkódja a következő:

#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; }
}

Táblakimenet

Ez a szakasz csak a bővítmény Tables API-verziójának támogatását ismerteti.

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `table`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
direction	A beállításnak a `out`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	A táblát vagy entitást képviselő függvénykódban használt változónév. `$return` A függvény visszatérési értékére való hivatkozásra van állítva.
tableName	Annak a táblának a neve, amelyhez írni szeretne.
partitionKey	Az írni kívánt táblaentitás partíciókulcsa.
rowKey	Az írni kívánt táblaentitás sorkulcsa.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Csatlakozás ions.

Az alábbi példa egy táblakimeneti kötést mutat be egy function.json fájlban és a kötést használó C# szkriptkódban. A függvény több táblaentitást ír.

A function.json fájl a következő:

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

A C# szkriptkódja a következő:

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; }
}

Időzítő-eseményindító

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `timerTrigger`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	A beállításnak a `in`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely az időzítő objektumot jelöli a függvénykódban.
schedule	CRON-kifejezés vagy TimeSpan-érték. Az A `TimeSpan` csak App Service-csomagon futó függvényalkalmazásokhoz használható. Az ütemezési kifejezést elhelyezheti egy alkalmazásbeállításban, és beállíthatja ezt a tulajdonságot a táblákba burkolt alkalmazásbeállítási névre, ahogyan ebben a példában % is látható: "%ScheduleAppSetting%".
runOnStartup	Ha `true`, a függvény a futtatókörnyezet indításakor lesz meghívva. A futtatókörnyezet elindul például akkor, amikor a függvényalkalmazás felébred, miután inaktivitás miatt tétlen állapotba került, amikor a függvényalkalmazás a függvény változásai miatt újraindul, és amikor a függvényalkalmazás felskálázható. Óvatosan használja.A runOnStartup-t ritkán kell beállítani `true`, különösen éles környezetben.
useMonitor	Állítsa `true` vagy `false` értékre annak megadásához, hogy az ütemezés monitorozva legyen-e. Az ütemezés monitorozása megőrzi az ütemezési eseményeket, így biztosítva az ütemezés megfelelő karbantartását még akkor is, ha a függvényalkalmazás-példányok újraindulnak. Ha nincs explicit módon beállítva, az alapértelmezett érték az olyan ütemezések esetében van `true` , amelyek ismétlődési időköze 1 percnél hosszabb vagy egyenlő. Azoknál az ütemezéseknél, amelyek percenként többször aktiválnak, az alapértelmezett érték a .`false`

Az alábbi példa egy időzítő eseményindító kötését mutatja be egy function.json fájlban és egy C# szkriptfüggvényt, amely a kötést használja. A függvény naplót ír, amely jelzi, hogy ez a függvényhívás egy kihagyott ütemezési esemény miatt van-e. Az TimerInfo objektum át lesz adva a függvénybe.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

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-eseményindító

Az alábbi táblázat a function.json fájlban beállított triggerkonfigurációs tulajdonságokat ismerteti:

function.json tulajdonság	Leírás
type	Kötelező – a beállításnak `httpTrigger`a következőnek kell lennie: .
direction	Kötelező – a beállításnak `in`a következőnek kell lennie: .
név	Kötelező – a kérelem vagy a kérelem törzsének függvénykódjában használt változónév.
authLevel	Meghatározza, hogy a függvény meghívásához milyen kulcsoknak kell szerepelnie a kérelemben, ha vannak ilyenek. A támogatott értékekről lásd : Engedélyezési szint.
Módszerek	Azon HTTP-metódusok tömbje, amelyekre a függvény válaszol. Ha nincs megadva, a függvény minden HTTP-metódusra válaszol. Lásd a HTTP-végpont testreszabását.
Útvonal	Meghatározza az útvonalsablont, amely meghatározza, hogy a függvény melyik kérelem URL-címére válaszol. Az alapértelmezett érték, ha nincs megadva `<functionname>`. További információ: A HTTP-végpont testreszabása.
webHookType	Csak az 1.x-es futtatókörnyezetben támogatott. A HTTP-eseményindítót úgy konfigurálja, hogy a megadott szolgáltató webhook-fogadójaként működjön. A támogatott értékekért lásd a WebHook típusát.

Az alábbi példa egy triggerkötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt, amely a kötést használja. A függvény egy paramétert name keres a lekérdezési sztringben vagy a HTTP-kérés törzsében.

A function.json fájl a következő:

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

Az alábbi C#-szkriptkód a következőhöz HttpRequestkötődik:

#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");
}

A helyett HttpRequestegyéni objektumhoz is kapcsolódhat. Ez az objektum a kérelem törzséből jön létre, és JSON-ként van elemezve. Hasonlóképpen, egy típus átadható a HTTP-válasz kimeneti kötésének, és választörzsként visszaadható, állapotkóddal 200 együtt.

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-kimenet

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

Property	Leírás
type	A beállításnak a `http`következőnek kell lennie: .
direction	A beállításnak a `out`következőnek kell lennie: .
név	A válasz függvénykódjában vagy `$return` a visszatérési érték használatára használt változó neve.

Event Hubs-eseményindító

Az alábbi táblázat a function.json fájlban beállított triggerkonfigurációs tulajdonságokat ismerteti:

function.json tulajdonság	Leírás
type	A beállításnak a `eventHubTrigger`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	A beállításnak a `in`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely a függvénykód eseményelemét jelöli.
eventHubName	Függvények 2.x és újabb. Az eseményközpont neve. Ha az eseményközpont neve is szerepel a kapcsolati sztring, ez az érték futásidőben felülbírálja ezt a tulajdonságot. Az alkalmazásbeállításokon`%eventHubName%` keresztül hivatkozhat gombra. Az 1.x verzióban ez a tulajdonság neve `path`.
consumerGroup	Nem kötelező tulajdonság, amely beállítja a központban lévő eseményekre való feliratkozáshoz használt fogyasztói csoportot . Ha nincs megadva, a rendszer a `$Default` fogyasztói csoportot használja.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Event Hubshoz. Lásd: Csatlakozás ions.

Az alábbi példa egy Event Hubs-eseményindító-kötést mutat be egy function.json fájlban, és egy C# szkriptfüggvényt, amely a kötést használja. A függvény naplózza az Event Hubs-eseményindító üzenettörzsét.

Az alábbi példák az Event Hubs kötési adatait mutatják be a Functions 2.x és újabb verzióinak function.json fájljában.

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

A C# szkriptkódja a következő:

using System;

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

Ha az esemény metaadataihoz szeretne hozzáférni a függvénykódban, kössön egy EventData-objektumhoz . Ugyanezeket a tulajdonságokat a metódus aláírásában lévő kötési kifejezések használatával is elérheti. Az alábbi példa mindkét módszert mutatja be ugyanazon adatok lekérésére:

#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}");
}

Ha eseményeket szeretne fogadni egy kötegben, hozzon létre string vagy EventData tömböt:

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-kimenet

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `eventHub`következőnek kell lennie: .
direction	A beállításnak a `out`következőnek kell lennie: . Ez a paraméter automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	Az eseményt jelképező függvénykódban használt változónév.
eventHubName	Függvények 2.x és újabb. Az eseményközpont neve. Ha az eseményközpont neve is szerepel a kapcsolati sztring, ez az érték futásidőben felülbírálja ezt a tulajdonságot. A Functions 1.x-ben ennek a tulajdonságnak a neve `path`.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat az Event Hubshoz. További információ: Csatlakozás.

Az alábbi példában egy eseményközpont eseményindító kötése látható egy function.json fájlban és egy C# szkriptfüggvényben, amely a kötést használja. A függvény üzenetet ír egy eseményközpontba.

Az alábbi példák az Event Hubs kötési adatait mutatják be a Functions 2.x és újabb verzióinak function.json fájljában.

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

Az alábbi C#-szkriptkód egyetlen üzenetet hoz létre:

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;
}

Az alábbi C#-szkriptkód több üzenetet hoz létre:

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);
}

Event Grid-trigger

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti. Az attribútumban EventGridTrigger nincsenek konstruktorparaméterek vagy tulajdonságok.

function.json tulajdonság	Leírás
type	Kötelező – a beállításnak `eventGridTrigger`a következőnek kell lennie: .
direction	Kötelező – a beállításnak `in`a következőnek kell lennie: .
név	Kötelező – az eseményadatokat fogadó paraméter függvénykódjában használt változónév.

Az alábbi példa a function.json fájlban definiált Event Grid-eseményindítót mutatja be.

A function.json fájl kötési adatai a következők:

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

Íme egy példa egy C# szkriptfüggvényre, amely kötési paramétert EventGridEvent használ:

#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());
}

Íme egy példa egy C# szkriptfüggvényre, amely kötési paramétert JObject használ:

#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-kimenet

Az alábbi táblázat a function.json fájlban beállított C#-szkript kötéskonfigurációs tulajdonságait ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `eventGrid`következőnek kell lennie: .
direction	A beállításnak a `out`következőnek kell lennie: . Ez a paraméter automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	Az eseményt jelképező függvénykódban használt változónév.
topicEndpointUri	Az egyéni témakör URI-ját tartalmazó alkalmazásbeállítás neve, például `MyTopicEndpointUri`.
topicKeySetting	Az egyéni témakör hozzáférési kulcsát tartalmazó alkalmazásbeállítás neve.

Az alábbi példa az Event Grid kimeneti kötési adatait mutatja be a function.json fájlban.

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

Az alábbi C#-szkriptkód egy eseményt hoz létre:

#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");
}

Az alábbi C#-szkriptkód több eseményt hoz létre:

#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-eseményindító

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `serviceBusTrigger`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	A beállításnak a `in`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely az üzenetsort vagy a témakörüzenetet jelöli a függvénykódban.
queueName	A monitorozni kívánt üzenetsor neve. Csak üzenetsor figyelése esetén állítsa be, nem témakörhöz.
topicName	A figyelendő témakör neve. Csak akkor állítsa be, ha figyel egy témakört, nem üzenetsorhoz.
subscriptionName	A monitorozni kívánt előfizetés neve. Csak akkor állítsa be, ha figyel egy témakört, nem üzenetsorhoz.
Kapcsolat	A Service Bushoz való csatlakozás módját meghatározó alkalmazásbeállítás vagy beállításgyűjtemény neve. Lásd: Csatlakozás ions.
accessRights	A kapcsolati sztring hozzáférési jogosultságai. A rendelkezésre álló értékek és `listen`a `manage` . Az alapértelmezett érték az`manage`, amely azt jelzi, hogy a `connection` kezelés engedéllyel rendelkezik. Ha olyan kapcsolati sztring használ, amely nem rendelkezik a Kezelés engedéllyel, állítsa be a "figyelés" elemet`accessRights`. Ellenkező esetben előfordulhat, hogy a Functions-futtatókörnyezet nem próbál meg olyan műveleteket végrehajtani, amelyek felügyeleti jogosultságokat igényelnek. Az Azure Functions 2.x és újabb verziójában ez a tulajdonság nem érhető el, mert a Service Bus SDK legújabb verziója nem támogatja a műveletek kezelését.
isSessionsEnabled	`true`ha munkamenet-tudatos üzenetsorhoz vagy előfizetéshez csatlakozik. `false` ellenkező esetben ez az alapértelmezett érték.
Automatikus	`true` ha az eseményindítónak a feldolgozás után automatikusan befejezettnek kell lennie, vagy ha a függvénykód manuálisan hívja meg a készet. `false` A beállítás csak a C#-ban támogatott. Ha be van `true`állítva, az eseményindító automatikusan befejezi az üzenetet, ha a függvény végrehajtása sikeresen befejeződött, és ellenkező esetben megszakítja az üzenetet. <br/Ha be `false`van állítva, ön felel a ServiceBusReceiver metódusok meghívásáért az üzenet, a munkamenet vagy a köteg befejezéséhez, elhagyásához vagy holtponthoz állítva. Ha kivételt vetnek ki (és egyik `ServiceBusReceiver` metódus sem lesz meghívva), a zárolás megmarad. A zárolás lejárta után az üzenet újra sorba kerül a `DeliveryCount` növekményekkel, és a zárolás automatikusan megújul. Ez a tulajdonság csak az Azure Functions 2.x és újabb verzióiban érhető el.

Az alábbi példa egy Service Bus-eseményindító kötését mutatja be egy function.json fájlban, és egy C# szkriptfüggvényt, amely a kötést használja. A függvény felolvassa az üzenet metaadatait, és naplóz egy Service Bus-üzenetsort.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

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-kimenet

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `serviceBus`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
direction	A beállításnak a `out`következőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	Annak a változónak a neve, amely az üzenetsort vagy a témakörüzenetet jelöli a függvénykódban. Állítsa be a "$return" értéket a függvény visszatérési értékére való hivatkozáshoz.
queueName	Az üzenetsor neve. Csak akkor állítsa be, ha üzenetsor-üzeneteket küld, nem témakörhöz.
topicName	A témakör neve. Csak akkor állítsa be, ha témakörüzeneteket küld, nem üzenetsorhoz.
Kapcsolat	A Service Bushoz való csatlakozás módját meghatározó alkalmazásbeállítás vagy beállításgyűjtemény neve. Lásd: Csatlakozás ions.
accessRights (csak v1)	A kapcsolati sztring hozzáférési jogosultságai. A rendelkezésre álló értékek és `listen`a `manage` . Az alapértelmezett érték az`manage`, amely azt jelzi, hogy a `connection` kezelés engedéllyel rendelkezik. Ha olyan kapcsolati sztring használ, amely nem rendelkezik a Kezelés engedéllyel, állítsa be a "figyelés" elemet`accessRights`. Ellenkező esetben előfordulhat, hogy a Functions-futtatókörnyezet nem próbál meg olyan műveleteket végrehajtani, amelyek felügyeleti jogosultságokat igényelnek. Az Azure Functions 2.x és újabb verziójában ez a tulajdonság nem érhető el, mert a Service Bus SDK legújabb verziója nem támogatja a műveletek kezelését.

Az alábbi példa egy Service Bus kimeneti kötést mutat be egy function.json fájlban, és egy C# szkriptfüggvényt, amely a kötést használja. A függvény időzítő eseményindítóval 15 másodpercenként küld üzenetsort.

A function.json fájl kötési adatai a következők:

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

Az alábbi C#-szkriptkód egyetlen üzenetet hoz létre:

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;
}

Az alábbi C#-szkriptkód több üzenetet hoz létre:

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-eseményindító

Ez a szakasz csak a bővítmény 4.x+ verziójának támogatását ismerteti.

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `cosmosDBTrigger`következőnek kell lennie: .
direction	A beállításnak a `in`következőnek kell lennie: . Ez a paraméter automatikusan be van állítva, amikor létrehozza az eseményindítót az Azure Portalon.
név	A függvénykódban használt változónév, amely a módosításokat tartalmazó dokumentumok listáját jelöli.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
databaseName	Az Azure Cosmos DB-adatbázis neve a figyelt tárolóval.
containerName	A figyelt tároló neve.
bérlet Csatlakozás ion	(Nem kötelező) Egy alkalmazásbeállítás vagy beállítástároló neve, amely meghatározza, hogyan csatlakozhat a bérlettárolót tartalmazó Azure Cosmos DB-fiókhoz. Ha nincs beállítva, a rendszer az `connection` értéket használja. Ez a paraméter automatikusan be lesz állítva, amikor a kötés létrejön a portálon. A bérlettároló kapcsolati sztring írási engedélyekkel kell rendelkeznie.
leaseDatabaseName	(Nem kötelező) A bérletek tárolására használt tárolót tartalmazó adatbázis neve. Ha nincs beállítva, a rendszer a `databaseName` beállítás értékét használja.
leaseContainerName	(Nem kötelező) A bérletek tárolására használt tároló neve. Ha nincs beállítva, a rendszer az értéket `leases` használja.
createLeaseContainerIfNotExists	(Nem kötelező) Ha be van `true`állítva, a bérlettároló automatikusan létrejön, ha még nem létezik. Az alapértelmezett érték `false`. Ha a Microsoft Entra-identitások értékét `true`állítja be, a tárolók létrehozása nem engedélyezett művelet , és a függvény nem fog tudni elindulni.
leasesContainerThroughput	(Nem kötelező) Meghatározza a bérlettároló létrehozásakor hozzárendelni kívánt kérelemegységek számát. Ezt a beállítást csak akkor használja a rendszer, ha `createLeaseContainerIfNotExists` be van állítva.`true` Ez a paraméter automatikusan be lesz állítva, amikor a kötés a portál használatával jön létre.
leaseContainerPrefix	(Nem kötelező) Ha be van állítva, az érték előtagként lesz hozzáadva a függvény bérlettárolójában létrehozott bérletekhez. Az előtagok használatával két különálló Azure Functions különböző előtagokkal oszthatja meg ugyanazt a bérlettárolót.
feedPollDelay	(Nem kötelező) A partíció lekérdezése közötti késés ideje (ezredmásodpercben) a hírcsatorna új módosításainak lekérdezése között, miután az összes aktuális módosítás leürült. Az alapértelmezett érték 5000 ezredmásodperc vagy 5 másodperc.
leaseAcquireInterval	(Nem kötelező) Ha be van állítva, ezredmásodpercben határozza meg azt az időközt, amely alapján kiszámítható, hogy a partíciók egyenletesen oszlanak-e el az ismert gazdagéppéldányok között. Az alapértelmezett érték 13000 (13 másodperc).
leaseExpirationInterval	(Nem kötelező) Ha be van állítva, ezredmásodpercben határozza meg azt az időközt, amelyre a bérlet egy partíciót képviselő bérleten történik. Ha a bérlet nem újul meg ebben az intervallumban, az lejár, és a partíció tulajdonjoga egy másik példányra kerül. Az alapértelmezett érték 60000 (60 másodperc).
leaseRenewInterval	(Nem kötelező) Ha be van állítva, ezredmásodpercben határozza meg a példány által jelenleg tárolt partíciók összes bérletének megújítási időközét. Az alapértelmezett érték 17000 (17 másodperc).
maxItemsPerInvocation	(Nem kötelező) Ha be van állítva, ez a tulajdonság beállítja a függvényhívásonként fogadott elemek maximális számát. Ha a figyelt tárolóban tárolt eljárásokkal hajtják végre a műveleteket, a tranzakció hatóköre megmarad a változáscsatorna elemeinek beolvasásakor. Ennek eredményeképpen a fogadott elemek száma magasabb lehet a megadott értéknél, így az ugyanazon tranzakcióval módosított elemek egy atomi köteg részeként lesznek visszaadva.
startFromBeginning	(Nem kötelező) Ez a beállítás arra utasítja az eseményindítót, hogy az aktuális időpont helyett a tároló változáselőzményeinek kezdetétől olvassa be a módosításokat. Az első olvasás csak az eseményindító első indításakor működik, mivel a későbbi futtatások során a rendszer már tárolja az ellenőrzőpontokat. Ha ezt a beállítást úgy állítja be, hogy `true` már létrejöttek a bérletek, annak nincs hatása.
startFromTime	(Nem kötelező) Lekéri vagy beállítja a változáscsatorna olvasási műveletének inicializálásának dátumát és időpontját. Az ajánlott formátum az ISO 8601 és az UTC-tervező, például `2021-02-16T14:19:29Z`. Ez csak a kezdeti eseményindító állapot beállítására szolgál. Ha az eseményindító bérletállapotú, az érték módosítása nem lép érvénybe.
preferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: "USA keleti régiója,USA déli középső régiója,Észak-Európa".

Az alábbi példa egy Azure Cosmos DB-eseményindító kötését mutatja be egy function.json fájlban és egy C# szkriptfüggvényt , amely a kötést használja. A függvény naplóüzeneteket ír az Azure Cosmos DB-rekordok hozzáadásakor vagy módosításakor.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    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 bemenet

Ez a szakasz csak a bővítmény 4.x+ verziójának támogatását ismerteti.

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a `cosmosDB`következőnek kell lennie: .
direction	A beállításnak a `in`következőnek kell lennie: .
név	A függvénykódban használt változónév, amely a módosításokat tartalmazó dokumentumok listáját jelöli.
Kapcsolat	Egy alkalmazásbeállítás vagy beállítástároló neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
databaseName	Az Azure Cosmos DB-adatbázis neve a figyelt tárolóval.
containerName	A figyelt tároló neve.
partitionKey	Megadja a keresés partíciókulcs-értékét. Tartalmazhat kötési paramétereket. A particionált tárolókban lévő keresésekhez szükséges.
id	A lekérni kívánt dokumentum azonosítója. Ez a tulajdonság támogatja a kötési kifejezéseket. Ne állítsa be a tulajdonságokat és `sqlQuery` a `id` tulajdonságokat sem. Ha egyiket sem állítja be, a rendszer lekéri a teljes tárolót.
sqlQuery	Több dokumentum lekéréséhez használt Azure Cosmos DB SQL-lekérdezés. A tulajdonság támogatja a futtatókörnyezet-kötéseket, ahogyan ebben a példában is látható: `SELECT * FROM c where c.departmentId = {departmentId}`. Ne állítsa be a tulajdonságokat és `sqlQuery` a `id` tulajdonságokat sem. Ha egyiket sem állítja be, a rendszer lekéri a teljes tárolót.
preferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. For example, `East US,South Central US,North Europe`.

Ez a szakasz a következő példákat tartalmazza:

Üzenetsor-eseményindító, azonosító keresése sztringből
Üzenetsor-eseményindító, több dokumentum lekérése az SqlQuery használatával
HTTP-eseményindító, azonosító keresése lekérdezési sztringből
HTTP-eseményindító, azonosító keresése útvonaladatokból
HTTP-eseményindító, több dokumentum lekérése az SqlQuery használatával
HTTP-eseményindító, több dokumentum lekérése a DocumentClient használatával

A HTTP-eseményindító példái egy egyszerű ToDoItem típusra vonatkoznak:

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

Üzenetsor-eseményindító, azonosító keresése sztringből

Az alábbi példa egy Azure Cosmos DB bemeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt, amely a kötést használja. A függvény egyetlen dokumentumot olvas be, és frissíti a dokumentum szöveges értékét.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    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.";
    }

Üzenetsor-eseményindító, több dokumentum lekérése az SqlQuery használatával

Az alábbi példa egy Azure Cosmos DB bemeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt, amely a kötést használja. A függvény egy SQL-lekérdezés által megadott több dokumentumot kér le egy üzenetsor-eseményindító használatával a lekérdezési paraméterek testreszabásához.

Az üzenetsor-eseményindító egy paramétert departmentIdbiztosít. Egy üzenetsor { "departmentId" : "Finance" } a pénzügyi részleg összes rekordját visszaadja.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    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-eseményindító, azonosító keresése lekérdezési sztringből

Az alábbi példa egy C# szkriptfüggvényt mutat be, amely egyetlen dokumentumot kér le. A függvényt egy HTTP-kérés aktiválja, amely lekérdezési sztringet használ a kereséshez használt azonosító és partíciókulcs értékének megadásához. Ezzel az azonosítóval és partíciókulcs-értékkel kér le egy dokumentumot ToDoItem a megadott adatbázisból és gyűjteményből.

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító, azonosító keresése útvonaladatokból

Az alábbi példa egy C# szkriptfüggvényt mutat be, amely egyetlen dokumentumot kér le. A függvényt egy HTTP-kérés aktiválja, amely útvonaladatokat használ a megkeresendő azonosító és partíciókulcs értékének megadásához. Ezzel az azonosítóval és partíciókulcs-értékkel kér le egy dokumentumot ToDoItem a megadott adatbázisból és gyűjteményből.

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító, több dokumentum lekérése az SqlQuery használatával

Az alábbi példa egy C#-szkriptfüggvényt mutat be, amely lekéri a dokumentumok listáját. A függvényt HTTP-kérés aktiválja. A lekérdezés az SqlQuery attribútumtulajdonságban van megadva.

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító, több dokumentum lekérése a DocumentClient használatával

Az alábbi példa egy C#-szkriptfüggvényt mutat be, amely lekéri a dokumentumok listáját. A függvényt HTTP-kérés aktiválja. A kód az DocumentClient Azure Cosmos DB-kötés által biztosított példányt használja a dokumentumok listájának olvasásához. A DocumentClient példány írási műveletekhez is használható.

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

#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 kimenet

Ez a szakasz csak a bővítmény 4.x+ verziójának támogatását ismerteti.

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
databaseName	Az Azure Cosmos DB-adatbázis neve a figyelt tárolóval.
containerName	A figyelt tároló neve.
createIfNotExists	Logikai érték, amely jelzi, hogy a tároló akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új tárolók fenntartott átviteli sebességgel jönnek létre, ami költséghatással jár. További tájékoztatás a díjszabási oldalon olvasható.
partitionKey	Ha `createIfNotExists` igaz, meghatározza a létrehozott tároló partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
containerThroughput	Ha `createIfNotExists` igaz, meghatározza a létrehozott tároló átviteli sebességét .
preferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. For example, `East US,South Central US,North Europe`.

Ez a szakasz a következő példákat tartalmazza:

Üzenetsor-eseményindító, egy dokumentum írása
Üzenetsor-eseményindító, dokumentumok írása az IAsyncCollector használatával

Üzenetsor-eseményindító, egy dokumentum írása

Az alábbi példa egy Azure Cosmos DB kimeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt , amely a kötést használja. A függvény egy üzenetsor bemeneti kötését használja egy üzenetsorhoz, amely a következő formátumban fogadja a JSON-t:

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

A függvény minden rekordhoz az alábbi formátumban hozza létre az Azure Cosmos DB-dokumentumokat:

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

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    #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
      };
    }

Üzenetsor-eseményindító, dokumentumok írása az IAsyncCollector használatával

Ha több dokumentumot szeretne létrehozni, a támogatott típusok egyikéhez kapcsolódhat ICollector<T> vagy IAsyncCollector<T> hol T található.

Ez a példa egy egyszerű ToDoItem típusra utal:

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

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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 eseményindító

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    #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 bemenet

Ez a szakasz a következő példákat tartalmazza:

Üzenetsor-eseményindító, azonosító keresése sztringből
Üzenetsor-eseményindító, több dokumentum lekérése az SqlQuery használatával
HTTP-eseményindító, azonosító keresése lekérdezési sztringből
HTTP-eseményindító, azonosító keresése útvonaladatokból
HTTP-eseményindító, több dokumentum lekérése az SqlQuery használatával
HTTP-eseményindító, több dokumentum lekérése a DocumentClient használatával

A HTTP-eseményindító példái egy egyszerű ToDoItem típusra vonatkoznak:

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

Üzenetsor-eseményindító, azonosító keresése sztringből

Az alábbi példa egy Azure Cosmos DB bemeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt , amely a kötést használja. A függvény egyetlen dokumentumot olvas be, és frissíti a dokumentum szöveges értékét.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    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.";
    }

Üzenetsor-eseményindító, több dokumentum lekérése az SqlQuery használatával

Az alábbi példa egy Azure Cosmos DB bemeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt , amely a kötést használja. A függvény egy SQL-lekérdezés által megadott több dokumentumot kér le egy üzenetsor-eseményindító használatával a lekérdezési paraméterek testreszabásához.

Az üzenetsor-eseményindító egy paramétert departmentIdbiztosít. Egy üzenetsor { "departmentId" : "Finance" } a pénzügyi részleg összes rekordját visszaadja.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    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-eseményindító, azonosító keresése lekérdezési sztringből

Az alábbi példa egy C# szkriptfüggvényt mutat be, amely egyetlen dokumentumot kér le. A függvényt egy olyan HTTP-kérés aktiválja, amely egy lekérdezési sztringgel adja meg a keresendő azonosítót. Ez az azonosító egy dokumentum lekérésére ToDoItem szolgál a megadott adatbázisból és gyűjteményből.

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító, azonosító keresése útvonaladatokból

Az alábbi példa egy C# szkriptfüggvényt mutat be, amely egyetlen dokumentumot kér le. A függvényt egy HTTP-kérés aktiválja, amely útvonaladatokat használ a keresendő azonosító megadásához. Ez az azonosító egy dokumentum lekérésére ToDoItem szolgál a megadott adatbázisból és gyűjteményből.

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító, több dokumentum lekérése az SqlQuery használatával

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító, több dokumentum lekérése a DocumentClient használatával

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

#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 kimenet

Ez a szakasz a következő példákat tartalmazza:

Üzenetsor-eseményindító, egy dokumentum írása
Üzenetsor-eseményindító, dokumentumok írása a következő használatával: IAsyncCollector

Üzenetsor-eseményindító, egy dokumentum írása

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

A függvény minden rekordhoz az alábbi formátumban hozza létre az Azure Cosmos DB-dokumentumokat:

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

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

    #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
        };
    }

Üzenetsor-eseményindító, dokumentumok írása az IAsyncCollector használatával

Ha több dokumentumot szeretne létrehozni, a támogatott típusok egyikéhez kapcsolódhat ICollector<T> vagy IAsyncCollector<T> hol T található.

Ez a példa egy egyszerű ToDoItem típusra utal:

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

A function.json fájl a következő:

{
  "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
}

A C# szkriptkódja a következő:

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-eseményindító

Az Azure SQL-eseményindítóhoz további minták érhetők el a GitHub-adattárban.

A példa egy ToDoItem osztályra és egy megfelelő adatbázistáblára hivatkozik:

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
);

A változáskövetés engedélyezve van az adatbázisban és a táblában:

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

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

Az SQL-eseményindító egy IReadOnlyList<SqlChange<T>>, két tulajdonsággal rendelkező objektumlistához SqlChange kapcsolódik:

Elem: a módosított elem. Az elem típusának az osztályban látható táblázatsémát kell követnie ToDoItem .
Művelet: enumerálási SqlChangeOperation érték. A lehetséges értékek: Insert, Update és Delete.

Az alábbi példa egy SQL-eseményindítót mutat be egy function.json fájlban, és egy C# szkriptfüggvényt , amely a tábla módosításakor ToDo lesz meghívva:

A következő kötési adatok a function.json fájlban vannak:

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

A C# szkriptfüggvény a következő:

#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-bemenet

Az Azure SQL bemeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből
HTTP-eseményindító, sorok törlése

A példák egy ToDoItem osztályra és egy megfelelő adatbázistáblára vonatkoznak:

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-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy Azure SQL bemeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényt , amely a kötést használja. A függvényt egy HTTP-kérés aktiválja, amely egy lekérdezési sztringet használ az azonosító megadásához. Ez az azonosító egy rekord lekérésére ToDoItem szolgál a megadott lekérdezéssel.

Megjegyzés:

A HTTP lekérdezési sztring paramétere megkülönbözteti a kis- és nagybetűk értékét.

A function.json fájl kötési adatai a következők:

{
    "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"
}

A C# szkriptkódja a következő:

#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-eseményindító, sorok törlése

Az alábbi példa egy Azure SQL bemeneti kötést mutat be egy function.json fájlban, valamint egy C# szkriptfüggvényt , amely a kötés használatával hajt végre egy tárolt eljárást a HTTP-kérelem lekérdezési paraméterének bemenetével. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az SQL-adatbázisban.

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

A function.json fájl kötési adatai a következők:

{
    "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);
        }
    }
}

A C# szkriptkódja a következő:

#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-kimenet

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

HTTP-eseményindító, rekordok írása egy táblába
HTTP-eseményindító, írás két táblába

A példák egy ToDoItem osztályra és egy megfelelő adatbázistáblára vonatkoznak:

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-eseményindító, rekordok írása egy táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be egy function.json fájlban, valamint egy C# szkriptfüggvényt , amely rekordokat ad hozzá egy táblához, és egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként.

A következő kötési adatok a function.json fájlban vannak:

{
    "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"
}

A C# példaszkript kódja a következő:

#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-eseményindító, írás két táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be egy function.json fájlban és egy C# szkriptfüggvényben , amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (dbo.ToDo és dbo.RequestLog), amelyek egy HTTP POST-kérelemben megadott adatokat használnak JSON-törzsként és több kimeneti kötésként.

A második tábla dbo.RequestLoga következő definíciónak felel meg:

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

A következő kötési adatok a function.json fájlban vannak:

{
    "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"
}

A C# példaszkript kódja a következő:

#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 kimenet

Az alábbi példa egy RabbitMQ kimeneti kötést mutat be egy function.json fájlban, és egy C# szkriptfüggvényt , amely a kötést használja. A függvény beolvassa az üzenetet egy HTTP-eseményindítóból, és a RabbitMQ-üzenetsorba küldi.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

using System;
using Microsoft.Extensions.Logging;

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

SendGrid-kimenet

Az alábbi példa egy SendGrid kimeneti kötést mutat be egy function.json fájlban, és egy C# szkriptfüggvényt , amely a kötést használja.

A function.json fájl kötési adatai a következők:

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

A C# szkriptkódja a következő:

#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-eseményindító

Íme egy példa kötési adatok a function.json fájlban:

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

És itt van a kód:

#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-bemenet

Az alábbi példa egy SignalR kapcsolatinformációs bemeneti kötést mutat be egy function.json fájlban, és egy C# szkriptfüggvényt , amely a kötést használja a kapcsolati adatok visszaadásához.

Az alábbi kötési adatok a function.json fájlban vannak:

Példa function.json:

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

A C# szkriptkódja a következő:

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

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

A kötés tulajdonságát a fejlécből származó értékre állíthatja userId egy kötési kifejezéssel: {headers.x-ms-client-principal-id} vagy {headers.x-ms-client-principal-name}.

Példa 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"
}

A C# szkriptkódja a következő:

#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-kimenet

Az alábbi kötési adatok a function.json fájlban vannak:

Példa function.json:

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

A C# szkriptkódja a következő:

#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 }
        });
}

A SignalR-üzenetben megadott felhasználói azonosító beállításával csak olyan kapcsolatoknak küldhet üzenetet, amelyek hitelesítése megtörtént a felhasználó számára.

Példa function.json:

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

A C# szkriptkódja a következő:

#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 }
        });
}

Csak a csoporthoz hozzáadott kapcsolatoknak küldhet üzenetet a SignalR üzenetben a csoport nevének beállításával.

Példa function.json:

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

A C# szkriptkódja a következő:

#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 }
        });
}

A SignalR szolgáltatás lehetővé teszi a felhasználók vagy kapcsolatok csoportokhoz való hozzáadását. Ezután üzeneteket küldhet egy csoportnak. A kimeneti kötéssel kezelheti a SignalR csoportokat.

Az alábbi példa egy felhasználót ad hozzá egy csoporthoz.

Példa függvény.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
        });
}

Az alábbi példa eltávolít egy felhasználót egy csoportból.

Példa függvény.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-kimenet

Az alábbi példa egy Twilio kimeneti kötést mutat be egy function.json fájlban, és egy C# szkriptfüggvényt , amely a kötést használja. A függvény paraméterrel out küld szöveges üzenetet.

Az alábbi kötési adatok a function.json fájlban vannak:

Példa function.json:

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

A következő C#-szkriptkód:

#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;
}

A paraméterek nem használhatók az aszinkron kódban. Íme egy aszinkron C#-szkriptkód- példa:

#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);
}

Bemelegítési eseményindító

Az alábbi példa egy bemelegítési eseményindítót mutat be egy function.json fájlban, és egy C# szkriptfüggvényt , amely minden új példányon fut, amikor hozzáadják az alkalmazáshoz.

A Functions-futtatókörnyezet 1.x-es verziója nem támogatott.

A function.json fájl a következő:

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

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

További lépések

További információ az eseményindítókról és kötésekről

További információ az Azure Functions ajánlott eljárásairól