Referência do desenvolvedor do script C# do Azure Functions (.csx)

Este artigo é uma introdução ao desenvolvimento do Azure Functions usando o script C# (.csx).

O Azure Functions permite desenvolver funções usando C# de uma das seguintes maneiras:

Como funciona o .csx

Os dados fluem para sua função C# por meio de argumentos de método. Os nomes de argumento são especificados em um function.json arquivo e há nomes predefinidos para acessar coisas como o registrador de funções e os tokens de cancelamento.

O formato .csx permite que você escreva menos "clichê" e se concentre em escrever apenas uma função C#. Em vez de envolver tudo em um namespace e classe, basta definir um Run método. Inclua quaisquer referências de assembly e namespaces no início do arquivo, como de costume.

Os arquivos .csx de um aplicativo de função são compilados quando uma instância é inicializada. Esta etapa de compilação significa que coisas como início a frio podem levar mais tempo para funções de script C# em comparação com bibliotecas de classe C#. Esta etapa de compilação também é o motivo pelo qual as funções de script C# são editáveis no portal do Azure, enquanto as bibliotecas de classe C# não são.

Estrutura de pastas

A estrutura de pastas para um projeto de script C# se parece com o exemplo a seguir:

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

Há um arquivo de host.json compartilhado que pode ser usado para configurar o aplicativo de função. Cada função tem seu próprio arquivo de código (.csx) e arquivo de configuração de vinculação (function.json).

As extensões de vinculação necessárias na versão 2.x e versões posteriores do tempo de execução do Functions são definidas no extensions.csproj arquivo, com os arquivos de biblioteca reais na bin pasta. Ao desenvolver localmente, você deve registrar extensões de vinculação. Quando você desenvolve funções no portal do Azure, esse registro é feito para você.

Vinculação a argumentos

Os dados de entrada ou saída são vinculados a um parâmetro de função de script C# por meio da name propriedade no arquivo de configuração function.json . O exemplo a seguir mostra um arquivo function.json e um arquivo run.csx para uma função acionada por fila. O parâmetro que recebe dados da mensagem de fila é nomeado myQueueItem porque esse é o valor da name propriedade.

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

A #r afirmação é explicada mais adiante neste artigo.

Tipos suportados para ligações

Cada ligação tem seus próprios tipos suportados; por exemplo, um gatilho de blob pode ser usado com um parâmetro string, um parâmetro POCO, um CloudBlockBlob parâmetro ou qualquer um dos vários outros tipos suportados. O artigo de referência de vinculação para associações de blob lista todos os tipos de parâmetros suportados para gatilhos de blob. Para obter mais informações, consulte Gatilhos e ligações e os documentos de referência de vinculação para cada tipo de associação.

Fazendo referência a classes personalizadas

Se você precisar usar uma classe Plain Old CLR Object (POCO) personalizada, poderá incluir a definição de classe dentro do mesmo arquivo ou colocá-la em um arquivo separado.

O exemplo a seguir mostra um exemplo run.csx que inclui uma definição de classe 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; }
}

Uma classe POCO deve ter um getter e setter definidos para cada propriedade.

Reutilizando o código .csx

Você pode usar classes e métodos definidos em outros arquivos .csx em seu arquivo run.csx . Para fazer isso, use #load diretivas em seu arquivo run.csx . No exemplo a seguir, uma rotina de log nomeada MyLogger é compartilhada em myLogger.csx e carregada em run.csx usando a #load diretiva :

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

Exemplo mylogger.csx:

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

Usar um arquivo .csx compartilhado é um padrão comum quando você deseja digitar fortemente os dados passados entre funções usando um objeto POCO. No exemplo simplificado a seguir, um gatilho HTTP e um gatilho de fila compartilham um objeto POCO nomeado Order para digitar fortemente os dados do pedido:

Exemplo run.csx para gatilho 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);
    }
}

Exemplo run.csx para gatilho de fila:

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

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

Você pode usar um caminho relativo com a #load diretiva:

• #load "mylogger.csx" Carrega um arquivo localizado na pasta de funções.
• #load "loadedfiles\mylogger.csx" Carrega um arquivo localizado em uma pasta na pasta de função.
• #load "..\shared\mylogger.csx" Carrega um arquivo localizado em uma pasta no mesmo nível da pasta de função, ou seja, diretamente em wwwroot.

A #load diretiva funciona apenas com arquivos .csx , não com arquivos .cs .

Vinculação ao valor de retorno do método

Você pode usar um valor de retorno de método para uma associação de saída, usando o nome $return em function.json.

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

Aqui está o código de script C# usando o valor de retorno, seguido por um exemplo assíncrono:

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

Use o valor de retorno somente se uma execução de função bem-sucedida sempre resultar em um valor de retorno para passar para a associação de saída. Caso contrário, use ICollector ou IAsyncCollector, conforme mostrado na seção a seguir.

Gravando vários valores de saída

Para gravar vários valores em uma ligação de saída, ou se uma invocação de função bem-sucedida pode não resultar em nada para passar para a associação de saída, use os ICollector tipos ou IAsyncCollector . Esses tipos são coleções somente gravação que são gravadas na associação de saída quando o método é concluído.

Este exemplo grava várias mensagens de fila na mesma fila usando ICollector:

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

Registo

Para registrar a saída em seus logs de streaming em C#, inclua um argumento do tipo ILogger. Recomendamos que você nomeie .log Evite usar Console.Write no Azure Functions.

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

Registro de métricas personalizadas

Você pode usar o LogMetric método de extensão para ILogger criar métricas personalizadas no Application Insights. Aqui está uma chamada de método de exemplo:

logger.LogMetric("TestMetric", 1234);

Esse código é uma alternativa à chamada TrackMetric usando a API do Application Insights para .NET.

Assíncrono

Para tornar uma função assíncrona, use a async palavra-chave e retorne um Task objeto.

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

Não é possível usar out parâmetros em funções assíncronas. Para ligações de saída, use o valor de retorno da função ou um objeto coletor.

Tokens de cancelamento

Uma função pode aceitar um parâmetro CancellationToken , que permite que o sistema operacional notifique seu código quando a função estiver prestes a ser encerrada. Você pode usar essa notificação para garantir que a função não seja encerrada inesperadamente de uma forma que deixe os dados em um estado inconsistente.

O exemplo a seguir mostra como verificar o encerramento iminente da função.

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

Importando namespaces

Se precisar importar namespaces, você pode fazê-lo como de costume, com a using cláusula.

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

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

Os namespaces a seguir são importados automaticamente e, portanto, opcionais:

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

Fazendo referência a assemblies externos

Para assemblies de estrutura, adicione referências usando a #r "AssemblyName" diretiva .

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

Os assemblies a seguir são adicionados automaticamente pelo ambiente de hospedagem do 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

Os seguintes assemblies podem ser referenciados por nome simples, por versão de tempo de execução:

No código, os assemblies são referenciados como o exemplo a seguir:

#r "AssemblyName"

Fazendo referência a assemblies personalizados

Para fazer referência a um assembly personalizado, você pode usar um assembly compartilhado ou um assembly privado :

• Os assemblies compartilhados são compartilhados em todas as funções dentro de um aplicativo de função. Para fazer referência a um assembly personalizado, carregue o assembly em uma pasta nomeada bin na pasta raiz (wwwroot) do seu aplicativo de função.

• Os assemblies privados fazem parte do contexto de uma determinada função e suportam sideload de diferentes versões. Os assemblies privados devem ser carregados em uma bin pasta no diretório de funções. Faça referência aos assemblies usando o nome do arquivo, como #r "MyAssembly.dll".

Para obter informações sobre como carregar arquivos para sua pasta de funções, consulte a seção sobre gerenciamento de pacotes.

Diretórios assistidos

O diretório que contém o arquivo de script de função é automaticamente observado para alterações em assemblies. Para observar as alterações de assembly em outros diretórios, adicione-as watchDirectories à lista em host.json.

Usando pacotes NuGet

A maneira como os pacotes de extensão de vinculação e outros pacotes NuGet são adicionados ao seu aplicativo de função depende da versão de destino do tempo de execução do Functions.

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

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

Para usar um feed NuGet personalizado, especifique o feed em um arquivo Nuget.Config na pasta raiz do aplicativo de função. Para obter mais informações, consulte Configurando o comportamento do NuGet.

Se você estiver trabalhando em seu projeto apenas no portal, precisará criar manualmente o arquivo extensions.csproj ou um arquivo Nuget.Config diretamente no site. Para saber mais, consulte Instalar extensões manualmente.

Variáveis de ambiente

Para obter uma variável de ambiente ou um valor de configuração de aplicativo, use System.Environment.GetEnvironmentVariable, conforme mostrado no exemplo de código a seguir:

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

Repetir políticas

O Functions suporta duas políticas de repetição incorporadas. Para obter mais informações, consulte Repetir políticas.

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

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

Vinculação em tempo de execução

Em C# e outras linguagens .NET, você pode usar um padrão de vinculação imperativa , em oposição às associações declarativas no function.json. A vinculação imperativa é útil quando os parâmetros de vinculação precisam ser calculados em tempo de execução em vez de tempo de design. Com esse padrão, você pode vincular ligações de entrada e saída suportadas on-the-fly em seu código de função.

Defina uma ligação imperativa da seguinte forma:

• Não inclua uma entrada no function.json para as ligações imperativas desejadas.
• Passe um parâmetro Binder binder de entrada ou IBinder binder.
• Use o seguinte padrão C# para executar a associação de dados.

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

BindingTypeAttribute é o atributo .NET que define sua associação e T é um tipo de entrada ou saída suportado por esse tipo de associação. T não pode ser um tipo de out parâmetro (como out JObject). Por exemplo, a ligação de saída da tabela Aplicativos Móveis suporta seis tipos de saída, mas você só pode usar ICollector<T> ou IAsyncCollector<T> para T.

Exemplo de atributo único

O código de exemplo a seguir cria uma ligação de saída de blob de armazenamento com caminho de blob definido em tempo de execução e, em seguida, grava uma cadeia de caracteres no blob.

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

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

BlobAttribute define a ligação de entrada ou saída do blob de armazenamento e TextWriter é um tipo de ligação de saída suportado.

Exemplo de vários atributos

O exemplo anterior obtém a configuração do aplicativo para a cadeia de conexão principal da conta de armazenamento do aplicativo de função (que é AzureWebJobsStorage). Você pode especificar uma configuração de aplicativo personalizada a ser usada para a conta de armazenamento adicionando o StorageAccountAttribute e passando a matriz de atributos para BindAsync<T>(). Use um Binder parâmetro, não IBinder. Por exemplo:

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

A tabela a seguir lista os atributos .NET para cada tipo de associação e os pacotes nos quais eles são definidos.

Converter um aplicativo de script C# em um projeto C#

A maneira mais fácil de converter um aplicativo de função de script C# em um projeto de biblioteca de classes C# compilado é começar com um novo projeto. Você pode, então, para cada função, migrar o código e a configuração de cada arquivo run.csx e function.json arquivo em uma pasta de função para um único novo arquivo de código de biblioteca de classes .cs. Por exemplo, quando você tem uma função de script C# nomeada HelloWorld , você terá dois arquivos: HelloWorld/run.csx e HelloWorld/function.json. Para essa função, você cria um arquivo de código nomeado HelloWorld.cs em seu novo projeto de biblioteca de classes.

Se você estiver usando scripts C# para edição de portal, poderá baixar o conteúdo do aplicativo para sua máquina local. Escolha a opção Conteúdo do site em vez do projeto Conteúdo e Visual Studio. Você não precisa gerar um projeto e não inclui configurações do aplicativo no download. Você está definindo um novo ambiente de desenvolvimento, e esse ambiente não deve ter as mesmas permissões que seu ambiente de aplicativo hospedado.

Estas instruções mostram como converter funções de script C# (que são executadas em processo com o host Functions) em funções de biblioteca de classes C# que são executadas em um processo de trabalho isolado.

1. Conclua a seção Criar um projeto de aplicativo de funções no início rápido de sua preferência:

   • CLI do Azure
   • Visual Studio
   • Visual Studio Code

   Criar uma função C# no Azure a partir da linha de comando

2. Se o código de script C# original incluir um extensions.csproj arquivo ou quaisquer function.proj arquivos, copie as referências de pacote desses arquivos e adicione-as ao arquivo do novo projeto no mesmo ItemGroup com as dependências .csproj principais do Functions.

   Gorjeta

   A conversão oferece uma boa oportunidade para atualizar para as versões mais recentes de suas dependências. Isso pode exigir alterações adicionais no código em uma etapa posterior.

3. Copie o conteúdo do arquivo original host.json para o arquivo do novo projeto host.json , exceto para a extensionBundles seção (projetos C# compilados não usam pacotes de extensão e você deve adicionar explicitamente referências a todas as extensões usadas por suas funções). Ao mesclar arquivos host.json, lembre-se de que o esquema é versionado, com a maioria dos aplicativos usando a host.json versão 2.0. O conteúdo da extensions seção pode diferir com base em versões específicas das extensões de vinculação usadas por suas funções. Consulte artigos de referência de extensão individuais para saber como configurar corretamente o host.json para suas versões específicas.

4. Para todos os arquivos compartilhados referenciados por uma diretiva, crie um novo .cs arquivo para cada uma #load dessas referências compartilhadas. É mais simples criar um novo .cs arquivo para cada definição de classe compartilhada. Se houver métodos estáticos sem uma classe, você precisará definir novas classes para esses métodos.

5. Execute as seguintes tarefas para cada <FUNCTION_NAME> pasta no seu projeto original:

   1. Crie um novo arquivo chamado <FUNCTION_NAME>.cs, substituindo <FUNCTION_NAME> pelo nome da pasta que definiu sua função de script C#. Você pode criar um novo arquivo de código de função a partir de um dos modelos específicos do gatilho da seguinte maneira:

      • CLI do Azure
      • Visual Studio
      • Visual Studio Code

      Usando o func new --name <FUNCTION_NAME> comando e escolhendo o modelo de gatilho correto no prompt.

   2. Copie as using instruções do seu run.csx arquivo e adicione-as ao novo arquivo. Não precisa de diretivas #r .

   3. Para qualquer #load instrução em seu run.csx arquivo, adicione uma nova using instrução para o namespace que você usou para o código compartilhado.

   4. No novo arquivo, defina uma classe para sua função sob o namespace que você está usando para o projeto.

   5. Crie um novo método chamado RunHandler ou algo semelhante. Este novo método serve como o novo ponto de entrada para a função.

   6. Copie o método estático que representa sua função, juntamente com quaisquer funções que ele chama, de run.csx sua nova classe como um segundo método. A partir do novo método criado na etapa anterior, chame esse método estático. Esta etapa de indireção é útil para navegar por quaisquer diferenças à medida que você continua a atualização. Você pode manter o método original exatamente igual e simplesmente controlar suas entradas a partir do novo contexto. Talvez seja necessário criar parâmetros no novo método que, em seguida, você passa para a chamada de método estático. Depois de confirmar que a migração funcionou como pretendido, você pode remover esse nível extra de indireção.

   7. Para cada associação no function.json arquivo, adicione o atributo correspondente ao seu novo método. Para encontrar rapidamente exemplos de vinculação, consulte Adicionar associações manualmente com base em exemplos.

   8. Adicione quaisquer pacotes de extensão exigidos pelas associações ao seu projeto, se ainda não o tiver feito.

6. Recrie todas as Values configurações do aplicativo exigidas pelo seu aplicativo na coleção do arquivo local.settings.json.

7. Verifique se o projeto é executado localmente:

   • CLI do Azure
   • Visual Studio
   • Visual Studio Code

   Use func start para executar seu aplicativo a partir da linha de comando. Para obter mais informações, consulte Executar funções localmente.

8. Publique seu projeto em um novo aplicativo de função no Azure:

   • CLI do Azure
   • Visual Studio
   • Visual Studio Code

   Crie seus recursos do Azure e implante o projeto de código no Azure usando o func azure functionapp publish <APP_NAME> comando. Para obter mais informações, consulte Implantar arquivos de projeto.

Exemplo de conversão de função

Esta seção mostra um exemplo da migração para uma única função.

A função original no script C# tem dois arquivos:

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

Os conteúdos são HelloWorld/function.json :

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

Os conteúdos são HelloWorld/run.csx :

#r "Newtonsoft.Json"

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

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

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

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

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

            return new OkObjectResult(responseMessage);
}

Depois de migrar para o modelo de trabalho isolado com integração ASP.NET Core, eles são substituídos por um único 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);
        }
    }
}

Configuração de vinculação e exemplos

Esta seção contém referências e exemplos para definir gatilhos e associações no script C#.

Blob trigger

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra uma definição de gatilho de blob em um arquivo function.json e código que usa a ligação. A função grava um log quando um blob é adicionado ou atualizado no samples-workitems contêiner.

Aqui estão os dados de ligação no arquivo function.json :

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

A cadeia de caracteres {name} no caminho samples-workitems/{name} do gatilho de blob cria uma expressão de vinculação que você pode usar no código da função para acessar o nome do arquivo do blob de acionamento. Para obter mais informações, consulte Padrões de nome de blob.

Aqui está o código de script C# que se liga a um 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");
}

Aqui está o código de script C# que se liga a um 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}");
}

Entrada de Blob

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra associações de entrada e saída de blob em um arquivo function.json e código de script C# que usa as associações. A função faz uma cópia de um blob de texto. A função é acionada por uma mensagem de fila que contém o nome do blob a ser copiado. O novo blob é chamado {originalblobname}-Copy.

No arquivo function.json, a queueTrigger propriedade de metadados é usada para especificar o nome do blob nas path propriedades:

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

Aqui está o código de script C#:

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

Saída de Blob

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra associações de entrada e saída de blob em um arquivo function.json e código de script C# que usa as associações. A função faz uma cópia de um blob de texto. A função é acionada por uma mensagem de fila que contém o nome do blob a ser copiado. O novo blob é chamado {originalblobname}-Copy.

No arquivo function.json, a queueTrigger propriedade de metadados é usada para especificar o nome do blob nas path propriedades:

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

Aqui está o código de script C#:

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

Gatilho RabbitMQ

O exemplo a seguir mostra uma ligação de gatilho RabbitMQ em um arquivo function.json e uma função de script C# que usa a ligação. A função lê e registra a mensagem RabbitMQ.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script C#:

using System;

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

Queue trigger

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra uma ligação de gatilho de fila em um arquivo function.json e código de script C# que usa a ligação. A função sonda a fila myqueue-items e grava um log cada vez que um item de fila é processado.

Aqui está o arquivo function.json :

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

Aqui está o código de script 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}");
}

Saída da fila

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra uma ligação de gatilho HTTP em um arquivo function.json e código de script C# que usa a ligação. A função cria um item de fila com uma carga útil do objeto CustomQueueMessage para cada solicitação HTTP recebida.

Aqui está o arquivo 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"
    }
  ]
}

Aqui está o código de script C# que cria uma única mensagem de fila:

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

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

Você pode enviar várias mensagens de uma só vez usando um ICollector parâmetro ou IAsyncCollector . Aqui está o código de script C# que envia várias mensagens, uma com os dados de solicitação HTTP e outra com valores codificados:

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

Entrada de tabela

Esta seção descreve o suporte apenas para a versão da API de tabelas da extensão .

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra uma associação de entrada de tabela em um arquivo function.json e código de script C# que usa a associação. A função usa um gatilho de fila para ler uma única linha de tabela.

O arquivo function.json especifica a partitionKey e a rowKey. O rowKey valor {queueTrigger} indica que a chave de linha vem da cadeia de caracteres de mensagem da fila.

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

Aqui está o código de script 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; }
}

Saída da tabela

Esta seção descreve o suporte apenas para a versão da API de tabelas da extensão .

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra uma ligação de saída de tabela em um arquivo function.json e código de script C# que usa a ligação. A função grava várias entidades de tabela.

Aqui está o arquivo function.json :

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

Aqui está o código de script 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; }
}

Acionador de temporizador

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra uma ligação de gatilho de temporizador em um arquivo function.json e uma função de script C# que usa a ligação. A função grava um log indicando se essa invocação de função é devido a uma ocorrência de agenda perdida. O TimerInfo objeto é passado para a função.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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}" );  
}

Acionador HTTP

A tabela a seguir explica as propriedades de configuração de gatilho definidas no arquivo function.json :

O exemplo a seguir mostra uma ligação de gatilho em um arquivo function.json e uma função de script C# que usa a ligação. A função procura um name parâmetro na cadeia de caracteres de consulta ou no corpo da solicitação HTTP.

Aqui está o arquivo function.json :

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

Aqui está o código de script C# que se liga a 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");
}

Você pode vincular a um objeto personalizado em vez de HttpRequest. Este objeto é criado a partir do corpo da solicitação e analisado como JSON. Da mesma forma, um tipo pode ser passado para a ligação de saída de resposta HTTP e retornado como o corpo da resposta, juntamente com um código de 200 status.

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

Saída HTTP

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

Os Hubs de Eventos disparam

A tabela a seguir explica as propriedades de configuração de gatilho definidas no arquivo function.json :

O exemplo a seguir mostra uma ligação de gatilho de Hubs de Eventos em um arquivo function.json e uma função de script C# que usa a ligação. A função registra o corpo da mensagem do gatilho Hubs de Eventos.

Os exemplos a seguir mostram dados de vinculação de Hubs de Eventos no arquivo function.json para o tempo de execução do Functions versão 2.x e versões posteriores.

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

Aqui está o código de script C#:

using System;

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

Para obter acesso aos metadados do evento no código da função, associe-se a um objeto EventData . Você também pode acessar as mesmas propriedades usando expressões de associação na assinatura do método. O exemplo a seguir mostra as duas maneiras de obter os mesmos dados:

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

Para receber eventos em um lote, marca string ou EventData matriz:

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

Saída de Hubs de Eventos

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

O exemplo a seguir mostra uma ligação de gatilho de hub de eventos em um arquivo function.json e uma função de script C# que usa a ligação. A função grava uma mensagem em um hub de eventos.

Os exemplos a seguir mostram dados de vinculação de Hubs de Eventos no arquivo function.json para o tempo de execução do Functions versão 2.x e versões posteriores.

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

Aqui está o código de script C# que cria uma mensagem:

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

Aqui está o código de script C# que cria várias mensagens:

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

Event Grid trigger

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json . Não há parâmetros ou propriedades do construtor para definir no EventGridTrigger atributo.

O exemplo a seguir mostra um gatilho de Grade de Eventos definido no arquivo function.json .

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está um exemplo de uma função de script C# que usa um EventGridEvent parâmetro de ligação:

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

Aqui está um exemplo de uma função de script C# que usa um JObject parâmetro de ligação:

#r "Newtonsoft.Json"

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

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

Saída da grade de eventos

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

O exemplo a seguir mostra os dados de vinculação de saída da Grade de Eventos no arquivo function.json .

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

Aqui está o código de script C# que cria um evento:

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

Aqui está o código de script C# que cria vários eventos:

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

Gatilho do Service Bus

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

O exemplo a seguir mostra uma ligação de gatilho do Service Bus em um arquivo function.json e uma função de script C# que usa a associação. A função lê metadados de mensagem e registra uma mensagem de fila do Service Bus.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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}");
}

Saída do Service Bus

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

O exemplo a seguir mostra uma ligação de saída do Service Bus em um arquivo function.json e uma função de script C# que usa a ligação. A função usa um gatilho de temporizador para enviar uma mensagem de fila a cada 15 segundos.

Aqui estão os dados de ligação no arquivo 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
}

Aqui está o código de script C# que cria uma única mensagem:

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

Aqui está o código de script C# que cria várias mensagens:

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

Gatilho do Azure Cosmos DB v2

Esta seção descreve o suporte apenas para a versão 4.x+ da extensão .

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

O exemplo a seguir mostra uma associação de gatilho do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função grava mensagens de log quando os registros do Azure Cosmos DB são adicionados ou modificados.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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);
    }

Entrada do Azure Cosmos DB v2

Esta seção descreve o suporte apenas para a versão 4.x+ da extensão .

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

Esta seção contém os seguintes exemplos:

• Gatilho de fila, procurar ID da string
• Gatilho de fila, obter vários documentos, usando SqlQuery
• Gatilho HTTP, ID de pesquisa da cadeia de caracteres de consulta
• Gatilho HTTP, procure ID a partir de dados de rota
• HTTP trigger, obter vários documentos, usando SqlQuery
• Gatilho HTTP, obtenha vários documentos, usando DocumentClient

Os exemplos de gatilho HTTP referem-se a um tipo simples ToDoItem :

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

Gatilho de fila, procurar ID da string

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função lê um único documento e atualiza o valor de texto do documento.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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.";
    }

Gatilho de fila, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função recupera vários documentos especificados por uma consulta SQL, usando um gatilho de fila para personalizar os parâmetros de consulta.

O gatilho de fila fornece um parâmetro departmentId. Uma mensagem de fila de { "departmentId" : "Finance" } retornaria todos os registros para o departamento financeiro.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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; }
    }

Gatilho HTTP, ID de pesquisa da cadeia de caracteres de consulta

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar o ID e o valor da chave de partição a serem pesquisados. Esse ID e o valor da chave de partição são usados para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

Gatilho HTTP, procure ID a partir de dados de rota

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por uma solicitação HTTP que usa dados de rota para especificar o ID e o valor da chave de partição a serem pesquisados. Esse ID e o valor da chave de partição são usados para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

HTTP trigger, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. A consulta é especificada na SqlQuery propriedade atributo.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

Gatilho HTTP, obtenha vários documentos, usando DocumentClient

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. O código usa uma DocumentClient instância fornecida pela associação do Azure Cosmos DB para ler uma lista de documentos. A DocumentClient instância também pode ser usada para operações de gravação.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

Saída do Azure Cosmos DB v2

Esta seção descreve o suporte apenas para a versão 4.x+ da extensão .

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

Esta seção contém os seguintes exemplos:

• Gatilho de fila, escreva um documento
• Gatilho de fila, escrever documentos usando IAsyncCollector

Gatilho de fila, escreva um documento

O exemplo a seguir mostra uma ligação de saída do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função usa uma ligação de entrada de fila para uma fila que recebe JSON no seguinte formato:

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

A função cria documentos do Azure Cosmos DB no seguinte formato para cada registro:

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

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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
      };
    }

Gatilho de fila, escrever documentos usando IAsyncCollector

Para criar vários documentos, você pode vincular a ICollector<T> ou IAsyncCollector<T> onde T é um dos tipos suportados.

Este exemplo refere-se a um tipo simples ToDoItem :

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

Aqui está o arquivo 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
}

Aqui está o código de script 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);
    }
}

Gatilho do Azure Cosmos DB v1

O exemplo a seguir mostra uma associação de gatilho do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função grava mensagens de log quando os registros do Azure Cosmos DB são modificados.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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);
    }

Entrada do Azure Cosmos DB v1

Esta seção contém os seguintes exemplos:

• Gatilho de fila, procurar ID da string
• Gatilho de fila, obter vários documentos, usando SqlQuery
• Gatilho HTTP, ID de pesquisa da cadeia de caracteres de consulta
• Gatilho HTTP, procure ID a partir de dados de rota
• HTTP trigger, obter vários documentos, usando SqlQuery
• Gatilho HTTP, obtenha vários documentos, usando DocumentClient

Os exemplos de gatilho HTTP referem-se a um tipo simples ToDoItem :

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

Gatilho de fila, procurar ID da string

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função lê um único documento e atualiza o valor de texto do documento.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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.";
    }

Gatilho de fila, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função recupera vários documentos especificados por uma consulta SQL, usando um gatilho de fila para personalizar os parâmetros de consulta.

O gatilho de fila fornece um parâmetro departmentId. Uma mensagem de fila de { "departmentId" : "Finance" } retornaria todos os registros para o departamento financeiro.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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; }
    }

Gatilho HTTP, ID de pesquisa da cadeia de caracteres de consulta

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por um pedido HTTP que utiliza uma cadeia de consulta para especificar o ID a procurar. Esse ID é usado para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

Gatilho HTTP, procure ID a partir de dados de rota

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por uma solicitação HTTP que usa dados de rota para especificar o ID a ser pesquisado. Esse ID é usado para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

HTTP trigger, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. A consulta é especificada na SqlQuery propriedade atributo.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

Gatilho HTTP, obtenha vários documentos, usando DocumentClient

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. O código usa uma DocumentClient instância fornecida pela associação do Azure Cosmos DB para ler uma lista de documentos. A DocumentClient instância também pode ser usada para operações de gravação.

Aqui está o arquivo 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
}

Aqui está o código de script 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);
}

Saída do Azure Cosmos DB v1

Esta seção contém os seguintes exemplos:

• Gatilho de fila, escreva um documento
• Gatilho de fila, escreva documentos usando IAsyncCollector

Gatilho de fila, escreva um documento

O exemplo a seguir mostra uma ligação de saída do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função usa uma ligação de entrada de fila para uma fila que recebe JSON no seguinte formato:

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

A função cria documentos do Azure Cosmos DB no seguinte formato para cada registro:

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

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script 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
        };
    }

Gatilho de fila, escrever documentos usando IAsyncCollector

Para criar vários documentos, você pode vincular a ICollector<T> ou IAsyncCollector<T> onde T é um dos tipos suportados.

Este exemplo refere-se a um tipo simples ToDoItem :

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

Aqui está o arquivo 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
}

Aqui está o código de script 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);
    }
}

Gatilho SQL do Azure

Mais exemplos para o gatilho SQL do Azure estão disponíveis no repositório GitHub.

O exemplo refere-se a uma ToDoItem classe e uma tabela de banco de dados correspondente:

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

O controlo de alterações está ativado na base de dados e na tabela:

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

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

O gatilho SQL se liga a um IReadOnlyList<SqlChange<T>>, uma lista de SqlChange objetos cada um com duas propriedades:

• Item: o item que foi alterado. O tipo do item deve seguir o esquema de tabela como visto na ToDoItem classe.
• Operação: um valor de SqlChangeOperation enum. Os valores possíveis são Insert, Updatee Delete.

O exemplo a seguir mostra um gatilho SQL em um arquivo function.json e uma função de script C# que é invocada quando há alterações na ToDo tabela:

O seguinte é a vinculação de dados no arquivo function.json:

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

A seguinte é a função de script 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}");
    }
}

Entrada SQL do Azure

Mais exemplos para a associação de entrada SQL do Azure estão disponíveis no repositório GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter linha por ID da cadeia de caracteres de consulta
• Gatilho HTTP, excluir linhas

Os exemplos referem-se a uma ToDoItem classe e a uma tabela de banco de dados correspondente:

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

Gatilho HTTP, obter linha por ID da cadeia de caracteres de consulta

O exemplo a seguir mostra uma associação de entrada SQL do Azure em um arquivo function.json e uma função de script C# que usa a associação. A função é acionada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID. Esse ID é usado para recuperar um ToDoItem registro com a consulta especificada.

Aqui estão os dados de ligação no arquivo 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"
}

Aqui está o código de script 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);
}

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma associação de entrada SQL do Azure em um arquivo function.json e uma função de script C# que usa a associação para executar um procedimento armazenado com entrada do parâmetro de consulta de solicitação HTTP. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

O procedimento dbo.DeleteToDo armazenado deve ser criado no banco de dados 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

Aqui estão os dados de ligação no arquivo 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);
        }
    }
}

Aqui está o código de script 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);
}

Saída SQL do Azure

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, gravar registros em uma tabela
• Gatilho HTTP, gravar em duas tabelas

Os exemplos referem-se a uma ToDoItem classe e a uma tabela de banco de dados correspondente:

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

Gatilho HTTP, gravar registros em uma tabela

O exemplo a seguir mostra uma ligação de saída SQL em um arquivo function.json e uma função de script C# que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

O seguinte é a vinculação de dados no arquivo 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"
}

Segue-se um exemplo de código de script 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);
}

Gatilho HTTP, gravar em duas tabelas

O exemplo a seguir mostra uma ligação de saída SQL em um arquivo function.json e uma função de script C# que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias ligações de saída.

O segundo quadro, dbo.RequestLog, corresponde à seguinte definição:

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

O seguinte é a vinculação de dados no arquivo 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"
}

Segue-se um exemplo de código de script 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; }
}

Saída RabbitMQ

O exemplo a seguir mostra uma ligação de saída RabbitMQ em um arquivo function.json e uma função de script C# que usa a ligação. A função lê a mensagem de um gatilho HTTP e a envia para a fila RabbitMQ.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código de script C#:

using System;
using Microsoft.Extensions.Logging;

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

Saída SendGrid

O exemplo a seguir mostra uma ligação de saída SendGrid em um arquivo function.json e uma função de script C# que usa a ligação.

Aqui estão os dados de ligação no arquivo 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}"
        }
    ]
}

Aqui está o código de script 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; }
}

Gatilho SignalR

Veja um exemplo de dados de vinculação no arquivo function.json :

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

E, aqui está o código:

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

Entrada SignalR

O exemplo a seguir mostra uma ligação de entrada de informações de conexão SignalR em um arquivo function.json e uma função de script C# que usa a associação para retornar as informações de conexão.

Aqui estão os dados de vinculação no arquivo function.json :

Exemplo function.json:

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

Aqui está o código de script C#:

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

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

Você pode definir a userId propriedade da associação para o valor de qualquer cabeçalho usando uma expressão de ligação: {headers.x-ms-client-principal-id} ou {headers.x-ms-client-principal-name}.

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

Aqui está o código de script 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;
}

Saída SignalR

Aqui estão os dados de vinculação no arquivo function.json :

Exemplo function.json:

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

Aqui está o código de script 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 }
        });
}

Você pode enviar uma mensagem somente para conexões que foram autenticadas para um usuário definindo o ID do usuário na mensagem do SignalR.

Exemplo function.json:

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

Aqui está o código de script 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 }
        });
}

Você pode enviar uma mensagem somente para conexões que foram adicionadas a um grupo definindo o nome do grupo na mensagem SignalR.

Exemplo function.json:

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

Aqui está o código de script 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 }
        });
}

O Serviço SignalR permite que usuários ou conexões sejam adicionados a grupos. As mensagens podem então ser enviadas para um grupo. Você pode usar a SignalR associação de saída para gerenciar grupos.

O exemplo a seguir adiciona um usuário a um grupo.

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

O exemplo a seguir remove um usuário de um grupo.

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

Saída Twilio

O exemplo a seguir mostra uma ligação de saída Twilio em um arquivo function.json e uma função de script C# que usa a ligação. A função usa um out parâmetro para enviar uma mensagem de texto.

Aqui estão os dados de vinculação no arquivo function.json :

Exemplo function.json:

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

Aqui está o código de script 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;
}

Não é possível usar parâmetros em código assíncrono. Aqui está um exemplo de código de script C# assíncrono:

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

Gatilho de aquecimento

O exemplo a seguir mostra um gatilho de aquecimento em um arquivo function.json e uma função de script C# que é executada em cada nova instância quando é adicionada ao seu aplicativo.

Não suportado para a versão 1.x do tempo de execução do Functions.

Aqui está o arquivo function.json :

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

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

Próximos passos