Referenční informace pro vývojáře pro skript Jazyk C# služby Azure Functions (.csx)

Článek
10/18/2023

Tento článek je úvodem k vývoji azure Functions pomocí skriptu jazyka C# (.csx).

Důležité

Skript jazyka C# je podporovaný především proto, aby poskytoval pohodlné prostředí na portálu, které vám pomůže rychle začít vytvářet a spouštět funkce jazyka C#. Pro aplikace v produkční kvalitě byste měli místo toho vyvíjet funkce jazyka C# místně jako kompilovaný projekt knihovny tříd C#. Informace o migraci projektu skriptu jazyka C# do projektu knihovny tříd jazyka C# (izolovaný pracovní proces) najdete v tématu Převod aplikace skriptů jazyka C# na projekt jazyka C#.

Azure Functions umožňuje vyvíjet funkce pomocí jazyka C# jedním z následujících způsobů:

Typ	Proces provádění	Rozšíření kódu	Vývojové prostředí	Reference
Skript jazyka C#	v procesu	.Csx	Azure Portal Základní nástroje	Tento článek
Knihovna tříd jazyka C# (izolovaný pracovní proces)	izolovaný pracovní proces	.cs	Visual Studio Visual Studio Code Základní nástroje	Funkce izolovaného pracovního procesu .NET
Knihovna tříd jazyka C# (v procesu)	v procesu	.cs	Visual Studio Visual Studio Code Základní nástroje	Funkce knihovny tříd jazyka C# v procesu

Jak .csx funguje

Data proudí do funkce jazyka C# prostřednictvím argumentů metody. Názvy argumentů jsou zadané v function.json souboru a existují předdefinované názvy pro přístup k funkcím, jako jsou protokolovací nástroj funkce a tokeny zrušení.

Formát .csx umožňuje psát méně "často používané" a soustředit se na psaní pouze funkce jazyka C#. Místo zabalení všeho do oboru názvů a třídy stačí definovat metodu Run . Zahrňte všechny odkazy na sestavení a obory názvů na začátku souboru jako obvykle.

Soubory .csx aplikace funkcí se kompilují při inicializaci instance. Tento krok kompilace znamená, že u funkcí skriptů jazyka C# může trvat delší dobu než knihovny tříd jazyka C#. Tento krok kompilace je také důvodem, proč je možné upravovat funkce skriptů jazyka C# na webu Azure Portal, zatímco knihovny tříd jazyka C#nejsou.

Struktura složek

Struktura složek pro projekt skriptu jazyka C# vypadá jako v následujícím příkladu:

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

Existuje sdílený soubor host.json , který se dá použít ke konfiguraci aplikace funkcí. Každá funkce má vlastní soubor kódu (.csx) a konfigurační soubor vazby (function.json).

Rozšíření vazeb požadovaná ve verzi 2.x a novějších verzích modulu runtime Functions jsou definována v extensions.csproj souboru se skutečnými soubory knihovny ve bin složce. Při místním vývoji musíte zaregistrovat rozšíření vazeb. Při vývoji funkcí na webu Azure Portal se tato registrace provádí za vás.

Vazba na argumenty

Vstupní nebo výstupní data jsou svázaná s parametrem funkce skriptu jazyka C# prostřednictvím name vlastnosti v konfiguračním souboru function.json . Následující příklad ukazuje soubor function.json a soubor run.csx pro funkci aktivovanou frontou. Parametr, který přijímá data ze zprávy fronty, je pojmenovaný myQueueItem , protože je to hodnota name vlastnosti.

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

Prohlášení #r je vysvětleno dále v tomto článku.

Podporované typy vazeb

Každá vazba má své vlastní podporované typy; Trigger objektu blob je například možné použít s parametrem řetězce, parametrem POCO, parametrem CloudBlockBlob nebo některým z několika dalších podporovaných typů. Referenční článek vazby pro vazby objektů blob obsahuje seznam všech podporovaných typů parametrů pro triggery objektů blob. Další informace najdete v tématu Triggery a vazby a referenční dokumenty k vazbám pro každý typ vazby.

Tip

Pokud plánujete používat vazby HTTP nebo WebHook, naplánujte, aby se zabránilo vyčerpání portů, které může být způsobeno nesprávnou instancí HttpClient. Další informace najdete v tématu Správa připojení ve službě Azure Functions.

Odkazování na vlastní třídy

Pokud potřebujete použít vlastní třídu POCO (Plain Old Object), můžete zahrnout definici třídy do stejného souboru nebo jej umístit do samostatného souboru.

Následující příklad ukazuje příklad run.csx , který obsahuje definici třídy POCO.

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

Třída POCO musí mít pro každou vlastnost definovaný getter a setter.

Opětovné spuštění kódu .csx

V souboru run.csx můžete použít třídy a metody definované v jiných souborech .csx. Uděláte to tak, že v souboru run.csx použijete #loaddirektivy. V následujícím příkladu je rutina protokolování s názvem MyLogger sdílena v myLogger.csx a načtena do run.csx pomocí direktivy #load :

Příklad 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říklad mylogger.csx:

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

Použití sdíleného souboru .csx je běžný vzor, pokud chcete silně zadat data předaná mezi funkcemi pomocí objektu POCO. V následujícím zjednodušeném příkladu trigger HTTP a trigger fronty sdílejí objekt POCO s názvem Order silného typu data objednávky:

Příklad run.csx pro trigger HTTP:

#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říklad run.csx pro trigger fronty:

#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říklad 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}";
    }
}

S direktivou #load můžete použít relativní cestu:

#load "mylogger.csx" načte soubor umístěný ve složce funkce.
#load "loadedfiles\mylogger.csx" načte soubor umístěný ve složce ve složce funkce.
#load "..\shared\mylogger.csx" načte soubor umístěný ve složce na stejné úrovni jako složka funkce, tj. přímo pod wwwroot.

Direktiva #load funguje pouze se soubory .csx , nikoli se soubory .cs .

Vazba na vrácenou hodnotu metody

Pro výstupní vazbu můžete použít návratovou hodnotu metody pomocí názvu $return ve function.json.

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

Tady je kód skriptu jazyka C#, který používá návratovou hodnotu následovanou asynchronním příkladem:

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

Návratovou hodnotu použijte pouze v případě, že úspěšné spuštění funkce vždy vede k návratové hodnotě, která se má předat výstupní vazbě. V opačném případě použijte ICollector nebo IAsyncCollector, jak je znázorněno v následující části.

Zápis více výstupních hodnot

Pokud chcete na výstupní vazbu napsat více hodnot nebo pokud úspěšné vyvolání funkce nemusí vést k předání výstupní vazby, použijte tyto ICollector nebo IAsyncCollector typy. Tyto typy jsou kolekce jen pro zápis, které jsou zapsány do výstupní vazby po dokončení metody.

Tento příklad zapíše více zpráv front do stejné fronty pomocí ICollector:

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

Protokolování

Pokud chcete protokolovat výstup do protokolů streamování v jazyce C#, uveďte argument typu ILogger. Doporučujeme ho logpojmenovat . Vyhněte se používání Console.Write ve službě Azure Functions.

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

Poznámka:

Informace o novějším rozhraní protokolování, které můžete místo toho použít TraceWriter, najdete v dokumentaci ILoggeru v příručce pro vývojáře knihovny tříd .NET.

Protokolování vlastních metrik

Metodu LogMetricILogger rozšíření můžete použít k vytvoření vlastních metrik v Přehledy aplikace. Tady je volání ukázkové metody:

logger.LogMetric("TestMetric", 1234);

Tento kód je alternativou k volání TrackMetric pomocí rozhraní API Přehledy aplikace pro .NET.

Async

Pokud chcete, aby byla funkce asynchronní, použijte async klíčové slovo a vraťte Taskobjekt.

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

Parametry nemůžete použít out v asynchronních funkcích. Pro výstupní vazby použijte místo toho návratovou hodnotu funkce nebo objekt kolektoru.

Tokeny zrušení

Funkce může přijmout parametr CancellationToken , který umožňuje operačnímu systému upozornit váš kód, když se funkce chystá ukončit. Pomocí tohoto oznámení můžete zajistit, aby se funkce neočekávaně neukončila způsobem, který ponechá data v nekonzistentním stavu.

Následující příklad ukazuje, jak zkontrolovat blížící se ukončení funkce.

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

Import oborů názvů

Pokud potřebujete importovat obory názvů, můžete to provést obvyklým způsobem pomocí using klauzule.

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

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

Následující obory názvů se automaticky naimportují a jsou proto volitelné:

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

Odkazování na externí sestavení

Pro sestavení architektury přidejte odkazy pomocí direktivy #r "AssemblyName" .

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

Následující sestavení se automaticky přidají hostitelským prostředím Azure Functions:

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

Na následující sestavení lze odkazovat jednoduchým názvem podle verze modulu runtime:

v2.x+
v1.x

Newtonsoft.Json
Microsoft.WindowsAzure.Storage^*

^*Odebráno ve verzi 4.x modulu runtime.

V kódu jsou sestavení odkazována jako na následující příklad:

#r "AssemblyName"

Odkazování na vlastní sestavení

Pokud chcete odkazovat na vlastní sestavení, můžete použít buď sdílené sestavení, nebo privátní sestavení:

Sdílená sestavení se sdílejí napříč všemi funkcemi v rámci aplikace funkcí. Pokud chcete odkazovat na vlastní sestavení, nahrajte sestavení do složky pojmenované bin v kořenové složce (wwwroot) vaší aplikace funkcí.
Soukromá sestavení jsou součástí kontextu dané funkce a podporují načítání různých verzí bokem. Soukromá sestavení by se měla nahrát do bin složky v adresáři funkce. Odkazovat na sestavení pomocí názvu souboru, například #r "MyAssembly.dll".

Informace o tom, jak nahrát soubory do složky funkcí, najdete v části o správě balíčků.

Sledované adresáře

Adresář, který obsahuje soubor skriptu funkce, se automaticky sleduje na změny sestavení. Pokud chcete sledovat změny sestavení v jiných adresářích, přidejte je do watchDirectories seznamu v souboru host.json.

Použití balíčků NuGet

Způsob přidání balíčků rozšíření i dalších balíčků NuGet do vaší aplikace funkcí závisí na cílové verzi modulu runtime Functions.

v2.x+
v1.x

Ve výchozím nastavení jsou podporované sady balíčků NuGet rozšíření Functions dostupné pro vaši aplikaci funkcí skriptů jazyka C#pomocí sad rozšíření. Další informace najdete v tématu Balíčky rozšíření.

Pokud z nějakého důvodu nemůžete v projektu používat sady rozšíření, můžete také pomocí nástrojů Azure Functions Core Tools nainstalovat rozšíření na základě vazeb definovaných v souborech function.json ve vaší aplikaci. Při registraci rozšíření pomocí nástrojů Core Tools nezapomeňte použít tuto --csx možnost. Další informace najdete v tématu instalace rozšíření func.

Core Tools ve výchozím nastavení načte soubory function.json a přidá požadované balíčky do souboru projektu knihovny tříd extensions.csproj C# v kořenovém adresáři systému souborů aplikace funkcí (wwwroot). Vzhledem k tomu, Core Tools používá dotnet.exe, můžete jej použít k přidání libovolného odkazu na balíček NuGet odkaz na tento soubor přípony. Během instalace nástroje Core Tools sestaví rozšíření.csproj pro instalaci požadovaných knihoven. Tady je příklad souboru extensions.csproj , který přidá odkaz na Microsoft.ProjectOxford.Face verze 1.1.0:

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

Poznámka:

Pro skript jazyka C# (.csx) je nutné nastavit TargetFramework hodnotu netstandard2.0. Jiné cílové architektury, například net6.0, nejsou podporovány.

Verze 1.x modulu runtime Functions používá k definování závislostí soubor project.json . Tady je ukázkový soubor project.json :

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

Sady rozšíření nejsou podporovány verzí 1.x.

Pokud chcete použít vlastní informační kanál NuGet, zadejte ho v souboru Nuget.Config v kořenové složce aplikace funkcí. Další informace naleznete v tématu Konfigurace chování NuGet.

Pokud pracujete jenom na projektu na portálu, budete muset soubor extensions.csproj nebo soubor Nuget.Config přímo na webu vytvořit ručně. Další informace najdete v tématu Ruční instalace rozšíření.

Proměnné prostředí

Pokud chcete získat proměnnou prostředí nebo hodnotu nastavení aplikace, použijte System.Environment.GetEnvironmentVariable, jak je znázorněno v následujícím příkladu kódu:

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

Zásady opakování pokusů

Funkce podporuje dvě předdefinované zásady opakování. Další informace najdete v tématu Zásady opakování.

Pevné zpoždění
Exponenciální zpochybnění

Tady je zásada opakování v souboru function.json :

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

function.json – vlastnost	Popis
Strategie	Použijte `fixedDelay`.
maxRetryCount	Povinný: Maximální počet opakování povolených pro každé spuštění funkce. `-1` znamená opakování po neomezenou dobu.
delayInterval	Zpoždění, které se používá mezi opakovanými pokusy. Zadejte ho jako řetězec s formátem `HH:mm:ss`.

Tady je zásada opakování v souboru function.json :

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

function.json – vlastnost	Popis
Strategie	Použijte `exponentialBackoff`.
maxRetryCount	Povinný: Maximální počet opakování povolených pro každé spuštění funkce. `-1` znamená opakování po neomezenou dobu.
minimumInterval	Minimální prodleva opakování. Zadejte ho jako řetězec s formátem `HH:mm:ss`.
maximumInterval	Maximální zpoždění opakování. Zadejte ho jako řetězec s formátem `HH:mm:ss`.

Vazba za běhu

V jazyce C# a dalších jazycích .NET můžete místo deklarativních vazeb ve function.json použít imperativní vzor vazby. Imperativní vazba je užitečná v případě, že parametry vazby je potřeba vypočítat za běhu místo doby návrhu. Pomocí tohoto vzoru můžete vytvořit vazbu na podporované vstupní a výstupní vazby v kódu funkce.

Nadefinujte imperativní vazbu následujícím způsobem:

Nezahrnujte položku do function.json pro požadované imperativní vazby.
Předání vstupního parametru Binder binder nebo IBinder binder.
K provedení datové vazby použijte následující vzor jazyka C#.

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

BindingTypeAttribute je atribut .NET, který definuje vazbu a T je vstupním nebo výstupním typem, který tento typ vazby podporuje. T nemůže být typ parametru out (například out JObject). Výstupní vazba tabulky Mobile Apps například podporuje šest typů výstupu, ale můžete použít pouze ICollector<T> nebo IAsyncCollector<T> pro T.

Příklad s jedním atributem

Následující příklad kódu vytvoří výstupní vazbu objektu blob služby Storage s cestou objektu blob definovanou za běhu a pak zapíše řetězec do objektu blob.

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

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

BlobAttribute definuje vstupní nebo výstupní vazbu objektu blob služby Storage a TextWriter je podporovaný typ výstupní vazby.

Příklad více atributů

Předchozí příklad získá nastavení aplikace pro hlavní účet úložiště aplikace funkcí připojovací řetězec (což je AzureWebJobsStorage). Vlastní nastavení aplikace, které se má použít pro účet úložiště, můžete zadat přidáním atributu StorageAccountAttribute a předáním pole atributů do BindAsync<T>(). Binder Použijte parametr, nikoli IBinder. Příklad:

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

Následující tabulka uvádí atributy .NET pro každý typ vazby a balíčky, ve kterých jsou definovány.

Vytváření vazby	Atribut	Přidání odkazu
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"`
Fronta úložiště	`Microsoft.Azure.WebJobs.QueueAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Objekt blob úložiště	`Microsoft.Azure.WebJobs.BlobAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Tabulka úložiště	`Microsoft.Azure.WebJobs.TableAttribute`, `Microsoft.Azure.WebJobs.StorageAccountAttribute`
Twilio	`Microsoft.Azure.WebJobs.TwilioSmsAttribute`	`#r "Microsoft.Azure.WebJobs.Extensions.Twilio"`

Převod aplikace skriptu jazyka C# na projekt jazyka C#

Nejjednodušší způsob, jak převést aplikaci funkcí skriptu jazyka C# na zkompilovaný projekt knihovny tříd jazyka C#, je začít s novým projektem. Pro každou funkci pak můžete migrovat kód a konfiguraci z každého souboru run.csx a souboru function.json ve složce funkce do jednoho nového souboru knihovny tříd .cs. Pokud máte například funkci skriptu jazyka C#s názvem HelloWorld , budete mít dva soubory: HelloWorld/run.csx a HelloWorld/function.json. Pro tuto funkci vytvoříte soubor kódu pojmenovaný HelloWorld.cs v novém projektu knihovny tříd.

Pokud pro úpravy portálu používáte skriptování v jazyce C#, můžete obsah aplikace stáhnout do místního počítače. Místo projektu Obsah a Visual Studio zvolte možnost Obsah webu. Nemusíte generovat projekt a do stahování nezahrnujte nastavení aplikace. Definujete nové vývojové prostředí a toto prostředí by nemělo mít stejná oprávnění jako prostředí hostované aplikace.

Tyto pokyny ukazují, jak převést funkce skriptů jazyka C# (které běží v procesu s hostitelem functions) na funkce knihovny tříd jazyka C#, které běží v izolovaném pracovním procesu.

V oblíbeném rychlém startu dokončete část Vytvoření projektu aplikace Functions:
Vytvoření funkce jazyka C# v Azure z příkazového řádku

Vytvoření první funkce jazyka C# v Azure pomocí sady Visual Studio

Vytvoření první funkce jazyka C# v Azure pomocí editoru Visual Studio Code

Pokud váš původní kód skriptu C# obsahuje extensions.csproj soubor nebo jakékoli function.proj soubory, zkopírujte odkazy na balíčky z tohoto souboru a přidejte je do souboru nového projektu .csproj ve stejném ItemGroup souboru se závislostmi jádra functions.

Tip

Převod poskytuje dobrou příležitost k aktualizaci na nejnovější verze závislostí. To může vyžadovat další změny kódu v pozdějším kroku.
Zkopírujte obsah původního host.json souboru do souboru nového projektu host.json s výjimkou extensionBundles oddílu (kompilované projekty jazyka C# nepoužívají sady rozšíření a musíte explicitně přidat odkazy na všechna rozšíření používaná funkcemi). Při slučování souborů host.json mějte na paměti, že host.json schéma je s verzí většiny aplikací používajících verzi 2.0. Obsah oddílu extensions se může lišit v závislosti na konkrétních verzích rozšíření vazeb používaných vašimi funkcemi. Informace o správné konfiguraci souboru host.json pro konkrétní verze najdete v článcích s referenčními informacemi o jednotlivých rozšířeních.
Pro všechny sdílené soubory odkazované direktivou #loadvytvořte nový .cs soubor pro každý z těchto sdílených odkazů. Nejjednodušší je vytvořit nový .cs soubor pro každou definici sdílené třídy. Pokud existují statické metody bez třídy, je nutné definovat nové třídy pro tyto metody.
Pro každou <FUNCTION_NAME> složku v původním projektu proveďte následující úlohy:
1. Vytvořte nový soubor s názvem <FUNCTION_NAME>.csa nahraďte <FUNCTION_NAME> názvem složky, která definovala funkci skriptu jazyka C#. Nový soubor kódu funkce můžete vytvořit z jedné ze šablon specifických pro triggery následujícím způsobem:
  func new --name <FUNCTION_NAME> Pomocí příkazu a zvolení správné šablony triggeru na příkazovém řádku.
  
  V průvodci sadou Visual Studio přidejte do projektu funkci.
  
  V průvodci editorem Visual Studio Code přidejte do projektu funkci.
2. Zkopírujte příkazy using ze run.csx souboru a přidejte je do nového souboru. Nepotřebujete žádné #r direktivy.
3. Pro libovolný #load příkaz v run.csx souboru přidejte nový using příkaz pro obor názvů, který jste použili pro sdílený kód.
4. V novém souboru definujte třídu pro vaši funkci v oboru názvů, který používáte pro projekt.
5. Vytvořte novou metodu s názvem RunHandler nebo něco podobného. Tato nová metoda slouží jako nový vstupní bod funkce.
6. Zkopírujte statickou metodu, která představuje vaši funkci a všechny funkce, které volá, z run.csx vaší nové třídy jako druhá metoda. Z nové metody, kterou jste vytvořili v předchozím kroku, zavolejte tuto statickou metodu. Tento krok nepřímého rozdělení je užitečný pro navigaci v případných rozdílech, když budete pokračovat v upgradu. Původní metodu můžete zachovat úplně stejnou a jednoduše řídit její vstupy z nového kontextu. Možná budete muset vytvořit parametry pro novou metodu, kterou pak předáte do volání statické metody. Po potvrzení, že migrace fungovala tak, jak má, můžete odebrat tuto dodatečnou úroveň nepřímého připojení.
7. Pro každou vazbu v function.json souboru přidejte odpovídající atribut do nové metody. Pokud chcete rychle najít příklady vazeb, přečtěte si téma Ruční přidání vazeb na základě příkladů.
8. Pokud jste to ještě neudělali, přidejte do projektu všechny balíčky rozšíření vyžadované vazbami.
Znovu vytvořte všechna nastavení aplikace požadovaná vaší aplikací v Values kolekci souboru local.settings.json.
Ověřte, že projekt běží místně:
Slouží func start ke spuštění aplikace z příkazového řádku. Další informace najdete v tématu Místní spouštění funkcí.

Postupujte podle místně uvedené části Spustit funkce v průvodci sadou Visual Studio.

Postupujte podle místně uvedené části Spustit funkce v průvodci editorem Visual Studio Code.
Publikujte projekt do nové aplikace funkcí v Azure:
Pomocí příkazu vytvořte prostředky Azure a nasaďte projekt kódu do Azure func azure functionapp publish <APP_NAME> . Další informace naleznete v tématu Nasazení souborů projektu.

Postupujte podle části Publikovat do Azure v průvodci sadou Visual Studio.

Postupujte podle části Vytvoření prostředků Azure v průvodci nástrojem Visual Studio Code.

Příklad převodu funkcí

Tato část ukazuje příklad migrace jedné funkce.

Původní funkce ve skriptování jazyka C# má dva soubory:

HelloWorld/function.json
HelloWorld/run.csx

HelloWorld/function.json Obsah:

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

HelloWorld/run.csx Obsah:

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

Po migraci na izolovaný pracovní model s integrací ASP.NET Core se nahradí jedním 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);
        }
    }
}

Konfigurace vazeb a příklady

Tato část obsahuje odkazy a příklady pro definování triggerů a vazeb ve skriptu jazyka C#.

Aktivační událost objektu BLOB

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `blobTrigger`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Musí být nastavena na `in`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která představuje objekt blob v kódu funkce.
path	Kontejner, který se má monitorovat. Může to být vzor názvu objektu blob.
Připojení	Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k objektům blob Azure. Viz Připojení iony.

Následující příklad ukazuje definici triggeru objektu blob v souboru function.json a kódu, který používá vazbu. Funkce zapíše protokol při přidání nebo aktualizaci objektu blob v kontejnerusamples-workitems.

Tady jsou data vazby v souboru function.json :

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

Řetězec {name} v cestě samples-workitems/{name} triggeru objektu blob vytvoří vazbový výraz , který můžete použít v kódu funkce pro přístup k názvu souboru aktivačního objektu blob. Další informace najdete v tématu Vzory názvů objektů blob.

Tady je kód skriptu jazyka C#, který je vázán na Stream:

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

Tady je kód skriptu jazyka C#, který je vázán na CloudBlockBlob:

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.WindowsAzure.Storage.Blob;

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

Vstup objektu blob

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `blob`hodnotu .
direction	Musí být nastavena na `in`hodnotu .
Jméno	Název proměnné, která představuje objekt blob v kódu funkce.
path	Cesta k objektu blob.
Připojení	Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k objektům blob Azure. Viz Připojení iony.

Následující příklad ukazuje vstupní a výstupní vazby objektu blob v souboru function.json a kódu skriptu jazyka C#, který používá vazby. Funkce vytvoří kopii textového objektu blob. Funkce se aktivuje zprávou fronty, která obsahuje název objektu blob, který se má zkopírovat. Nový objekt blob má název {originalblobname}-Copy.

V souboru queueTrigger function.json se vlastnost metadat používá k zadání názvu objektu blob ve path vlastnostech:

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

Tady je kód skriptu jazyka C#:

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

Výstup objektu blob

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `blob`hodnotu .
direction	Musí být nastavena na `out`hodnotu .
Jméno	Název proměnné, která představuje objekt blob v kódu funkce.
path	Cesta k objektu blob.
Připojení	Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k objektům blob Azure. Viz Připojení iony.

V souboru queueTrigger function.json se vlastnost metadat používá k zadání názvu objektu blob ve path vlastnostech:

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

Tady je kód skriptu jazyka C#:

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

Trigger RabbitMQ

Následující příklad ukazuje vazbu triggeru RabbitMQ v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce přečte a zaprokoluje zprávu RabbitMQ.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

using System;

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

Aktivační událost fronty

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `queueTrigger`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Pouze v souboru function.json . Musí být nastavena na `in`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která obsahuje datovou část položky fronty v kódu funkce.
queueName	Název fronty, která se má dotazovat.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke frontám Azure. Viz Připojení iony.

Následující příklad ukazuje vazbu triggeru fronty v souboru function.json a kódu skriptu jazyka C#, který používá vazbu. Funkce se dotazuje fronty myqueue-items a zapíše protokol při každém zpracování položky fronty.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Výstup fronty

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `queue`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Musí být nastavena na `out`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která představuje frontu v kódu funkce. Nastaví se tak, aby `$return` odkaz na vrácenou hodnotu funkce.
queueName	Název fronty.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke frontám Azure. Viz Připojení iony.

Následující příklad ukazuje vazbu triggeru HTTP v souboru function.json a kódu skriptu jazyka C#, který používá vazbu. Funkce vytvoří položku fronty s datovou částí objektu CustomQueueMessage pro každý přijatý požadavek HTTP.

Tady je soubor function.json :

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

Tady je kód skriptu C#, který vytvoří jednu zprávu fronty:

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

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

Pomocí parametru ICollector nebo parametru IAsyncCollector můžete odeslat více zpráv najednou. Tady je kód skriptu jazyka C#, který odesílá více zpráv, jeden s daty požadavku HTTP a druhý s pevně zakódovanými hodnotami:

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

Vstup tabulky

Tato část popisuje podporu pouze verze rozhraní Tables API rozšíření .

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `table`hodnotu . Tato vlastnost se nastaví automaticky při vytváření vazby na webu Azure Portal.
direction	Musí být nastavena na `in`hodnotu . Tato vlastnost se nastaví automaticky při vytváření vazby na webu Azure Portal.
Jméno	Název proměnné, která představuje tabulku nebo entitu v kódu funkce.
Tablename	Název tabulky.
partitionKey	Nepovinné. Klíč oddílu entity tabulky, který se má přečíst.
rowKey	Nepovinné. Klíč řádku entity tabulky, který se má přečíst. Nelze použít s `take` nebo `filter`.
vzít	Nepovinné. Maximální počet entit, které se mají vrátit. Nelze použít s `rowKey`.
filter	Nepovinné. Výraz filtru OData pro entity, které se mají vrátit z tabulky. Nelze použít s `rowKey`.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke službě Table Service. Viz Připojení iony.

Následující příklad ukazuje vstupní vazbu tabulky v souboru function.json a kódu skriptu jazyka C#, který používá vazbu. Funkce používá trigger fronty ke čtení jednoho řádku tabulky.

Soubor function.json určuje a partitionKey .rowKey Hodnota rowKey{queueTrigger} označuje, že klíč řádku pochází z řetězce zprávy fronty.

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

Tady je kód skriptu jazyka C#:

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

Výstup tabulky

Tato část popisuje podporu pouze verze rozhraní Tables API rozšíření .

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `table`hodnotu . Tato vlastnost se nastaví automaticky při vytváření vazby na webu Azure Portal.
direction	Musí být nastavena na `out`hodnotu . Tato vlastnost se nastaví automaticky při vytváření vazby na webu Azure Portal.
Jméno	Název proměnné použitý v kódu funkce, který představuje tabulku nebo entitu. Nastaví se tak, aby `$return` odkaz na vrácenou hodnotu funkce.
Tablename	Název tabulky, do které se má zapisovat.
partitionKey	Klíč oddílu entity tabulky, který se má zapisovat.
rowKey	Klíč řádku entity tabulky, která se má zapisovat.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke službě Table Service. Viz Připojení iony.

Následující příklad ukazuje výstupní vazbu tabulky v souboru function.json a kódu skriptu jazyka C#, který používá vazbu. Funkce zapíše více entit tabulky.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger časovače

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `timerTrigger`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Musí být nastavena na `in`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která představuje objekt časovače v kódu funkce.
schedule	Výraz CRON nebo hodnota TimeSpan Dá `TimeSpan` se použít jenom pro aplikaci funkcí, která běží v plánu služby App Service. Výraz plánu můžete vložit do nastavení aplikace a nastavit tuto vlastnost na název nastavení aplikace zabalený jako v % tomto příkladu: %ScheduleAppSetting%.
runOnStartup	Pokud `true`se funkce vyvolá při spuštění modulu runtime. Modul runtime se například spustí, když se aplikace funkcí probudí po nečinnosti z důvodu neaktivity, když se aplikace funkcí restartuje kvůli změnám funkce a když se aplikace funkcí škáluje na více instancí. Používejte s opatrností.RunOnStartup by mělo být zřídka, pokud je někdy nastaveno na `true`, zejména v produkčním prostředí.
useMonitor	Nastavením na hodnotu `true` nebo `false` určíte, jestli se má plán monitorovat. Monitorování plánu zachovává výskyty plánu, aby bylo zajištěno, že je plán správně udržován i v případě, že se instance aplikace funkcí restartují. Pokud není nastavené explicitně, výchozí hodnota je `true` pro plány, které mají interval opakování větší nebo roven 1 minutě. Pro plány, které se aktivují více než jednou za minutu, je `false`výchozí hodnota .

Následující příklad ukazuje vazbu triggeru časovače v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce zapíše protokol označující, jestli je vyvolání této funkce způsobeno zmeškaným výskytem plánu. Objekt TimerInfo se předá do funkce.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP

Následující tabulka vysvětluje vlastnosti konfigurace triggeru, které jste nastavili v souboru function.json :

function.json – vlastnost	Popis
type	Povinné – musí být nastaveno na `httpTrigger`hodnotu .
direction	Povinné – musí být nastaveno na `in`hodnotu .
Jméno	Povinný argument – název proměnné použité v kódu funkce pro text požadavku nebo požadavku.
authLevel	Určuje, jaké klíče, pokud existují, musí být na požadavku přítomny, aby bylo možné vyvolat funkci. Podporované hodnoty najdete v tématu Úroveň autorizace.
Metody	Pole metod HTTP, na které funkce reaguje. Pokud není zadáno, funkce odpoví na všechny metody HTTP. Viz přizpůsobení koncového bodu HTTP.
Postupu	Definuje šablonu trasy, která určuje, na které adresy URL požadavků vaše funkce reaguje. Výchozí hodnota, pokud není k dispozici `<functionname>`žádná je . Další informace najdete v tématu Přizpůsobení koncového bodu HTTP.
webHookType	Podporuje se pouze pro modul runtime verze 1.x. Nakonfiguruje trigger HTTP tak, aby fungoval jako příjemce webhooku pro zadaného zprostředkovatele. Podporované hodnoty najdete v tématu Typ webhooku.

Následující příklad ukazuje vazbu triggeru v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce hledá name parametr buď v řetězci dotazu, nebo v textu požadavku HTTP.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#, který je svázaný s HttpRequest:

#r "Newtonsoft.Json"

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

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

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

Místo objektu lze vytvořit vazbu k vlastnímu objektu HttpRequest. Tento objekt se vytvoří z textu požadavku a parsuje se jako JSON. Podobně lze typ předat výstupní vazbě odpovědi HTTP a vrátit jako text odpovědi spolu se stavovým kódem 200 .

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

Výstup HTTP

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

Vlastnost	Popis
type	Musí být nastavena na `http`hodnotu .
direction	Musí být nastavena na `out`hodnotu .
Jméno	Název proměnné použité v kódu funkce pro odpověď nebo `$return` použití návratové hodnoty.

Trigger služby Event Hubs

Následující tabulka vysvětluje vlastnosti konfigurace triggeru, které jste nastavili v souboru function.json :

function.json – vlastnost	Popis
type	Musí být nastavena na `eventHubTrigger`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Musí být nastavena na `in`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která představuje položku události v kódu funkce.
eventHubName	Funkce 2.x a vyšší Název centra událostí. Pokud se v připojovací řetězec nachází také název centra událostí, tato hodnota přepíše tuto vlastnost za běhu. Můžete na to odkazovat prostřednictvím nastavení`%eventHubName%` aplikace. Ve verzi 1.x má tato vlastnost název `path`.
consumerGroup	Volitelná vlastnost, která nastaví skupinu příjemců použitou k přihlášení k odběru událostí v centru. Pokud tuto možnost vynecháte, `$Default` použije se skupina příjemců.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke službě Event Hubs. Viz Připojení iony.

Následující příklad ukazuje vazbu triggeru služby Event Hubs v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce protokoluje text zprávy triggeru Event Hubs.

Následující příklady ukazují data vazby služby Event Hubs v souboru function.json pro modul runtime Functions verze 2.x a novější verze.

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

Tady je kód skriptu jazyka C#:

using System;

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

Pokud chcete získat přístup k metadatům událostí v kódu funkce, vytvořte vazbu na objekt EventData . Ke stejným vlastnostem můžete přistupovat také pomocí vazeb výrazů v podpisu metody. Následující příklad ukazuje oba způsoby, jak získat stejná data:

#r "Microsoft.Azure.EventHubs"

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

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

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

Pokud chcete přijímat události v dávce, vytvořte string nebo EventData matici:

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

Výstup služby Event Hubs

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `eventHub`hodnotu .
direction	Musí být nastavena na `out`hodnotu . Tento parametr se nastaví automaticky při vytváření vazby na webu Azure Portal.
Jméno	Název proměnné použitý v kódu funkce, který představuje událost.
eventHubName	Funkce 2.x a vyšší Název centra událostí. Pokud se v připojovací řetězec nachází také název centra událostí, tato hodnota přepíše tuto vlastnost za běhu. Ve službě Functions 1.x má tato vlastnost název `path`.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke službě Event Hubs. Další informace najdete v tématu Připojení iony.

Následující příklad ukazuje vazbu triggeru centra událostí v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce zapíše zprávu do centra událostí.

Následující příklady ukazují data vazby služby Event Hubs v souboru function.json pro modul runtime Functions verze 2.x a novější verze.

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

Tady je kód skriptu jazyka C#, který vytvoří jednu zprávu:

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

Tady je kód skriptu C#, který vytváří více zpráv:

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

Trigger Event Grid

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json . V atributu nejsou nastaveny žádné parametry ani vlastnosti konstruktoru EventGridTrigger .

function.json – vlastnost	Popis
type	Povinné – musí být nastaveno na `eventGridTrigger`hodnotu .
direction	Povinné – musí být nastaveno na `in`hodnotu .
Jméno	Povinné – název proměnné použité v kódu funkce pro parametr, který přijímá data události.

Následující příklad ukazuje trigger Event Gridu definovaný v souboru function.json .

Tady jsou data vazby v souboru function.json :

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

Tady je příklad funkce skriptu jazyka C#, která používá EventGridEvent parametr vazby:

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

Tady je příklad funkce skriptu jazyka C#, která používá JObject parametr vazby:

#r "Newtonsoft.Json"

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

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

Výstup Event Gridu

Následující tabulka vysvětluje vlastnosti konfigurace vazby pro skript jazyka C#, který jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `eventGrid`hodnotu .
direction	Musí být nastavena na `out`hodnotu . Tento parametr se nastaví automaticky při vytváření vazby na webu Azure Portal.
Jméno	Název proměnné použitý v kódu funkce, který představuje událost.
topicEndpointUri	Název nastavení aplikace, které obsahuje identifikátor URI pro vlastní téma, například `MyTopicEndpointUri`.
topicKeySetting	Název nastavení aplikace, které obsahuje přístupový klíč pro vlastní téma.

Následující příklad ukazuje výstupní data vazby Event Gridu v souboru function.json .

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

Tady je kód skriptu jazyka C#, který vytvoří jednu událost:

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

Tady je kód skriptu C#, který vytvoří více událostí:

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

Trigger služby Service Bus

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `serviceBusTrigger`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Musí být nastavena na `in`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která představuje zprávu fronty nebo tématu v kódu funkce.
queueName	Název fronty, která se má monitorovat. Nastavit pouze v případě monitorování fronty, ne pro téma.
topicName	Název tématu, které chcete monitorovat. Nastavte pouze v případě monitorování tématu, ne pro frontu.
subscriptionName	Název předplatného, které chcete monitorovat. Nastavte pouze v případě monitorování tématu, ne pro frontu.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke službě Service Bus. Viz Připojení iony.
accessRights	Přístupová práva pro připojovací řetězec Dostupné hodnoty jsou `manage` a `listen`. Výchozí hodnota je `manage`, což označuje, že `connection` má oprávnění Spravovat . Pokud používáte připojovací řetězec, který nemá oprávnění Spravovat, nastavte `accessRights` na "listen". Jinak může modul runtime služby Functions selhat při pokusu o provádění operací, které vyžadují práva pro správu. Ve službě Azure Functions verze 2.x a vyšší není tato vlastnost dostupná, protože nejnovější verze sady Service Bus SDK nepodporuje operace správy.
isSessionsEnabled	`true`pokud se připojujete k frontě nebo předplatnému pracujícímu s relacemi. `false` jinak, což je výchozí hodnota.
Automatické dokončování	`true` kdy by se trigger měl po zpracování automaticky volat, nebo pokud kód funkce bude ručně volat. Nastavení pro `false` jazyk C# je podporováno pouze v jazyce C#. Pokud je nastavená hodnota `true`, trigger zprávu automaticky dokončí, pokud se provádění funkce úspěšně dokončí, a jinak zprávu opustí. <br/When set to `false`, you are responsible for call ServiceBusReceiver methods to complete, abandon, or deadletter the message, session, or batch. Pokud je vyvolána výjimka (a žádná z `ServiceBusReceiver` metod není volána), zámek zůstane. Po vypršení platnosti zámku se zpráva znovu zařadí do fronty s přírůstkem `DeliveryCount` a zámek se automaticky obnoví. Tato vlastnost je dostupná pouze ve službě Azure Functions 2.x a vyšší.

Následující příklad ukazuje vazbu triggeru služby Service Bus v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce čte metadata zpráv a protokoluje zprávu fronty služby Service Bus.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Výstup služby Service Bus

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `serviceBus`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
direction	Musí být nastavena na `out`hodnotu . Tato vlastnost se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné, která představuje zprávu fronty nebo tématu v kódu funkce. Pokud chcete odkazovat na návratnou hodnotu funkce, nastavte hodnotu $return.
queueName	Název fronty Nastavit pouze v případě odesílání zpráv fronty, nikoli pro téma.
topicName	Název tématu Nastavit pouze v případě odesílání zpráv tématu, ne pro frontu.
Připojení	Název nastavení aplikace nebo nastavení kolekce, která určuje, jak se připojit ke službě Service Bus. Viz Připojení iony.
accessRights (pouze v1)	Přístupová práva pro připojovací řetězec Dostupné hodnoty jsou `manage` a `listen`. Výchozí hodnota je `manage`, což označuje, že `connection` má oprávnění Spravovat . Pokud používáte připojovací řetězec, který nemá oprávnění Spravovat, nastavte `accessRights` na "listen". Jinak může modul runtime služby Functions selhat při pokusu o provádění operací, které vyžadují práva pro správu. Ve službě Azure Functions verze 2.x a vyšší není tato vlastnost dostupná, protože nejnovější verze sady Service Bus SDK nepodporuje operace správy.

Následující příklad ukazuje výstupní vazbu služby Service Bus v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce používá trigger časovače k odeslání zprávy fronty každých 15 sekund.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#, který vytvoří jednu zprávu:

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

Tady je kód skriptu C#, který vytváří více zpráv:

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

Trigger služby Azure Cosmos DB v2

Tato část popisuje podporu pouze pro verzi 4.x+ rozšíření .

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `cosmosDBTrigger`hodnotu .
direction	Musí být nastavena na `in`hodnotu . Tento parametr se nastaví automaticky při vytváření triggeru na webu Azure Portal.
Jméno	Název proměnné použitý v kódu funkce, který představuje seznam dokumentů se změnami.
Připojení	Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k monitorovanému účtu služby Azure Cosmos DB. Další informace najdete v tématu Připojení iony.
Databasename	Název databáze Azure Cosmos DB s monitorovaným kontejnerem.
containerName	Název monitorovaného kontejneru.
zapůjčení Připojení ion	(Volitelné) Název nastavení aplikace nebo nastavení kontejneru, který určuje, jak se připojit k účtu služby Azure Cosmos DB, který obsahuje kontejner zapůjčení. Pokud není nastavená, použije se `connection` hodnota. Tento parametr se automaticky nastaví při vytvoření vazby na portálu. Kontejner zapůjčení připojovací řetězec musí mít oprávnění k zápisu.
leaseDatabaseName	(Volitelné) Název databáze, která obsahuje kontejner použitý k ukládání zapůjčení. Pokud nastavení nenastavíte, použije se hodnota `databaseName` tohoto nastavení.
leaseContainerName	(Volitelné) Název kontejneru použitého k ukládání zapůjčení. Pokud není nastavená, použije se hodnota `leases` .
createLeaseContainerIfNotExists	(Volitelné) Pokud je nastavená hodnota `true`, kontejner zapůjčení se automaticky vytvoří, když ještě neexistuje. Výchozí hodnota je `false`. Pokud použijete identity Microsoft Entra, pokud nastavíte hodnotu na `true`, vytváření kontejnerů není povolená operace a vaše funkce nebude moci spustit.
leasesContainerThroughput	(Volitelné) Definuje počet jednotek žádostí, které se mají přiřadit při vytvoření kontejneru zapůjčení. Toto nastavení se používá pouze v případě, že `createLeaseContainerIfNotExists` je nastavena hodnota `true`. Tento parametr se automaticky nastaví při vytvoření vazby pomocí portálu.
leaseContainerPrefix	(Volitelné) Při nastavení se hodnota přidá jako předpona zapůjčení vytvořeným v kontejneru Zapůjčení pro tuto funkci. Použití předpony umožňuje dvěma samostatným funkcím Azure Functions sdílet stejný kontejner zapůjčení pomocí různých předpon.
feedPollDelay	(Volitelné) Čas (v milisekundách) zpoždění mezi dotazováním oddílu na nové změny v informačním kanálu po vyprázdnění všech aktuálních změn. Výchozí hodnota je 5 000 milisekund nebo 5 sekund.
leaseAcquireInterval	(Volitelné) Když nastavíte, definuje interval v milisekundách, aby se úloha vypočítala, pokud se oddíly rovnoměrně distribuují mezi známé instance hostitele. Výchozí hodnota je 13000 (13 sekund).
leaseExpirationInterval	(Volitelné) Při nastavení definuje v milisekundách interval, pro který se zapůjčení převezme na zapůjčení představující oddíl. Pokud se zapůjčení neprodloužilo v tomto intervalu, způsobí to vypršení platnosti oddílu a vlastnictví oddílu se přesune do jiné instance. Výchozí hodnota je 60000 (60 sekund).
leaseRenewInterval	(Volitelné) Při nastavení definuje interval obnovení pro všechna zapůjčení oddílů, které jsou aktuálně uloženy instancí, v milisekundách. Výchozí hodnota je 17000 (17 sekund).
maxItemsPerInvocation	(Volitelné) Při nastavení nastaví tato vlastnost maximální počet položek přijatých na volání funkce. Pokud se operace v monitorovaném kontejneru provádějí prostřednictvím uložených procedur, při čtení položek z kanálu změn se obor transakcí zachovají. V důsledku toho může být počet přijatých položek vyšší než zadaná hodnota, aby položky změněné stejnou transakcí byly vráceny jako součást jedné atomické dávky.
startFromBeginning	(Volitelné) Tato možnost dává triggeru pokyn ke čtení změn od začátku historie změn kontejneru, nikoli od aktuálního času. Čtení od začátku funguje jenom při prvním spuštění triggeru, protože v následných spuštěních jsou kontrolní body už uložené. Nastavení této možnosti na to, že `true` již vytvořené zapůjčení nemá žádný vliv.
startFromTime	(Volitelné) Získá nebo nastaví datum a čas, ze kterého se má inicializovat operace čtení kanálu změn. Doporučený formát je ISO 8601 s designátorem UTC, například `2021-02-16T14:19:29Z`. Slouží pouze k nastavení počátečního stavu triggeru. Jakmile má trigger stav zapůjčení, změna této hodnoty nemá žádný vliv.
preferredLocations	(Volitelné) Definuje upřednostňovaná umístění (oblasti) pro geograficky replikované databázové účty ve službě Azure Cosmos DB. Hodnoty by měly být oddělené čárkami. Například USA – východ, USA – středojiž, Severní Evropa.

Následující příklad ukazuje vazbu triggeru služby Azure Cosmos DB v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce zapisuje zprávy protokolu při přidání nebo úpravě záznamů služby Azure Cosmos DB.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Vstup služby Azure Cosmos DB v2

Tato část popisuje podporu pouze pro verzi 4.x+ rozšíření .

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

function.json – vlastnost	Popis
type	Musí být nastavena na `cosmosDB`hodnotu .
direction	Musí být nastavena na `in`hodnotu .
Jméno	Název proměnné použitý v kódu funkce, který představuje seznam dokumentů se změnami.
Připojení	Název nastavení aplikace nebo kontejneru nastavení, který určuje, jak se připojit k monitorovanému účtu služby Azure Cosmos DB. Další informace najdete v tématu Připojení iony.
Databasename	Název databáze Azure Cosmos DB s monitorovaným kontejnerem.
containerName	Název monitorovaného kontejneru.
partitionKey	Určuje hodnotu klíče oddílu pro vyhledávání. Může obsahovat parametry vazby. Vyžaduje se pro vyhledávání v dělených kontejnerech.
id	ID dokumentu, který se má načíst. Tato vlastnost podporuje vazbové výrazy. Nenastavujte obě vlastnosti `id` i `sqlQuery` vlastnosti. Pokud ani jeden nenastavíte, načte se celý kontejner.
sqlQuery	Dotaz SQL služby Azure Cosmos DB, který se používá k načítání více dokumentů. Vlastnost podporuje vazby modulu runtime, jako v tomto příkladu: `SELECT * FROM c where c.departmentId = {departmentId}`. Nenastavujte obě vlastnosti `id` i `sqlQuery` vlastnosti. Pokud ani jeden nenastavíte, načte se celý kontejner.
preferredLocations	(Volitelné) Definuje upřednostňovaná umístění (oblasti) pro geograficky replikované databázové účty ve službě Azure Cosmos DB. Hodnoty by měly být oddělené čárkami. Například `East US,South Central US,North Europe`.

Tato část obsahuje následující příklady:

Trigger fronty, vyhledání ID z řetězce
Trigger fronty, získání více dokumentů pomocí SqlQuery
Trigger HTTP, vyhledání ID z řetězce dotazu
Trigger HTTP, vyhledání ID ze směrovacích dat
Trigger HTTP, získání více dokumentů pomocí SqlQuery
Trigger HTTP, získání více dokumentů pomocí DocumentClient

Příklady triggeru HTTP odkazují na jednoduchý ToDoItem typ:

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

Trigger fronty, vyhledání ID z řetězce

Následující příklad ukazuje vstupní vazbu Azure Cosmos DB v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce čte jeden dokument a aktualizuje textovou hodnotu dokumentu.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger fronty, získání více dokumentů pomocí SqlQuery

Následující příklad ukazuje vstupní vazbu Azure Cosmos DB v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce načte více dokumentů určených dotazem SQL pomocí triggeru fronty k přizpůsobení parametrů dotazu.

Trigger fronty poskytuje parametr departmentId. Zpráva fronty { "departmentId" : "Finance" } by vrátila všechny záznamy pro finanční oddělení.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, vyhledání ID z řetězce dotazu

Následující příklad ukazuje funkci skriptu jazyka C#, která načte jeden dokument. Funkce se aktivuje požadavkem HTTP, který pomocí řetězce dotazu určí ID a hodnotu klíče oddílu, které se mají vyhledat. Toto ID a hodnota klíče oddílu ToDoItem slouží k načtení dokumentu ze zadané databáze a kolekce.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, vyhledání ID ze směrovacích dat

Následující příklad ukazuje funkci skriptu jazyka C#, která načte jeden dokument. Funkce se aktivuje požadavkem HTTP, který používá směrovací data k určení ID a hodnoty klíče oddílu, které se mají vyhledat. Toto ID a hodnota klíče oddílu ToDoItem slouží k načtení dokumentu ze zadané databáze a kolekce.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, získání více dokumentů pomocí SqlQuery

Následující příklad ukazuje funkci skriptu jazyka C#, která načte seznam dokumentů. Funkce se aktivuje požadavkem HTTP. Dotaz je zadán ve vlastnosti atributu SqlQuery .

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, získání více dokumentů pomocí DocumentClient

Následující příklad ukazuje funkci skriptu jazyka C#, která načte seznam dokumentů. Funkce se aktivuje požadavkem HTTP. Kód používá instanci poskytovanou DocumentClient vazbou azure Cosmos DB ke čtení seznamu dokumentů. Instanci DocumentClient lze také použít pro operace zápisu.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Výstup služby Azure Cosmos DB v2

Tato část popisuje podporu pouze pro verzi 4.x+ rozšíření .

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

function.json – vlastnost	Popis
Připojení	Název nastavení aplikace nebo kolekce nastavení, která určuje, jak se připojit k monitorovanému účtu služby Azure Cosmos DB. Další informace najdete v tématu Připojení iony.
Databasename	Název databáze Azure Cosmos DB s monitorovaným kontejnerem.
containerName	Název monitorovaného kontejneru.
createIfNotExists	Logická hodnota označující, jestli se kontejner vytvoří, když neexistuje. Výchozí hodnota je false , protože se vytvoří nové kontejnery s rezervovanou propustností, což má vliv na náklady. Další informace naleznete v části Stránka s cenami.
partitionKey	Pokud `createIfNotExists` je hodnota true, definuje cestu klíče oddílu pro vytvořený kontejner. Může obsahovat parametry vazby.
containerThroughput	Pokud `createIfNotExists` je hodnota true, definuje propustnost vytvořeného kontejneru.
preferredLocations	(Volitelné) Definuje upřednostňovaná umístění (oblasti) pro geograficky replikované databázové účty ve službě Azure Cosmos DB. Hodnoty by měly být oddělené čárkami. Například `East US,South Central US,North Europe`.

Tato část obsahuje následující příklady:

Trigger fronty, napsání jednoho dokumentu
Trigger fronty, zápis dokumentů pomocí IAsyncCollectoru

Trigger fronty, napsání jednoho dokumentu

Následující příklad ukazuje výstupní vazbu Azure Cosmos DB v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce používá vstupní vazbu fronty pro frontu, která přijímá JSON v následujícím formátu:

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

Funkce pro každý záznam vytvoří dokumenty Azure Cosmos DB v následujícím formátu:

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

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger fronty, zápis dokumentů pomocí IAsyncCollectoru

Pokud chcete vytvořit více dokumentů, můžete vytvořit vazbu s ICollector<T> jedním z podporovaných typů nebo IAsyncCollector<T> tam, kde T je jeden z podporovaných typů.

Tento příklad odkazuje na jednoduchý ToDoItem typ:

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

Tady je soubor function.json:

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

Tady je kód skriptu jazyka C#:

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

Trigger služby Azure Cosmos DB v1

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Vstup služby Azure Cosmos DB v1

Tato část obsahuje následující příklady:

Trigger fronty, vyhledání ID z řetězce
Trigger fronty, získání více dokumentů pomocí SqlQuery
Trigger HTTP, vyhledání ID z řetězce dotazu
Trigger HTTP, vyhledání ID ze směrovacích dat
Trigger HTTP, získání více dokumentů pomocí SqlQuery
Trigger HTTP, získání více dokumentů pomocí DocumentClient

Příklady triggeru HTTP odkazují na jednoduchý ToDoItem typ:

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

Trigger fronty, vyhledání ID z řetězce

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger fronty, získání více dokumentů pomocí SqlQuery

Trigger fronty poskytuje parametr departmentId. Zpráva fronty { "departmentId" : "Finance" } by vrátila všechny záznamy pro finanční oddělení.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, vyhledání ID z řetězce dotazu

Následující příklad ukazuje funkci skriptu jazyka C#, která načte jeden dokument. Funkce je aktivována požadavkem HTTP, který používá řetězec dotazu k určení ID, které se má vyhledat. Toto ID se používá k načtení ToDoItem dokumentu ze zadané databáze a kolekce.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, vyhledání ID ze směrovacích dat

Následující příklad ukazuje funkci skriptu jazyka C#, která načte jeden dokument. Funkce se aktivuje požadavkem HTTP, který pomocí směrovacích dat určí ID, které se má vyhledat. Toto ID se používá k načtení ToDoItem dokumentu ze zadané databáze a kolekce.

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, získání více dokumentů pomocí SqlQuery

Následující příklad ukazuje funkci skriptu jazyka C#, která načte seznam dokumentů. Funkce se aktivuje požadavkem HTTP. Dotaz je zadán ve vlastnosti atributu SqlQuery .

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, získání více dokumentů pomocí DocumentClient

Tady je soubor function.json :

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

Tady je kód skriptu jazyka C#:

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

Výstup služby Azure Cosmos DB v1

Tato část obsahuje následující příklady:

Trigger fronty, napsání jednoho dokumentu
Trigger fronty, zápis dokumentů pomocí IAsyncCollector

Trigger fronty, napsání jednoho dokumentu

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

Funkce pro každý záznam vytvoří dokumenty Azure Cosmos DB v následujícím formátu:

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

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger fronty, zápis dokumentů pomocí IAsyncCollectoru

Pokud chcete vytvořit více dokumentů, můžete vytvořit vazbu s ICollector<T> jedním z podporovaných typů nebo IAsyncCollector<T> tam, kde T je jeden z podporovaných typů.

Tento příklad odkazuje na jednoduchý ToDoItem typ:

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

Tady je soubor function.json:

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

Tady je kód skriptu jazyka C#:

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

Trigger Azure SQL

Další ukázky triggeru Azure SQL jsou k dispozici v úložišti GitHub.

Příklad odkazuje na ToDoItem třídu a odpovídající tabulku databáze:

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

Sledování změn je povolené v databázi a v tabulce:

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

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

Aktivační událost SQL se sváže se seznamem IReadOnlyList<SqlChange<T>>SqlChange objektů s dvěma vlastnostmi:

Položka: položka, která byla změněna. Typ položky by měl následovat podle schématu tabulky, jak je vidět ve ToDoItem třídě.
Operace: hodnota z SqlChangeOperation výčtu. Hodnoty pole jsou Insert, Update a Delete.

Následující příklad ukazuje trigger SQL v souboru function.json a funkci skriptu jazyka C#, která se vyvolá při změnách ToDo tabulky:

Následuje vazba dat v souboru function.json:

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

Následuje funkce skriptu jazyka C#:

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

Vstup Azure SQL

Další ukázky vstupní vazby Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

Trigger HTTP, získání řádku podle ID z řetězce dotazu
Trigger HTTP, odstranění řádků

Příklady odkazují na ToDoItem třídu a odpovídající tabulku databáze:

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

Trigger HTTP, získání řádku podle ID z řetězce dotazu

Následující příklad ukazuje vstupní vazbu Azure SQL v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce se aktivuje požadavkem HTTP, který k zadání ID používá řetězec dotazu. Toto ID se používá k načtení záznamu ToDoItem se zadaným dotazem.

Poznámka:

Parametr řetězce dotazu HTTP rozlišují malá a velká písmena.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Trigger HTTP, odstranění řádků

Následující příklad ukazuje vstupní vazbu Azure SQL v souboru function.json a funkci skriptu jazyka C#, která používá vazbu ke spuštění uložené procedury se vstupem z parametru dotazu požadavku HTTP. V tomto příkladu uložená procedura odstraní jeden záznam nebo všechny záznamy v závislosti na hodnotě parametru.

Uložená procedura dbo.DeleteToDo musí být vytvořena v databázi SQL.

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

Tady jsou data vazby v souboru function.json :

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

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

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

Tady je kód skriptu jazyka C#:

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

Výstup Azure SQL

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

Trigger HTTP, zápis záznamů do tabulky
Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na ToDoItem třídu a odpovídající tabulku databáze:

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

Trigger HTTP, zápis záznamů do tabulky

Následující příklad ukazuje výstupní vazbu SQL v souboru function.json a funkci skriptu jazyka C#, která přidává záznamy do tabulky pomocí dat zadaných v požadavku HTTP POST jako tělo JSON.

Následuje vazba dat v souboru function.json:

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

Následuje ukázkový kód skriptu jazyka C#:

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

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu SQL v souboru function.json a funkci skriptu jazyka C#, která přidá záznamy do databáze ve dvou různých tabulkách (dbo.ToDo a dbo.RequestLog) pomocí dat zadaných v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb.

Druhá tabulka, dbo.RequestLogodpovídá následující definici:

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

Následuje vazba dat v souboru function.json:

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

Následuje ukázkový kód skriptu jazyka C#:

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

Výstup RabbitMQ

Následující příklad ukazuje výstupní vazbu RabbitMQ v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce přečte zprávu z triggeru HTTP a vypíše ji do fronty RabbitMQ.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

using System;
using Microsoft.Extensions.Logging;

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

Výstup SendGridu

Následující příklad ukazuje výstupní vazbu SendGrid v souboru function.json a funkci skriptu jazyka C#, která používá vazbu.

Tady jsou data vazby v souboru function.json :

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

Tady je kód skriptu jazyka C#:

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

Aktivační událost SignalR

Tady je příklad vazeb dat v souboru function.json :

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

A tady je 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}.");
}

Vstup SignalR

Následující příklad ukazuje vstupní vazbu informací o připojení SignalR v souboru function.json a funkci skriptu jazyka C#, která používá vazbu k vrácení informací o připojení.

Tady je vazba dat v souboru function.json :

Příklad function.json:

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

Tady je kód skriptu jazyka C#:

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

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

Vlastnost vazby na hodnotu můžete nastavit userId z hlavičky pomocí vazbového výrazu: {headers.x-ms-client-principal-id} nebo {headers.x-ms-client-principal-name}.

Příklad 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"
}

Tady je kód skriptu jazyka C#:

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

Výstup signalR

Tady je vazba dat v souboru function.json :

Příklad function.json:

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

Tady je kód skriptu jazyka C#:

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

Zprávu můžete odeslat pouze na připojení, která byla ověřena uživateli nastavením ID uživatele ve zprávě SignalR.

Příklad function.json:

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

Tady je kód skriptu jazyka C#:

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

Zprávu můžete odeslat pouze do připojení, která byla přidána do skupiny, nastavením názvu skupiny ve zprávě SignalR.

Příklad function.json:

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

Tady je kód skriptu jazyka C#:

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

Služba SignalR umožňuje přidávat uživatele nebo připojení ke skupinám. Zprávy se pak dají odeslat do skupiny. Výstupní vazbu můžete použít SignalR ke správě skupin.

Následující příklad přidá uživatele do skupiny.

Příklad function.json

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

Run.csx

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

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

Následující příklad odebere uživatele ze skupiny.

Příklad function.json

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

Run.csx

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

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

Výstup Twilio

Následující příklad ukazuje výstupní vazbu Twilio v souboru function.json a funkci skriptu jazyka C#, která používá vazbu. Funkce používá out parametr k odeslání textové zprávy.

Tady je vazba dat v souboru function.json :

Příklad function.json:

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

Tady je kód skriptu jazyka C#:

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

Parametry nemůžete použít v asynchronním kódu. Tady je příklad asynchronního kódu skriptu C#:

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

Aktivační událost pro přípravu

Následující příklad ukazuje trigger zahřátí v souboru function.json a funkci skriptu jazyka C#, která se spouští na každé nové instanci, když je přidána do vaší aplikace.

Nepodporuje se pro modul runtime Functions verze 1.x.

Tady je soubor function.json :

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

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

Další kroky

Další informace o triggerech a vazbách

Další informace o osvědčených postupech pro Azure Functions