Udostępnij za pośrednictwem

Dokumentacja dla deweloperów skryptu języka C# usługi Azure Functions (csx)

  • Artykuł

Ten artykuł stanowi wprowadzenie do tworzenia usługi Azure Functions przy użyciu skryptu języka C# (csx).

Ważne

Skrypt języka C# jest obsługiwany głównie w celu zapewnienia wygodnego środowiska w portalu, aby ułatwić szybkie rozpoczęcie tworzenia i uruchamiania funkcji języka C#. W przypadku aplikacji jakości produkcyjnej należy zamiast tego opracowywać funkcje języka C# lokalnie jako skompilowany projekt biblioteki klas języka C#. Aby dowiedzieć się, jak przeprowadzić migrację projektu skryptu języka C# do projektu biblioteki klas języka C# (izolowanego procesu roboczego), zobacz Konwertowanie aplikacji skryptu języka C# na projekt C#.

Usługa Azure Functions umożliwia tworzenie funkcji przy użyciu języka C# na jeden z następujących sposobów:

Typ Proces wykonywania Rozszerzenie kodu Środowisko projektowe Odwołanie
Skrypt języka C# w procesie .csx Portal
Podstawowe narzędzia		 Ten artykuł
Biblioteka klas języka C# (izolowany proces roboczy) izolowany proces roboczy .cs Program Visual Studio
Visual Studio Code
Podstawowe narzędzia		 Funkcje izolowanego procesu roboczego platformy .NET
Biblioteka klas języka C# (w procesie) w procesie .cs Program Visual Studio
Visual Studio Code
Podstawowe narzędzia		 Funkcje biblioteki klas języka C# w procesie

Ważne

Wsparcie zostanie zakończone dla modelu procesu 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu procesu roboczego w celu uzyskania pełnej obsługi.

Jak działa plik csx

Dane przepływają do funkcji języka C# za pośrednictwem argumentów metody. Nazwy argumentów są określone w function.json pliku i istnieją wstępnie zdefiniowane nazwy na potrzeby uzyskiwania dostępu do elementów, takich jak rejestrator funkcji i tokeny anulowania.

Format csx umożliwia pisanie mniej "standardowy" i skupienie się na pisaniu tylko funkcji języka C#. Zamiast zawijać wszystko w przestrzeni nazw i klasie, po prostu zdefiniuj metodę Run . Dołącz wszystkie odwołania do zestawów i przestrzeni nazw na początku pliku, jak zwykle.

Pliki csx aplikacji funkcji są kompilowane po zainicjowaniu wystąpienia. Ten krok kompilacji oznacza, że wykonywanie takich czynności, jak zimny start, może trwać dłużej w przypadku funkcji skryptów języka C# w porównaniu z bibliotekami klas języka C#. Ten krok kompilacji jest również przyczyną edytowania funkcji skryptów języka C# w witrynie Azure Portal, podczas gdy biblioteki klas języka C# nie są.

Struktura folderów

Struktura folderów dla projektu skryptu języka C# wygląda podobnie do następującego przykładu:

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

Istnieje udostępniony plik host.json , który może służyć do konfigurowania aplikacji funkcji. Każda funkcja ma własny plik kodu (csx) i plik konfiguracji powiązania (function.json).

Rozszerzenia powiązań wymagane w wersji 2.x i nowszych wersjach środowiska uruchomieniowego usługi Functions są definiowane w extensions.csproj pliku z rzeczywistymi plikami biblioteki w folderze bin . Podczas tworzenia aplikacji lokalnie należy zarejestrować rozszerzenia powiązań. Podczas opracowywania funkcji w witrynie Azure Portal ta rejestracja jest wykonywana.

Wiązanie z argumentami

Dane wejściowe lub wyjściowe są powiązane z parametrem funkcji skryptu języka C# za pośrednictwem name właściwości w pliku konfiguracji function.json . W poniższym przykładzie przedstawiono plik function.json i plik run.csx dla funkcji wyzwalanej przez kolejkę. Parametr odbierający dane z komunikatu kolejki ma nazwę myQueueItem , ponieważ jest to wartość name właściwości.

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

Instrukcja #r zostanie wyjaśniona w dalszej części tego artykułu.

Obsługiwane typy powiązań

Każde powiązanie ma własne obsługiwane typy; na przykład wyzwalacz obiektu blob może być używany z parametrem ciągu, parametrem POCO, parametrem CloudBlockBlob lub dowolnym z kilku innych obsługiwanych typów. W artykule referencyjnym dotyczącym powiązań obiektów blob wymieniono wszystkie obsługiwane typy parametrów dla wyzwalaczy obiektów blob. Aby uzyskać więcej informacji, zobacz Wyzwalacze i powiązania oraz dokumentację referencyjną powiązań dla każdego typu powiązania.

Napiwek

Jeśli planujesz używać powiązań HTTP lub WebHook, zaplanuj uniknięcie wyczerpania portów HttpClient, które mogą być spowodowane przez niewłaściwe utworzenie wystąpienia elementu . Aby uzyskać więcej informacji, zobacz Jak zarządzać połączeniami w usłudze Azure Functions.

Odwoływanie się do klas niestandardowych

Jeśli musisz użyć niestandardowej niestandardowej klasy zwykłego starego obiektu CLR (POCO), możesz dołączyć definicję klasy do tego samego pliku lub umieścić ją w osobnym pliku.

W poniższym przykładzie przedstawiono przykład run.csx zawierający definicję klasy 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; }
}

Klasa POCO musi mieć element getter i setter zdefiniowany dla każdej właściwości.

Ponowne tworzenie kodu csx

W pliku run.csx można używać klas i metod zdefiniowanych w innych plikach csx. W tym celu użyj #load dyrektyw w pliku run.csx . W poniższym przykładzie rutyna rejestrowania o nazwie MyLogger jest udostępniana w pliku myLogger.csx i ładowana do pliku run.csx przy użyciu #load dyrektywy :

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

Przykład mylogger.csx:

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

Użycie udostępnionego pliku csx jest typowym wzorcem, gdy chcesz silnie wpisywać dane przekazywane między funkcjami przy użyciu obiektu POCO. W poniższym uproszczonym przykładzie wyzwalacz HTTP i wyzwalacz kolejki współużytkuje obiekt POCO o nazwie Order , aby silnie wpisać dane zamówienia:

Przykład run.csx dla wyzwalacza 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);
    }
}

Przykładowy wyzwalacz run.csx dla kolejki:

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

Przykład 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}";
    }
}

Możesz użyć ścieżki względnej z dyrektywą #load :

  • #load "mylogger.csx" ładuje plik znajdujący się w folderze funkcji.
  • #load "loadedfiles\mylogger.csx" ładuje plik znajdujący się w folderze funkcji.
  • #load "..\shared\mylogger.csx" ładuje plik znajdujący się w folderze na tym samym poziomie co folder funkcji, czyli bezpośrednio w folderze wwwroot.

Dyrektywa #load działa tylko z plikami csx , a nie z plikami .cs .

Powiązanie z wartością zwracaną przez metodę

Możesz użyć wartości zwracanej metody dla powiązania wyjściowego, używając nazwy $return w function.json.

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

Oto kod skryptu języka C# używający wartości zwracanej, a następnie przykład asynchroniczny:

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

Użyj wartości zwracanej tylko wtedy, gdy pomyślne wykonanie funkcji zawsze powoduje zwrócenie wartości do przekazania do powiązania wyjściowego. W przeciwnym razie użyj polecenia ICollector lub IAsyncCollector, jak pokazano w poniższej sekcji.

Zapisywanie wielu wartości wyjściowych

Aby zapisać wiele wartości w powiązaniu wyjściowym lub jeśli pomyślne wywołanie funkcji może nie spowodować przekazania niczego do powiązania wyjściowego, użyj ICollector typów lub IAsyncCollector . Te typy to kolekcje tylko do zapisu zapisywane w powiązaniu danych wyjściowych po zakończeniu działania metody.

W tym przykładzie wiele komunikatów kolejki jest zapisywanych w tej samej kolejce przy użyciu polecenia ICollector:

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

Rejestrowanie

Aby rejestrować dane wyjściowe w dziennikach przesyłania strumieniowego w języku C#, dołącz argument typu ILogger. Zalecamy nadanie mu lognazwy . Unikaj używania Console.Write w usłudze Azure Functions.

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

Uwaga

Aby uzyskać informacje na temat nowszej struktury rejestrowania, której można użyć zamiast TraceWriterprogramu , zobacz dokumentację ILogger w przewodniku dewelopera biblioteki klas platformy .NET.

Rejestrowanie metryk niestandardowych

Możesz użyć LogMetric metody rozszerzenia , ILogger aby utworzyć metryki niestandardowe w usłudze Application Insights. Oto przykładowe wywołanie metody:

logger.LogMetric("TestMetric", 1234);

Ten kod jest alternatywą dla wywoływania TrackMetric przy użyciu interfejsu API usługi Application Insights dla platformy .NET.

Async

Aby utworzyć funkcję asynchroniczną, użyj słowa kluczowego async i zwróć Task obiekt.

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

Nie można używać out parametrów w funkcjach asynchronicznych. W przypadku powiązań wyjściowych należy zamiast tego użyć wartości zwracanej funkcji lub obiektu modułu zbierającego.

Tokeny anulowania

Funkcja może akceptować parametr CancellationToken , który umożliwia systemowi operacyjnemu powiadamianie o kodzie po zakończeniu działania funkcji. Możesz użyć tego powiadomienia, aby upewnić się, że funkcja nie zostanie nieoczekiwanie zakończona w sposób, który pozostawia dane w stanie niespójnym.

W poniższym przykładzie pokazano, jak sprawdzić zbliżające się zakończenie funkcji.

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

Importowanie przestrzeni nazw

Jeśli musisz zaimportować przestrzenie nazw, możesz to zrobić jak zwykle z klauzulą using .

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

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

Następujące przestrzenie nazw są importowane automatycznie i dlatego są opcjonalne:

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

Odwoływanie się do zestawów zewnętrznych

W przypadku zestawów struktur dodaj odwołania przy użyciu #r "AssemblyName" dyrektywy .

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

Następujące zestawy są automatycznie dodawane przez środowisko hostingu usługi 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

Następujące zestawy mogą odwoływać się do prostych nazw według wersji środowiska uruchomieniowego:

  • Newtonsoft.Json
  • Microsoft.WindowsAzure.Storage*

*Usunięto w wersji 4.x środowiska uruchomieniowego.

W kodzie zestawy są przywołyzowane jak w poniższym przykładzie:

#r "AssemblyName"

Odwoływanie się do zestawów niestandardowych

Aby odwołać się do zestawu niestandardowego, można użyć zestawu udostępnionego lub zestawu prywatnego:

  • Udostępnione zestawy są współużytkowane we wszystkich funkcjach w aplikacji funkcji. Aby odwołać się do zestawu niestandardowego, przekaż zestaw do folderu o nazwie bin w folderze głównym (wwwroot) aplikacji funkcji.

  • Zestawy prywatne są częścią kontekstu danej funkcji i obsługują ładowanie bezpośrednie różnych wersji. Zestawy prywatne powinny być przekazywane w bin folderze w katalogu funkcji. Odwołaj się do zestawów przy użyciu nazwy pliku, na przykład #r "MyAssembly.dll".

Aby uzyskać informacje na temat przekazywania plików do folderu funkcji, zobacz sekcję dotyczącą zarządzania pakietami.

Obserwowane katalogi

Katalog zawierający plik skryptu funkcji jest automatycznie obserwowany pod kątem zmian w zestawach. Aby obserwować zmiany zestawu w innych katalogach, dodaj je do watchDirectories listy w host.json.

Korzystanie z pakietów NuGet

Sposób dodawania pakietów rozszerzeń powiązań i innych pakietów NuGet do aplikacji funkcji zależy od docelowej wersji środowiska uruchomieniowego usługi Functions.

Domyślnie obsługiwany zestaw pakietów NuGet rozszerzenia usługi Functions jest udostępniany aplikacji funkcji skryptu języka C# przy użyciu pakietów rozszerzeń. Aby dowiedzieć się więcej, zobacz Pakiety rozszerzeń.

Jeśli z jakiegoś powodu nie możesz używać pakietów rozszerzeń w projekcie, możesz również użyć narzędzi Azure Functions Core Tools do instalowania rozszerzeń na podstawie powiązań zdefiniowanych w plikach function.json w aplikacji. W przypadku używania narzędzi Core Tools do rejestrowania rozszerzeń upewnij się, że używasz --csx opcji . Aby dowiedzieć się więcej, zobacz instalowanie rozszerzeń func.

Domyślnie narzędzia Core Tools odczytują pliki function.json i dodaje wymagane pakiety do pliku projektu biblioteki klas extensions.csproj c# w katalogu głównym systemu plików aplikacji funkcji (wwwroot). Ponieważ narzędzia Core Tools używają dotnet.exe, można go użyć do dodania dowolnego odwołania do pakietu NuGet do tego pliku rozszerzeń. Podczas instalacji narzędzia Core Tools kompilują plik extensions.csproj w celu zainstalowania wymaganych bibliotek. Oto przykładowy plik extensions.csproj , który dodaje odwołanie do pliku Microsoft.ProjectOxford.Face w wersji 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>

Uwaga

W przypadku skryptu języka C# (csx) należy ustawić TargetFramework wartość .netstandard2.0 Inne struktury docelowe, takie jak net6.0, nie są obsługiwane.

Aby użyć niestandardowego źródła danych NuGet, określ źródło danych w pliku Nuget.Config w folderze głównym aplikacji funkcji. Aby uzyskać więcej informacji, zobacz Konfigurowanie zachowania narzędzia NuGet.

Jeśli pracujesz nad projektem tylko w portalu, musisz ręcznie utworzyć plik extensions.csproj lub plik Nuget.Config bezpośrednio w witrynie. Aby dowiedzieć się więcej, zobacz Ręczne instalowanie rozszerzeń.

Zmienne środowiskowe

Aby uzyskać zmienną środowiskową lub wartość ustawienia aplikacji, użyj metody System.Environment.GetEnvironmentVariable, jak pokazano w poniższym przykładzie kodu:

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

Zasady ponawiania prób

Funkcje obsługują dwie wbudowane zasady ponawiania prób. Aby uzyskać więcej informacji, zobacz Zasady ponawiania prób.

Oto zasady ponawiania w pliku function.json :

{
    "disabled": false,
    "bindings": [
        {
            ....
        }
    ],
    "retry": {
        "strategy": "fixedDelay",
        "maxRetryCount": 4,
        "delayInterval": "00:00:10"
    }
}
właściwość function.json opis
strategia Użyj witryny fixedDelay.
maxRetryCount Wymagany. Maksymalna dozwolona liczba ponownych prób na wykonanie funkcji. -1 oznacza, aby ponowić próbę na czas nieokreślony.
delayInterval Opóźnienie, które jest używane między ponownych prób. Określ go jako ciąg w formacie HH:mm:ss.

Wiązanie w czasie wykonywania

W języku C# i innych językach platformy .NET można użyć wzorca powiązania imperatywnego, w przeciwieństwie do powiązań deklaratywnych w function.json. Powiązanie imperatywne jest przydatne, gdy parametry powiązania muszą być obliczane w czasie wykonywania, a nie w czasie projektowania. Za pomocą tego wzorca można powiązać obsługiwane powiązania wejściowe i wyjściowe na bieżąco w kodzie funkcji.

Zdefiniuj powiązanie imperatywne w następujący sposób:

  • Nie dołączaj wpisu w function.json dla żądanych powiązań imperatywnych.
  • Przekaż parametr Binder binder wejściowy lub IBinder binder.
  • Użyj następującego wzorca języka C#, aby wykonać powiązanie danych.
using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
{
    ...
}

BindingTypeAttribute to atrybut platformy .NET, który definiuje powiązanie i T jest typem wejściowym lub wyjściowym obsługiwanym przez ten typ powiązania. T nie może być typem parametru out (takim jak out JObject). Na przykład powiązanie wyjściowe tabeli Mobile Apps obsługuje sześć typów danych wyjściowych, ale można użyć tylko funkcji ICollector<T> lub IAsyncCollector<T> .T

Przykład pojedynczego atrybutu

Poniższy przykładowy kod tworzy powiązanie wyjściowe obiektu blob usługi Storage ze ścieżką obiektu blob zdefiniowaną w czasie wykonywania, a następnie zapisuje ciąg w obiekcie 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!!");
    }
}

Obiekt BlobAttribute definiuje powiązanie wejściowe lub wyjściowe obiektu blob usługi Storage, a TextWriter jest obsługiwanym typem powiązania wyjściowego.

Przykład wielu atrybutów

Powyższy przykład pobiera ustawienie aplikacji dla głównego konta magazynu aplikacji funkcji parametry połączenia (czyli AzureWebJobsStorage). Możesz określić niestandardowe ustawienie aplikacji, które ma być używane dla konta magazynu, dodając atrybut StorageAccountAttribute i przekazując tablicę atrybutów do BindAsync<T>()elementu . Użyj parametru Binder , a nie IBinder. Na przykład:

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

W poniższej tabeli wymieniono atrybuty platformy .NET dla każdego typu powiązania i pakiety, w których są zdefiniowane.

Wiązanie Atrybut Dodaj odwołanie
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"
Kolejka magazynu Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Obiekt blob magazynu Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Tabela magazynu Microsoft.Azure.WebJobs.TableAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Twilio Microsoft.Azure.WebJobs.TwilioSmsAttribute #r "Microsoft.Azure.WebJobs.Extensions.Twilio"

Konwertowanie aplikacji skryptu języka C# na projekt w języku C#

Najprostszym sposobem przekonwertowania aplikacji funkcji skryptu języka C# na skompilowany projekt biblioteki klas języka C# jest rozpoczęcie od nowego projektu. Następnie dla każdej funkcji można migrować kod i konfigurację z każdego pliku run.csx i function.json w folderze funkcji do jednego nowego pliku kodu biblioteki klas .cs. Jeśli na przykład masz funkcję skryptu języka C# o nazwie HelloWorld , będziesz mieć dwa pliki: HelloWorld/run.csx i HelloWorld/function.json. W przypadku tej funkcji utworzysz plik kodu o nazwie HelloWorld.cs w nowym projekcie biblioteki klas.

Jeśli używasz skryptów języka C# do edytowania portalu, możesz pobrać zawartość aplikacji na komputer lokalny. Wybierz opcję Zawartość witryny zamiast zawartości i projektu programu Visual Studio. Nie musisz generować projektu i nie dołączać ustawień aplikacji do pobierania. Definiujesz nowe środowisko programistyczne, a to środowisko nie powinno mieć takich samych uprawnień jak środowisko hostowanej aplikacji.

Te instrukcje pokazują, jak przekonwertować funkcje skryptów języka C# (które są uruchamiane w procesie z hostem usługi Functions) do funkcji biblioteki klas języka C#, które są uruchamiane w izolowanym procesie roboczym.

  1. Ukończ sekcję Tworzenie projektu aplikacji funkcji w preferowanym przewodniku Szybki start:

  1. Jeśli oryginalny kod skryptu języka C# zawiera extensions.csproj plik lub dowolne function.proj pliki, skopiuj odwołania do pakietu z tego pliku i dodaj je do pliku nowego projektu .csproj w taki sam sposób ItemGroup , jak zależności podstawowe usługi Functions.

    Napiwek

    Konwersja zapewnia dobrą okazję do aktualizacji do najnowszych wersji zależności. Może to wymagać dodatkowych zmian kodu w późniejszym kroku.

  2. Skopiuj zawartość oryginalnego host.json pliku do pliku nowego projektu host.json , z wyjątkiem extensionBundles sekcji (skompilowane projekty języka C# nie używają pakietów rozszerzeń i musisz jawnie dodać odwołania do wszystkich rozszerzeń używanych przez funkcje). Podczas scalania plików host.json należy pamiętać, że host.json schemat jest wersjonowany, a większość aplikacji używa wersji 2.0. Zawartość extensions sekcji może się różnić w zależności od określonych wersji rozszerzeń powiązań używanych przez funkcje. Zapoznaj się z poszczególnymi artykułami referencyjnymi dotyczącymi rozszerzeń, aby dowiedzieć się, jak poprawnie skonfigurować host.json dla określonych wersji.

  3. W przypadku wszystkich udostępnionych plików, do których odwołuje się #load dyrektywa, utwórz nowy .cs plik dla każdego z tych udostępnionych odwołań. Najprostsze jest utworzenie nowego .cs pliku dla każdej udostępnionej definicji klasy. Jeśli istnieją metody statyczne bez klasy, należy zdefiniować nowe klasy dla tych metod.

  4. Wykonaj następujące zadania dla każdego <FUNCTION_NAME> folderu w oryginalnym projekcie:

    1. Utwórz nowy plik o nazwie <FUNCTION_NAME>.cs, zastępując <FUNCTION_NAME> ciąg nazwą folderu, który zdefiniował funkcję skryptu języka C#. Nowy plik kodu funkcji można utworzyć na podstawie jednego z szablonów specyficznych dla wyzwalacza w następujący sposób:

      Przy użyciu polecenia i wybraniu func new --name <FUNCTION_NAME> odpowiedniego szablonu wyzwalacza w wierszu polecenia.

    2. Skopiuj instrukcje using z run.csx pliku i dodaj je do nowego pliku. Nie potrzebujesz żadnych #r dyrektyw.

    3. W przypadku dowolnej #load instrukcji w run.csx pliku dodaj nową using instrukcję dla przestrzeni nazw używanej dla kodu udostępnionego.

    4. W nowym pliku zdefiniuj klasę funkcji w przestrzeni nazw używanej dla projektu.

    5. Utwórz nową metodę o nazwie RunHandler lub podobnej. Ta nowa metoda służy jako nowy punkt wejścia dla funkcji.

    6. Skopiuj metodę statyczną reprezentującą funkcję wraz z dowolnymi funkcjami, które wywołuje, z run.csx nowej klasy jako drugą metodą. Z nowej metody utworzonej w poprzednim kroku wywołaj tę metodę statyczną. Ten krok pośredni jest przydatny do nawigowania po wszelkich różnicach podczas kontynuowania uaktualniania. Oryginalna metoda może być dokładnie taka sama i po prostu kontrolować jej dane wejściowe z nowego kontekstu. Może być konieczne utworzenie parametrów dla nowej metody, która następnie zostanie przekazana do wywołania metody statycznej. Po potwierdzeniu, że migracja działała zgodnie z oczekiwaniami, możesz usunąć ten dodatkowy poziom pośredni.

    7. Dla każdego powiązania w function.json pliku dodaj odpowiedni atrybut do nowej metody. Aby szybko znaleźć przykłady powiązań, zobacz Ręczne dodawanie powiązań na podstawie przykładów.

    8. Dodaj wszystkie pakiety rozszerzeń wymagane przez powiązania do projektu, jeśli jeszcze tego nie zrobiono.

  5. Utwórz ponownie wszystkie ustawienia aplikacji wymagane przez aplikację w Values kolekcji pliku local.settings.json.

  6. Sprawdź, czy projekt działa lokalnie:

    Użyj func start polecenia , aby uruchomić aplikację z poziomu wiersza polecenia. Aby uzyskać więcej informacji, zobacz Uruchamianie funkcji lokalnie.

  7. Opublikuj projekt w nowej aplikacji funkcji na platformie Azure:

    Utwórz zasoby platformy Azure i wdróż projekt kodu na platformie Azure przy użyciu func azure functionapp publish <APP_NAME> polecenia . Aby uzyskać więcej informacji, zobacz Wdrażanie plików projektu.

Przykładowa konwersja funkcji

W tej sekcji przedstawiono przykład migracji dla pojedynczej funkcji.

Oryginalna funkcja skryptów w języku C# ma dwa pliki:

  • HelloWorld/function.json
  • HelloWorld/run.csx

Zawartość elementu HelloWorld/function.json to:

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

Zawartość elementu HelloWorld/run.csx to:

#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 przeprowadzeniu migracji do izolowanego modelu roboczego z integracją ASP.NET Core są one zastępowane jednym elementem 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);
        }
    }
}

Konfiguracja powiązania i przykłady

Ta sekcja zawiera odwołania i przykłady służące do definiowania wyzwalaczy i powiązań w skry skry skryptie języka C#.

Wyzwalacz obiektu blob

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość blobTrigger. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Musi być ustawiona wartość in. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej obiekt blob w kodzie funkcji.
path Kontener do monitorowania. Może to być wzorzec nazwy obiektu blob.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z obiektami blob platformy Azure. Zobacz Połączenia.

W poniższym przykładzie przedstawiono definicję wyzwalacza obiektu blob w pliku function.json i kodzie, który używa powiązania. Funkcja zapisuje dziennik po dodaniu lub zaktualizowaniu obiektu blob w kontenerze samples-workitems .

Oto dane powiązania w pliku function.json :

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

Ciąg {name} w ścieżce samples-workitems/{name} wyzwalacza obiektu blob tworzy wyrażenie powiązania, którego można użyć w kodzie funkcji w celu uzyskania dostępu do nazwy pliku wyzwalającego obiektu blob. Aby uzyskać więcej informacji, zobacz Wzorce nazw obiektów blob.

Oto kod skryptu języka C#, który jest powiązany z elementem 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");
}

Oto kod skryptu języka C#, który jest powiązany z elementem 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}");
}

Dane wejściowe obiektu blob

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość blob.
direction Musi być ustawiona wartość in.
name Nazwa zmiennej reprezentującej obiekt blob w kodzie funkcji.
path Ścieżka do obiektu blob.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z obiektami blob platformy Azure. Zobacz Połączenia.

W poniższym przykładzie przedstawiono powiązania wejściowe i wyjściowe obiektu blob w pliku function.json i kodzie skryptu języka C#, który używa powiązań. Funkcja tworzy kopię obiektu blob tekstowego. Funkcja jest wyzwalana przez komunikat kolejki zawierający nazwę obiektu blob do skopiowania. Nowy obiekt blob nosi nazwę {originalblobname}-Copy.

W pliku queueTrigger function.json właściwość metadata służy do określania nazwy obiektu blob we właściwościachpath:

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

Oto kod skryptu języka C#:

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

Dane wyjściowe obiektu blob

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość blob.
direction Musi być ustawiona wartość out.
name Nazwa zmiennej reprezentującej obiekt blob w kodzie funkcji.
path Ścieżka do obiektu blob.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z obiektami blob platformy Azure. Zobacz Połączenia.

W poniższym przykładzie przedstawiono powiązania wejściowe i wyjściowe obiektu blob w pliku function.json i kodzie skryptu języka C#, który używa powiązań. Funkcja tworzy kopię obiektu blob tekstowego. Funkcja jest wyzwalana przez komunikat kolejki zawierający nazwę obiektu blob do skopiowania. Nowy obiekt blob nosi nazwę {originalblobname}-Copy.

W pliku queueTrigger function.json właściwość metadata służy do określania nazwy obiektu blob we właściwościachpath:

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

Oto kod skryptu języka C#:

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

Wyzwalacz RabbitMQ

W poniższym przykładzie pokazano powiązanie wyzwalacza RabbitMQ w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja odczytuje i rejestruje komunikat RabbitMQ.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka C#:

using System;

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

Wyzwalacz kolejki

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość queueTrigger. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Tylko w pliku function.json. Musi być ustawiona wartość in. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej zawierającej ładunek elementu kolejki w kodzie funkcji.
queueName Nazwa kolejki do sondowania.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z kolejkami platformy Azure. Zobacz Połączenia.

W poniższym przykładzie pokazano powiązanie wyzwalacza kolejki w pliku function.json i kodzie skryptu języka C#, który używa powiązania. Funkcja sonduje kolejkę myqueue-items i zapisuje dziennik za każdym razem, gdy element kolejki jest przetwarzany.

Oto plik function.json:

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

Oto kod skryptu języka 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}");
}

Dane wyjściowe kolejki

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość queue. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Musi być ustawiona wartość out. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej kolejkę w kodzie funkcji. Ustaw wartość na , aby $return odwoływać się do wartości zwracanej przez funkcję.
queueName Nazwa kolejki.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z kolejkami platformy Azure. Zobacz Połączenia.

W poniższym przykładzie pokazano powiązanie wyzwalacza HTTP w pliku function.json i kodzie skryptu języka C#, który używa powiązania. Funkcja tworzy element kolejki z ładunkiem obiektu CustomQueueMessage dla każdego odebranego żądania HTTP.

Oto plik 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"
    }
  ]
}

Oto kod skryptu języka C#, który tworzy pojedynczy komunikat kolejki:

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

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

Jednocześnie można wysyłać wiele komunikatów przy użyciu parametru ICollector lub IAsyncCollector . Oto kod skryptu języka C#, który wysyła wiele komunikatów, jeden z danymi żądania HTTP i jeden z zakodowanymi wartościami:

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

Dane wejściowe tabeli

W tej sekcji opisano obsługę tylko wersji interfejsu API tabel rozszerzenia .

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość table. Ta właściwość jest ustawiana automatycznie podczas tworzenia powiązania w witrynie Azure Portal.
direction Musi być ustawiona wartość in. Ta właściwość jest ustawiana automatycznie podczas tworzenia powiązania w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej tabelę lub jednostkę w kodzie funkcji.
tableName Nazwa tabeli.
partitionKey Opcjonalny. Klucz partycji jednostki tabeli do odczytania.
rowKey Opcjonalny. Klucz wiersza jednostki tabeli do odczytania. Nie można używać z take programem lub filter.
brać Opcjonalny. Maksymalna liczba jednostek do zwrócenia. Nie można używać z rowKeyprogramem .
filter Opcjonalny. Wyrażenie filtru OData dla jednostek, które mają być zwracane z tabeli. Nie można używać z rowKeyprogramem .
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z usługą tabel. Zobacz Połączenia.

W poniższym przykładzie pokazano powiązanie wejściowe tabeli w pliku function.json i kod skryptu języka C#, który używa powiązania. Funkcja używa wyzwalacza kolejki do odczytywania pojedynczego wiersza tabeli.

Plik function.json określa element partitionKey i rowKey. Wartość rowKey {queueTrigger} wskazuje, że klucz wiersza pochodzi z ciągu komunikatu kolejki.

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

Oto kod skryptu języka 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; }
}

Dane wyjściowe tabeli

W tej sekcji opisano obsługę tylko wersji interfejsu API tabel rozszerzenia .

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość table. Ta właściwość jest ustawiana automatycznie podczas tworzenia powiązania w witrynie Azure Portal.
direction Musi być ustawiona wartość out. Ta właściwość jest ustawiana automatycznie podczas tworzenia powiązania w witrynie Azure Portal.
name Nazwa zmiennej używana w kodzie funkcji, która reprezentuje tabelę lub jednostkę. Ustaw wartość na , aby $return odwoływać się do wartości zwracanej przez funkcję.
tableName Nazwa tabeli, do której ma być zapisywany.
partitionKey Klucz partycji jednostki tabeli do zapisu.
rowKey Klucz wiersza jednostki tabeli do zapisu.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z usługą tabel. Zobacz Połączenia.

W poniższym przykładzie pokazano powiązanie wyjściowe tabeli w pliku function.json i kodzie skryptu języka C#, który używa powiązania. Funkcja zapisuje wiele jednostek tabeli.

Oto plik function.json:

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

Oto kod skryptu języka 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; }
}

Wyzwalacz czasomierza

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość timerTrigger. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Musi być ustawiona wartość in. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej obiekt czasomierza w kodzie funkcji.
schedule Wyrażenie CRON lub wartość TimeSpan. Element TimeSpan może być używany tylko dla aplikacji funkcji działającej w planie usługi App Service. Możesz umieścić wyrażenie harmonogramu w ustawieniu aplikacji i ustawić tę właściwość na nazwę ustawienia aplikacji opakowaną w % znaki, jak w tym przykładzie: "%ScheduleAppSetting%".
runOnStartup Jeśli truefunkcja jest wywoływana po uruchomieniu środowiska uruchomieniowego. Na przykład środowisko uruchomieniowe jest uruchamiane, gdy aplikacja funkcji wznawia się po przejściu w stan bezczynności z powodu braku aktywności. gdy aplikacja funkcji zostanie uruchomiona ponownie z powodu zmian funkcji i gdy aplikacja funkcji zostanie skalowana w poziomie. Należy zachować ostrożność. parametr runOnStartup powinien rzadko być ustawiony na truewartość , szczególnie w środowisku produkcyjnym.
useMonitor Ustaw na wartość true lub false, aby wskazać, czy harmonogram powinien być monitorowany. Monitorowanie harmonogramu utrwala wystąpienia harmonogramu, aby pomóc w zapewnieniu prawidłowej konserwacji harmonogramu nawet po ponownym uruchomieniu wystąpień aplikacji funkcji. Jeśli nie ustawiono jawnie, wartością domyślną jest true harmonogramy z interwałem cyklu większym lub równym 1 minucie. W przypadku harmonogramów wyzwalających więcej niż raz na minutę wartość domyślna to false.

W poniższym przykładzie pokazano powiązanie wyzwalacza czasomierza w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja zapisuje dziennik wskazujący, czy wywołanie tej funkcji jest spowodowane nieodebranym wystąpieniem harmonogramu. Obiekt TimerInfo jest przekazywany do funkcji.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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}" );  
}

Wyzwalacz HTTP

W poniższej tabeli opisano właściwości konfiguracji wyzwalacza ustawione w pliku function.json :

właściwość function.json opis
type Wymagane — musi być ustawiona na httpTriggerwartość .
direction Wymagane — musi być ustawiona na inwartość .
name Wymagane — nazwa zmiennej używana w kodzie funkcji dla treści żądania lub żądania.
authLevel Określa, jakie klucze, jeśli istnieją, muszą być obecne w żądaniu, aby wywołać funkcję. Aby uzyskać obsługiwane wartości, zobacz Poziom autoryzacji.
Metody Tablica metod HTTP, na które odpowiada funkcja. Jeśli nie zostanie określony, funkcja odpowiada na wszystkie metody HTTP. Zobacz Dostosowywanie punktu końcowego HTTP.
trasa Definiuje szablon trasy, kontrolując, na które adresy URL żądań odpowiada funkcja. Wartość domyślna, jeśli żadna z nich nie jest podana, to <functionname>. Aby uzyskać więcej informacji, zobacz dostosowywanie punktu końcowego HTTP.
webHookType Obsługiwane tylko w przypadku środowiska uruchomieniowego w wersji 1.x.

Konfiguruje wyzwalacz HTTP, aby działał jako odbiornik elementu webhook dla określonego dostawcy. Aby uzyskać obsługiwane wartości, zobacz Typ elementu webhook.

W poniższym przykładzie pokazano powiązanie wyzwalacza w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja szuka parametru name w ciągu zapytania lub treści żądania HTTP.

Oto plik function.json:

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

Oto kod skryptu języka C#, który jest powiązany z elementem 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");
}

Można powiązać z obiektem niestandardowym zamiast HttpRequest. Ten obiekt jest tworzony na podstawie treści żądania i analizowany jako JSON. Podobnie typ może zostać przekazany do powiązania wyjściowego odpowiedzi HTTP i zwrócony jako treść odpowiedzi wraz z 200 kodem stanu.

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

Dane wyjściowe HTTP

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

Właściwości Opis
type Musi być ustawiona wartość http.
direction Musi być ustawiona wartość out.
name Nazwa zmiennej używana w kodzie funkcji dla odpowiedzi lub $return do użycia wartości zwracanej.

Wyzwalacz usługi Event Hubs

W poniższej tabeli opisano właściwości konfiguracji wyzwalacza ustawione w pliku function.json :

właściwość function.json opis
type Musi być ustawiona wartość eventHubTrigger. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Musi być ustawiona wartość in. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej element zdarzenia w kodzie funkcji.
eventHubName Funkcje w wersji 2.x i nowszej. Nazwa centrum zdarzeń. Gdy nazwa centrum zdarzeń jest również obecna w parametry połączenia, ta wartość zastępuje tę właściwość w czasie wykonywania. Można odwoływać się za pomocą ustawień %eventHubName%aplikacji. W wersji 1.x ta właściwość nosi nazwę path.
consumerGroup Opcjonalna właściwość, która ustawia grupę odbiorców używaną do subskrybowania zdarzeń w centrum. W przypadku pominięcia $Default grupa odbiorców jest używana.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z usługą Event Hubs. Zobacz Połączenia.

W poniższym przykładzie pokazano powiązanie wyzwalacza usługi Event Hubs w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja rejestruje treść komunikatu wyzwalacza usługi Event Hubs.

W poniższych przykładach pokazano dane powiązania usługi Event Hubs w pliku function.json dla środowiska uruchomieniowego usługi Functions w wersji 2.x lub nowszej.

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

Oto kod skryptu języka C#:

using System;

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

Aby uzyskać dostęp do metadanych zdarzeń w kodzie funkcji, powiąż z obiektem EventData . Dostęp do tych samych właściwości można również uzyskać przy użyciu wyrażeń powiązań w podpisie metody. W poniższym przykładzie przedstawiono oba sposoby uzyskiwania tych samych danych:

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

Aby odbierać zdarzenia w partii, utwórz string lub EventData tablicę:

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

Dane wyjściowe usługi Event Hubs

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość eventHub.
direction Musi być ustawiona wartość out. Ten parametr jest ustawiany automatycznie podczas tworzenia powiązania w witrynie Azure Portal.
name Nazwa zmiennej używana w kodzie funkcji, która reprezentuje zdarzenie.
eventHubName Funkcje w wersji 2.x i nowszej. Nazwa centrum zdarzeń. Gdy nazwa centrum zdarzeń jest również obecna w parametry połączenia, ta wartość zastępuje tę właściwość w czasie wykonywania. W usłudze Functions 1.x ta właściwość nosi nazwę path.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z usługą Event Hubs. Aby dowiedzieć się więcej, zobacz Połączenia.

W poniższym przykładzie pokazano powiązanie wyzwalacza centrum zdarzeń w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja zapisuje komunikat w centrum zdarzeń.

W poniższych przykładach pokazano dane powiązania usługi Event Hubs w pliku function.json dla środowiska uruchomieniowego usługi Functions w wersji 2.x lub nowszej.

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

Oto kod skryptu języka C#, który tworzy jeden komunikat:

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

Oto kod skryptu języka C#, który tworzy wiele komunikatów:

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

Wyzwalacz usługi Event Grid

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json . Brak parametrów konstruktora ani właściwości do ustawienia w atrybucie EventGridTrigger .

właściwość function.json opis
type Wymagane — musi być ustawiona na eventGridTriggerwartość .
direction Wymagane — musi być ustawiona na inwartość .
name Required — nazwa zmiennej używana w kodzie funkcji dla parametru, który odbiera dane zdarzenia.

Poniższy przykład przedstawia wyzwalacz usługi Event Grid zdefiniowany w pliku function.json .

Oto dane powiązania w pliku function.json :

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

Oto przykład funkcji skryptu języka C#, która używa parametru EventGridEvent powiązania:

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

Oto przykład funkcji skryptu języka C#, która używa parametru JObject powiązania:

#r "Newtonsoft.Json"

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

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

Dane wyjściowe usługi Event Grid

W poniższej tabeli opisano właściwości konfiguracji powiązania dla skryptu języka C#, który został ustawiony w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość eventGrid.
direction Musi być ustawiona wartość out. Ten parametr jest ustawiany automatycznie podczas tworzenia powiązania w witrynie Azure Portal.
name Nazwa zmiennej używana w kodzie funkcji, która reprezentuje zdarzenie.
topicEndpointUri Nazwa ustawienia aplikacji zawierającego identyfikator URI tematu niestandardowego, na przykład MyTopicEndpointUri.
topicKeySetting Nazwa ustawienia aplikacji zawierającego klucz dostępu dla tematu niestandardowego.

W poniższym przykładzie przedstawiono dane powiązania wyjściowego usługi Event Grid w pliku function.json .

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

Oto kod skryptu języka C#, który tworzy jedno zdarzenie:

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

Oto kod skryptu języka C#, który tworzy wiele zdarzeń:

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

Wyzwalacz usługi Service Bus

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość serviceBusTrigger. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Musi być ustawiona wartość in. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej komunikat kolejki lub tematu w kodzie funkcji.
queueName Nazwa kolejki do monitorowania. Ustaw tylko wtedy, gdy monitorowanie kolejki, a nie tematu.
nazwa tematu Nazwa tematu do monitorowania. Ustaw tylko wtedy, gdy monitorowanie tematu, a nie dla kolejki.
subscriptionName Nazwa subskrypcji do monitorowania. Ustaw tylko wtedy, gdy monitorowanie tematu, a nie dla kolejki.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z usługą Service Bus. Zobacz Połączenia.
accessRights Prawa dostępu do parametry połączenia. Dostępne wartości to manage i listen. Wartość domyślna to manage, która wskazuje, że connection właściwość ma uprawnienie Zarządzaj . Jeśli używasz parametry połączenia, który nie ma uprawnienia Zarządzanie, ustaw wartość accessRights "nasłuchiwanie". W przeciwnym razie środowisko uruchomieniowe usługi Functions może nie próbować wykonywać operacji wymagających praw zarządzania. W usłudze Azure Functions w wersji 2.x lub nowszej ta właściwość nie jest dostępna, ponieważ najnowsza wersja zestawu SDK usługi Service Bus nie obsługuje operacji zarządzania.
isSessionsEnabled truew przypadku nawiązywania połączenia z kolejką lub subskrypcją z obsługą sesji. false w przeciwnym razie jest to wartość domyślna.
autouzupełnianie true gdy wyzwalacz powinien zostać automatycznie wywołany po zakończeniu przetwarzania lub jeśli kod funkcji zostanie ręcznie wywołany.

Ustawienie na false jest obsługiwane tylko w języku C#.

Jeśli ustawiono truewartość , wyzwalacz zakończy komunikat automatycznie, jeśli wykonanie funkcji zakończy się pomyślnie i porzuci komunikat w przeciwnym razie.
<br/Po ustawieniu falsewartości użytkownik jest odpowiedzialny za wywoływanie metod ServiceBusReceiver w celu ukończenia, porzucenia lub zakleszczenia komunikatu, sesji lub partii. Gdy zgłaszany jest wyjątek (i żadna z ServiceBusReceiver metod nie jest wywoływana), blokada pozostaje zachowana. Po wygaśnięciu blokady komunikat zostanie ponownie dodany do kolejki ze wzrostem DeliveryCount , a blokada zostanie automatycznie odnowiona.

Ta właściwość jest dostępna tylko w usłudze Azure Functions 2.x i nowszych.

W poniższym przykładzie pokazano powiązanie wyzwalacza usługi Service Bus w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja odczytuje metadane komunikatów i rejestruje komunikat kolejki usługi Service Bus.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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}");
}

Dane wyjściowe usługi Service Bus

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość serviceBus. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
direction Musi być ustawiona wartość out. Ta właściwość jest ustawiana automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej reprezentującej komunikat kolejki lub tematu w kodzie funkcji. Ustaw wartość "$return", aby odwołać się do wartości zwracanej przez funkcję.
queueName Nazwa kolejki. Ustaw tylko w przypadku wysyłania komunikatów w kolejce, a nie tematu.
nazwa tematu Nazwa tematu. Ustaw tylko w przypadku wysyłania komunikatów tematu, a nie dla kolejki.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z usługą Service Bus. Zobacz Połączenia.
accessRights (tylko wersja 1) Prawa dostępu do parametry połączenia. Dostępne wartości to manage i listen. Wartość domyślna to manage, która wskazuje, że connection właściwość ma uprawnienie Zarządzaj . Jeśli używasz parametry połączenia, który nie ma uprawnienia Zarządzanie, ustaw wartość accessRights "nasłuchiwanie". W przeciwnym razie środowisko uruchomieniowe usługi Functions może nie próbować wykonywać operacji wymagających praw zarządzania. W usłudze Azure Functions w wersji 2.x lub nowszej ta właściwość nie jest dostępna, ponieważ najnowsza wersja zestawu SDK usługi Service Bus nie obsługuje operacji zarządzania.

Poniższy przykład przedstawia powiązanie wyjściowe usługi Service Bus w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja używa wyzwalacza czasomierza do wysyłania komunikatu kolejki co 15 sekund.

Oto dane powiązania w pliku 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
}

Oto kod skryptu języka C#, który tworzy pojedynczy komunikat:

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

Oto kod skryptu języka C#, który tworzy wiele komunikatów:

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

Wyzwalacz usługi Azure Cosmos DB w wersji 2

W tej sekcji opisano obsługę tylko wersji 4.x+ rozszerzenia .

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość cosmosDBTrigger.
direction Musi być ustawiona wartość in. Ten parametr jest ustawiany automatycznie podczas tworzenia wyzwalacza w witrynie Azure Portal.
name Nazwa zmiennej używana w kodzie funkcji, która reprezentuje listę dokumentów ze zmianami.
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z monitorowanym kontem usługi Azure Cosmos DB. Aby uzyskać więcej informacji, zobacz Połączenia.
databaseName Nazwa bazy danych usługi Azure Cosmos DB z monitorowanym kontenerem.
containerName Nazwa monitorowanego kontenera.
leaseConnection (Opcjonalnie) Nazwa ustawienia aplikacji lub kontenera ustawień, który określa sposób nawiązywania połączenia z kontem usługi Azure Cosmos DB, które przechowuje kontener dzierżawy.

Jeśli nie zostanie ustawiona, zostanie użyta connection wartość. Ten parametr jest ustawiany automatycznie podczas tworzenia powiązania w portalu. Parametry połączenia kontenera dzierżaw musi mieć uprawnienia do zapisu.
leaseDatabaseName (Opcjonalnie) Nazwa bazy danych, która przechowuje kontener używany do przechowywania dzierżaw. Jeśli nie zostanie ustawiona, zostanie użyta wartość databaseName ustawienia.
leaseContainerName (Opcjonalnie) Nazwa kontenera używanego do przechowywania dzierżaw. Jeśli nie zostanie ustawiona, zostanie użyta wartość leases .
createLeaseContainerIfNotExists (Opcjonalnie) Po ustawieniu truewartości parametru kontener dzierżaw jest tworzony automatycznie, gdy jeszcze nie istnieje. Domyślna wartość to false. W przypadku korzystania z tożsamości entra firmy Microsoft, jeśli ustawisz wartość truena , tworzenie kontenerów nie jest dozwoloną operacją , a funkcja nie będzie mogła uruchomić.
leasesContainerThroughput (Opcjonalnie) Definiuje liczbę jednostek żądań do przypisania podczas tworzenia kontenera dzierżaw. To ustawienie jest używane tylko wtedy, gdy createLeaseContainerIfNotExists jest ustawione na true. Ten parametr jest ustawiany automatycznie podczas tworzenia powiązania przy użyciu portalu.
leaseContainerPrefix (Opcjonalnie) Po ustawieniu wartość jest dodawana jako prefiks do dzierżaw utworzonych w kontenerze Dzierżawa dla tej funkcji. Użycie prefiksu umożliwia dwóm oddzielnym usłudze Azure Functions współużytkowania tego samego kontenera dzierżawy przy użyciu różnych prefiksów.
feedPollDelay (Opcjonalnie) Czas (w milisekundach) dla opóźnienia między sondowaniem partycji pod kątem nowych zmian w kanale informacyjnym, po opróżnieniu wszystkich bieżących zmian. Wartość domyślna to 5000 milisekund lub 5 sekund.
leaseAcquireInterval (Opcjonalnie) Po ustawieniu definiuje, w milisekundach, interwał uruchamiania zadania obliczeniowego, jeśli partycje są równomiernie dystrybuowane między znane wystąpienia hosta. Wartość domyślna to 13000 (13 sekund).
leaseExpirationInterval (Opcjonalnie) Po ustawieniu definiuje, w milisekundach, interwał, dla którego dzierżawa jest wykonywana w dzierżawie reprezentującej partycję. Jeśli dzierżawa nie zostanie odnowiona w tym interwale, spowoduje to wygaśnięcie, a własność partycji zostanie przeniesiona do innego wystąpienia. Wartość domyślna to 60000 (60 sekund).
leaseRenewInterval (Opcjonalnie) Po ustawieniu definiuje, w milisekundach, interwał odnawiania dla wszystkich dzierżaw dla partycji, które są obecnie przechowywane przez wystąpienie. Wartość domyślna to 17000 (17 sekund).
maxItemsPerInvocation (Opcjonalnie) Po ustawieniu ta właściwość ustawia maksymalną liczbę odebranych elementów na wywołanie funkcji. Jeśli operacje w monitorowanym kontenerze są wykonywane za pomocą procedur składowanych, zakres transakcji jest zachowywany podczas odczytywania elementów ze źródła zmian. W związku z tym liczba odebranych elementów może być większa niż określona wartość, aby elementy zmienione przez tę samą transakcję zostały zwrócone w ramach jednej partii niepodzielnej.
startFromBeginning (Opcjonalnie) Ta opcja nakazuje wyzwalaczowi odczytywanie zmian od początku historii zmian kontenera zamiast rozpoczynania się od bieżącej godziny. Odczyt od początku działa tylko przy pierwszym uruchomieniu wyzwalacza, tak jak w kolejnych uruchomieniach, punkty kontrolne są już przechowywane. Ustawienie tej opcji na true wartość , gdy istnieją już utworzone dzierżawy, nie ma wpływu.
startFromTime (Opcjonalnie) Pobiera lub ustawia datę i godzinę, z której ma być inicjowana operacja odczytu zestawienia zmian. Zalecanym formatem jest ISO 8601 z projektantem UTC, takim jak 2021-02-16T14:19:29Z. Służy to tylko do ustawiania stanu początkowego wyzwalacza. Gdy wyzwalacz ma stan dzierżawy, zmiana tej wartości nie ma wpływu.
preferredLocations (Opcjonalnie) Definiuje preferowane lokalizacje (regiony) dla kont baz danych replikowanych geograficznie w usłudze Azure Cosmos DB. Wartości powinny być rozdzielane przecinkami. Na przykład "Wschodnie stany USA,Południowo-środkowe stany USA,Europa Północna".

W poniższym przykładzie pokazano powiązanie wyzwalacza usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja zapisuje komunikaty dziennika podczas dodawania lub modyfikowania rekordów usługi Azure Cosmos DB.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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);
    }

Dane wejściowe usługi Azure Cosmos DB w wersji 2

W tej sekcji opisano obsługę tylko wersji 4.x+ rozszerzenia .

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Musi być ustawiona wartość cosmosDB.
direction Musi być ustawiona wartość in.
name Nazwa zmiennej używana w kodzie funkcji, która reprezentuje listę dokumentów ze zmianami.
połączenie Nazwa ustawienia aplikacji lub kontenera ustawień, który określa sposób nawiązywania połączenia z monitorowanego konta usługi Azure Cosmos DB. Aby uzyskać więcej informacji, zobacz Połączenia.
databaseName Nazwa bazy danych usługi Azure Cosmos DB z monitorowanym kontenerem.
containerName Nazwa monitorowanego kontenera.
partitionKey Określa wartość klucza partycji dla wyszukiwania. Może zawierać parametry powiązania. Jest to wymagane w przypadku odnośników w kontenerach podzielonych na partycje.
id Identyfikator dokumentu do pobrania. Ta właściwość obsługuje wyrażenia powiązań. Nie ustawiaj id właściwości i sqlQuery . Jeśli nie ustawisz żadnej z nich, zostanie pobrany cały kontener.
sqlQuery Zapytanie SQL usługi Azure Cosmos DB używane do pobierania wielu dokumentów. Właściwość obsługuje powiązania środowiska uruchomieniowego, jak w tym przykładzie: SELECT * FROM c where c.departmentId = {departmentId}. Nie ustawiaj id właściwości i sqlQuery . Jeśli nie ustawisz żadnej z nich, zostanie pobrany cały kontener.
preferredLocations (Opcjonalnie) Definiuje preferowane lokalizacje (regiony) dla kont baz danych replikowanych geograficznie w usłudze Azure Cosmos DB. Wartości powinny być rozdzielane przecinkami. Na przykład East US,South Central US,North Europe.

Ta sekcja zawiera następujące przykłady:

Przykłady wyzwalacza HTTP odnoszą się do prostego ToDoItem typu:

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

Wyzwalacz kolejki, wyszukiwanie identyfikatora z ciągu

Poniższy przykład przedstawia powiązanie wejściowe usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja odczytuje pojedynczy dokument i aktualizuje wartość tekstową dokumentu.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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.";
    }

Wyzwalacz kolejki, uzyskiwanie wielu dokumentów przy użyciu zapytania SqlQuery

Poniższy przykład przedstawia powiązanie wejściowe usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja pobiera wiele dokumentów określonych przez zapytanie SQL przy użyciu wyzwalacza kolejki w celu dostosowania parametrów zapytania.

Wyzwalacz kolejki udostępnia parametr departmentId. Komunikat w kolejce zwraca { "departmentId" : "Finance" } wszystkie rekordy dla działu finansowego.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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; }
    }

Wyzwalacz HTTP, wyszukiwanie identyfikatora z ciągu zapytania

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera pojedynczy dokument. Funkcja jest wyzwalana przez żądanie HTTP, które używa ciągu zapytania do określenia identyfikatora i wartości klucza partycji do wyszukania. Ten identyfikator i wartość klucza partycji są używane do pobierania ToDoItem dokumentu z określonej bazy danych i kolekcji.

Oto plik 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
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, wyszukiwanie identyfikatora z danych trasy

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera pojedynczy dokument. Funkcja jest wyzwalana przez żądanie HTTP, które używa danych trasy do określenia identyfikatora i wartości klucza partycji do wyszukania. Ten identyfikator i wartość klucza partycji są używane do pobierania ToDoItem dokumentu z określonej bazy danych i kolekcji.

Oto plik 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
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, uzyskiwanie wielu dokumentów przy użyciu zapytania SqlQuery

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera listę dokumentów. Funkcja jest wyzwalana przez żądanie HTTP. Zapytanie jest określone we właściwości atrybutu SqlQuery .

Oto plik 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
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, uzyskiwanie wielu dokumentów przy użyciu elementu DocumentClient

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera listę dokumentów. Funkcja jest wyzwalana przez żądanie HTTP. Kod używa wystąpienia dostarczonego DocumentClient przez powiązanie usługi Azure Cosmos DB, aby odczytać listę dokumentów. Wystąpienie DocumentClient może być również używane na potrzeby operacji zapisu.

Oto plik 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
}

Oto kod skryptu języka 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);
}

Dane wyjściowe usługi Azure Cosmos DB w wersji 2

W tej sekcji opisano obsługę tylko wersji 4.x+ rozszerzenia .

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
połączenie Nazwa ustawienia aplikacji lub kolekcji ustawień, która określa sposób nawiązywania połączenia z monitorowanym kontem usługi Azure Cosmos DB. Aby uzyskać więcej informacji, zobacz Połączenia.
databaseName Nazwa bazy danych usługi Azure Cosmos DB z monitorowanym kontenerem.
containerName Nazwa monitorowanego kontenera.
createIfNotExists Wartość logiczna wskazująca, czy kontener jest tworzony, gdy nie istnieje. Wartość domyślna to false , ponieważ nowe kontenery są tworzone z zarezerwowaną przepływnością, co ma wpływ na koszty. Aby uzyskać więcej informacji, zobacz stronę z cennikiem.
partitionKey Jeśli createIfNotExists wartość ma wartość true, definiuje ścieżkę klucza partycji dla utworzonego kontenera. Może zawierać parametry powiązania.
containerThroughput Jeśli createIfNotExists wartość ma wartość true, definiuje przepływność utworzonego kontenera.
preferredLocations (Opcjonalnie) Definiuje preferowane lokalizacje (regiony) dla kont baz danych replikowanych geograficznie w usłudze Azure Cosmos DB. Wartości powinny być rozdzielane przecinkami. Na przykład East US,South Central US,North Europe.

Ta sekcja zawiera następujące przykłady:

Wyzwalacz kolejki, zapis jednego dokumentu

Poniższy przykład przedstawia powiązanie wyjściowe usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja używa powiązania wejściowego kolejki dla kolejki, która odbiera kod JSON w następującym formacie:

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

Funkcja tworzy dokumenty usługi Azure Cosmos DB w następującym formacie dla każdego rekordu:

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

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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
      };
    }

Wyzwalacz kolejki, zapisywanie dokumentów przy użyciu klasy IAsyncCollector

Aby utworzyć wiele dokumentów, możesz powiązać z ICollector<T> elementem lub IAsyncCollector<T> gdzie T jest jednym z obsługiwanych typów.

W tym przykładzie odwołuje się do prostego ToDoItem typu:

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

Oto plik 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
}

Oto kod skryptu języka 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);
    }
}

Wyzwalacz usługi Azure Cosmos DB w wersji 1

W poniższym przykładzie pokazano powiązanie wyzwalacza usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja zapisuje komunikaty dziennika podczas modyfikowania rekordów usługi Azure Cosmos DB.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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);
    }

Dane wejściowe usługi Azure Cosmos DB w wersji 1

Ta sekcja zawiera następujące przykłady:

Przykłady wyzwalacza HTTP odnoszą się do prostego ToDoItem typu:

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

Wyzwalacz kolejki, wyszukiwanie identyfikatora z ciągu

Poniższy przykład przedstawia powiązanie wejściowe usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja odczytuje pojedynczy dokument i aktualizuje wartość tekstową dokumentu.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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.";
    }

Wyzwalacz kolejki, uzyskiwanie wielu dokumentów przy użyciu zapytania SqlQuery

Poniższy przykład przedstawia powiązanie wejściowe usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja pobiera wiele dokumentów określonych przez zapytanie SQL przy użyciu wyzwalacza kolejki w celu dostosowania parametrów zapytania.

Wyzwalacz kolejki udostępnia parametr departmentId. Komunikat w kolejce zwraca { "departmentId" : "Finance" } wszystkie rekordy dla działu finansowego.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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; }
    }

Wyzwalacz HTTP, wyszukiwanie identyfikatora z ciągu zapytania

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera pojedynczy dokument. Funkcja jest wyzwalana przez żądanie HTTP, które używa ciągu zapytania do określenia wyszukiwanego identyfikatora. Ten identyfikator służy do pobierania ToDoItem dokumentu z określonej bazy danych i kolekcji.

Oto plik 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
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, wyszukiwanie identyfikatora z danych trasy

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera pojedynczy dokument. Funkcja jest wyzwalana przez żądanie HTTP, które używa danych tras do określenia identyfikatora do wyszukania. Ten identyfikator służy do pobierania ToDoItem dokumentu z określonej bazy danych i kolekcji.

Oto plik 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
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, uzyskiwanie wielu dokumentów przy użyciu zapytania SqlQuery

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera listę dokumentów. Funkcja jest wyzwalana przez żądanie HTTP. Zapytanie jest określone we właściwości atrybutu SqlQuery .

Oto plik 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
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, uzyskiwanie wielu dokumentów przy użyciu elementu DocumentClient

W poniższym przykładzie przedstawiono funkcję skryptu języka C#, która pobiera listę dokumentów. Funkcja jest wyzwalana przez żądanie HTTP. Kod używa wystąpienia dostarczonego DocumentClient przez powiązanie usługi Azure Cosmos DB, aby odczytać listę dokumentów. Wystąpienie DocumentClient może być również używane na potrzeby operacji zapisu.

Oto plik 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
}

Oto kod skryptu języka 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);
}

Dane wyjściowe usługi Azure Cosmos DB w wersji 1

Ta sekcja zawiera następujące przykłady:

  • Wyzwalacz kolejki, zapis jednego dokumentu
  • Wyzwalacz kolejki, zapisywanie dokumentów przy użyciu polecenia IAsyncCollector

Wyzwalacz kolejki, zapis jednego dokumentu

Poniższy przykład przedstawia powiązanie wyjściowe usługi Azure Cosmos DB w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja używa powiązania wejściowego kolejki dla kolejki, która odbiera kod JSON w następującym formacie:

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

Funkcja tworzy dokumenty usługi Azure Cosmos DB w następującym formacie dla każdego rekordu:

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

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka 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
        };
    }

Wyzwalacz kolejki, zapisywanie dokumentów przy użyciu klasy IAsyncCollector

Aby utworzyć wiele dokumentów, możesz powiązać z ICollector<T> elementem lub IAsyncCollector<T> gdzie T jest jednym z obsługiwanych typów.

W tym przykładzie odwołuje się do prostego ToDoItem typu:

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

Oto plik 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
}

Oto kod skryptu języka 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);
    }
}

Wyzwalacz usługi Azure SQL

Więcej przykładów wyzwalacza usługi Azure SQL jest dostępnych w repozytorium GitHub.

W przykładzie ToDoItem odwołuje się do klasy i odpowiedniej tabeli bazy danych:

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

Śledzenie zmian jest włączone w bazie danych i w tabeli:

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

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

Wyzwalacz SQL wiąże się z listą IReadOnlyList<SqlChange<T>>SqlChange obiektów z dwoma właściwościami:

  • Element: element, który został zmieniony. Typ elementu powinien być zgodny ze schematem tabeli, jak pokazano ToDoItem w klasie.
  • Operacja: wartość z SqlChangeOperation wyliczenia. Możliwe wartości to Insert, Update i Delete.

W poniższym przykładzie pokazano wyzwalacz SQL w pliku function.json i funkcję skryptu języka C#, która jest wywoływana po wprowadzeniu zmian w ToDo tabeli:

Poniżej przedstawiono powiązanie danych w pliku function.json:

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

Poniżej przedstawiono funkcję skryptu języka 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}");
    }
}

Dane wejściowe usługi Azure SQL

Więcej przykładów dla powiązania danych wejściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do ToDoItem klasy i odpowiedniej tabeli bazy danych:

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

Wyzwalacz HTTP, pobieranie wiersza według identyfikatora z ciągu zapytania

W poniższym przykładzie pokazano powiązanie danych wejściowych usługi Azure SQL w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja jest wyzwalana przez żądanie HTTP, które używa ciągu zapytania do określenia identyfikatora. Ten identyfikator służy do pobierania rekordu ToDoItem z określonym zapytaniem.

Uwaga

Parametr ciągu zapytania HTTP uwzględnia wielkość liter.

Oto dane powiązania w pliku 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"
}

Oto kod skryptu języka 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);
}

Wyzwalacz HTTP, usuwanie wierszy

Poniższy przykład przedstawia powiązanie wejściowe usługi Azure SQL w pliku function.json i funkcję skryptu języka C#, która używa powiązania do wykonywania procedury składowanej z danymi wejściowymi z parametru zapytania żądania HTTP. W tym przykładzie procedura składowana usuwa pojedynczy rekord lub wszystkie rekordy w zależności od wartości parametru.

Procedura dbo.DeleteToDo składowana musi zostać utworzona w bazie danych 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

Oto dane powiązania w pliku 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);
        }
    }
}

Oto kod skryptu języka 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);
}

Dane wyjściowe usługi Azure SQL

Więcej przykładów dla powiązania danych wyjściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do ToDoItem klasy i odpowiedniej tabeli bazy danych:

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

Wyzwalacz HTTP, zapisywanie rekordów w tabeli

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL w pliku function.json i funkcję skryptu języka C#, która dodaje rekordy do tabeli przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON.

Poniżej przedstawiono powiązanie danych w pliku 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"
}

Poniżej przedstawiono przykładowy kod skryptu języka 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);
}

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL w pliku function.json i funkcję skryptu języka C#, która dodaje rekordy do bazy danych w dwóch różnych tabelach (dbo.ToDo i dbo.RequestLog), przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych.

Druga tabela dbo.RequestLogodpowiada następującej definicji:

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

Poniżej przedstawiono powiązanie danych w pliku 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"
}

Poniżej przedstawiono przykładowy kod skryptu języka 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; }
}

Dane wyjściowe RabbitMQ

Poniższy przykład przedstawia powiązanie wyjściowe RabbitMQ w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja odczytuje komunikat z wyzwalacza HTTP i zwraca go do kolejki RabbitMQ.

Oto dane powiązania w pliku function.json :

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

Oto kod skryptu języka C#:

using System;
using Microsoft.Extensions.Logging;

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

Dane wyjściowe usługi SendGrid

W poniższym przykładzie pokazano powiązanie wyjściowe usługi SendGrid w pliku function.json i funkcję skryptu języka C#, która używa powiązania.

Oto dane powiązania w pliku 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}"
        }
    ]
}

Oto kod skryptu języka 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; }
}

Wyzwalacz signalR

Oto przykładowe dane powiązania w pliku function.json :

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

Oto kod:

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

Dane wejściowe usługi SignalR

Poniższy przykład przedstawia powiązanie wejściowe informacji o połączeniu usługi SignalR w pliku function.json i funkcję skryptu języka C#, która używa powiązania w celu zwrócenia informacji o połączeniu.

Oto dane powiązania w pliku function.json :

Przykład function.json:

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

Oto kod skryptu języka C#:

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

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

Właściwość powiązania można ustawić userId na wartość z nagłówka przy użyciu wyrażenia powiązania: {headers.x-ms-client-principal-id} lub {headers.x-ms-client-principal-name}.

Przykład 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"
}

Oto kod skryptu języka 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;
}

Dane wyjściowe usługi SignalR

Oto dane powiązania w pliku function.json :

Przykład function.json:

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

Oto kod skryptu języka 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 }
        });
}

Komunikat można wysłać tylko do połączeń, które zostały uwierzytelnione dla użytkownika, ustawiając identyfikator użytkownika w komunikacie usługi SignalR.

Przykład function.json:

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

Oto kod skryptu języka 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 }
        });
}

Komunikat można wysłać tylko do połączeń, które zostały dodane do grupy, ustawiając nazwę grupy w komunikacie usługi SignalR.

Przykład function.json:

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

Oto kod skryptu języka 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 }
        });
}

Usługa SignalR Service umożliwia dodawanie użytkowników lub połączeń do grup. Komunikaty można następnie wysyłać do grupy. Do zarządzania grupami można użyć powiązania wyjściowego SignalR .

Poniższy przykład dodaje użytkownika do grupy.

Przykład 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
        });
}

Poniższy przykład usuwa użytkownika z grupy.

Przykład 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
        });
}

Dane wyjściowe usługi Twilio

Poniższy przykład przedstawia powiązanie wyjściowe usługi Twilio w pliku function.json i funkcję skryptu języka C#, która używa powiązania. Funkcja używa parametru out do wysyłania wiadomości SMS.

Oto dane powiązania w pliku function.json :

Przykład function.json:

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

Oto kod skryptu języka 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;
}

Nie można używać parametrów w kodzie asynchronicznym. Oto przykład kodu skryptu asynchronicznego języka 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);
}

Wyzwalacz rozgrzewania

W poniższym przykładzie pokazano wyzwalacz rozgrzewki w pliku function.json i funkcję skryptu języka C#, która jest uruchamiana w każdym nowym wystąpieniu po dodaniu go do aplikacji.

Nieobsługiwane w wersji 1.x środowiska uruchomieniowego usługi Functions.

Oto plik function.json:

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

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

Następne kroki

Dowiedz się więcej o wyzwalaczach i powiązaniach

Dowiedz się więcej o najlepszych rozwiązaniach dotyczących usługi Azure Functions